NetBSD/sys/dev/ppbus/ppbus_base.c

/* $NetBSD: ppbus_base.c,v 1.17 2008/04/15 15:02:29 cegger Exp $ */

/*-
 * Copyright (c) 1997, 1998, 1999 Nicolas Souchu
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 * FreeBSD: src/sys/dev/ppbus/ppb_base.c,v 1.10.2.1 2000/08/01 23:26:26 n_hibma Exp
 *
 */

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: ppbus_base.c,v 1.17 2008/04/15 15:02:29 cegger Exp $");

#include "opt_ppbus_1284.h"
#include "opt_ppbus.h"

#include <sys/param.h>
#include <sys/kernel.h>
#include <sys/malloc.h>
#include <sys/proc.h>
#include <sys/systm.h>

#include <dev/ppbus/ppbus_1284.h>
#include <dev/ppbus/ppbus_conf.h>
#include <dev/ppbus/ppbus_base.h>
#include <dev/ppbus/ppbus_device.h>
#include <dev/ppbus/ppbus_io.h>
#include <dev/ppbus/ppbus_var.h>

#ifndef DONTPROBE_1284
/* Utility functions */
static char * search_token(char *, int, const char *);
#endif

/* Perform general ppbus I/O request */
int
ppbus_io(device_t dev, int iop, u_char * addr, int cnt, u_char byte)
{
	struct ppbus_softc * bus = device_private(dev);
	return (bus->ppbus_io(device_parent(dev), iop, addr, cnt, byte));
}

/* Execute microsequence */
int
ppbus_exec_microseq(device_t dev, struct ppbus_microseq ** sequence)
{
	struct ppbus_softc * bus = device_private(dev);
	return (bus->ppbus_exec_microseq(device_parent(dev), sequence));
}

/* Read instance variables of ppbus */
int
ppbus_read_ivar(device_t dev, int index, unsigned int * val)

{
	struct ppbus_softc * bus = device_private(dev);

	switch (index) {
	case PPBUS_IVAR_INTR:
	case PPBUS_IVAR_EPP_PROTO:
	case PPBUS_IVAR_DMA:
		return (bus->ppbus_read_ivar(device_parent(dev), index, val));

	case PPBUS_IVAR_IEEE:
		*val = (bus->sc_use_ieee == PPBUS_ENABLE_IEEE) ? 1 : 0;
		break;

	default:
		return (ENOENT);
	}

	return 0;
}

/* Write an instance variable */
int
ppbus_write_ivar(device_t dev, int index, unsigned int * val)
{
	struct ppbus_softc * bus = device_private(dev);

	switch (index) {
	case PPBUS_IVAR_INTR:
	case PPBUS_IVAR_EPP_PROTO:
	case PPBUS_IVAR_DMA:
		return (bus->ppbus_write_ivar(device_parent(dev), index, val));

	case PPBUS_IVAR_IEEE:
		bus->sc_use_ieee = ((*val != 0) ? PPBUS_ENABLE_IEEE :
			PPBUS_DISABLE_IEEE);
		break;

	default:
		return (ENOENT);
	}

	return 0;
}

/* Polls the bus for a max of 10-milliseconds */
int
ppbus_poll_bus(device_t dev, int maxp, char mask, char status,
	int how)
{
	int i, j, error;
	char r;

	/* try at least up to 10ms */
	for (j = 0; j < ((how & PPBUS_POLL) ? maxp : 1); j++) {
		for (i = 0; i < 10000; i++) {
			r = ppbus_rstr(dev);
			DELAY(1);
			if ((r & mask) == status)
				return (0);
		}
	}

	if (!(how & PPBUS_POLL)) {
	   for (i = 0; maxp == PPBUS_FOREVER || i < maxp-1; i++) {
		if ((ppbus_rstr(dev) & mask) == status)
			return (0);

		switch (how) {
		case PPBUS_NOINTR:
			/* wait 10 ms */
			tsleep((void *)dev, PPBUSPRI, "ppbuspoll", hz/100);
			break;

		case PPBUS_INTR:
		default:
			/* wait 10 ms */
			if (((error = tsleep((void *)dev, PPBUSPRI | PCATCH,
			    "ppbuspoll", hz/100)) != EWOULDBLOCK) != 0) {
				return (error);
			}
			break;
		}
	   }
	}

	return (EWOULDBLOCK);
}

/* Get operating mode of the chipset */
int
ppbus_get_mode(device_t dev)
{
	struct ppbus_softc * bus = device_private(dev);

	return (bus->sc_mode);
}

/* Set the operating mode of the chipset, return 0 on success. */
int
ppbus_set_mode(device_t dev, int mode, int options)
{
	struct ppbus_softc * bus = device_private(dev);
	int error = 0;

	/* If no mode change, do nothing */
	if(bus->sc_mode == mode)
		return error;

	/* Do necessary negotiations */
	if(bus->sc_use_ieee == PPBUS_ENABLE_IEEE) {
		/* Cannot negotiate standard mode */
		if(!(mode & (PPBUS_FAST | PPBUS_COMPATIBLE))) {
 			error = ppbus_1284_negotiate(dev, mode, options);
		}
		/* Termination is unnecessary for standard<->fast */
		else if(!(bus->sc_mode & (PPBUS_FAST | PPBUS_COMPATIBLE))) {
			ppbus_1284_terminate(dev);
		}
	}

	if(!error) {
		/* Set mode and update mode of ppbus to actual mode */
		error = bus->ppbus_setmode(device_parent(dev), mode);
		bus->sc_mode = bus->ppbus_getmode(device_parent(dev));
	}

	/* Update host state if necessary */
	if(!(error) && (bus->sc_use_ieee == PPBUS_ENABLE_IEEE)) {
		switch(mode) {
		case PPBUS_COMPATIBLE:
		case PPBUS_FAST:
		case PPBUS_EPP:
		case PPBUS_ECP:
			ppbus_1284_set_state(dev, PPBUS_FORWARD_IDLE);
			break;

		case PPBUS_NIBBLE:
		case PPBUS_PS2:
			ppbus_1284_set_state(dev, PPBUS_REVERSE_IDLE);
			break;
		}
	}

	return error;
}

/* Write charaters to the port */
int
ppbus_write(device_t dev, char * buf, int len, int how, size_t * cnt)
{
	struct ppbus_softc * bus = device_private(dev);

	if(bus->sc_use_ieee == PPBUS_ENABLE_IEEE) {
		if(bus->sc_1284_state != PPBUS_FORWARD_IDLE) {
			printf("%s(%s): bus not in forward idle mode.\n",
				__func__, device_xname(dev));
			return ENODEV;
		}
	}

	return (bus->ppbus_write(device_parent(bus->sc_dev), buf, len, how, cnt));
}

/* Read charaters from the port */
int
ppbus_read(device_t dev, char * buf, int len, int how, size_t * cnt)
{
	struct ppbus_softc * bus = device_private(dev);

	if(bus->sc_use_ieee == PPBUS_ENABLE_IEEE) {
		if(bus->sc_1284_state != PPBUS_REVERSE_IDLE) {
			printf("%s(%s): bus not in reverse idle mode.\n",
				__func__, device_xname(dev));
			return ENODEV;
		}
	}

	return (bus->ppbus_read(device_parent(dev), buf, len, how, cnt));
}

/* Reset the EPP timeout bit in the status register */
int
ppbus_reset_epp_timeout(device_t dev)
{
	struct ppbus_softc * bus = device_private(dev);

	if(bus->sc_capabilities & PPBUS_HAS_EPP) {
		bus->ppbus_reset_epp_timeout(device_parent(dev));
		return 0;
	}
	else {
		return ENODEV;
	}
}

/* Wait for the ECP FIFO to be empty */
int
ppbus_ecp_sync(device_t dev)
{
	struct ppbus_softc * bus = device_private(dev);

	if(bus->sc_capabilities & PPBUS_HAS_ECP) {
		bus->ppbus_ecp_sync(device_parent(dev));
		return 0;
	}
	else {
		return ENODEV;
	}
}

/* Allocate DMA for use with ppbus */
int
ppbus_dma_malloc(device_t dev, void ** buf, bus_addr_t * addr,
	bus_size_t size)
{
	struct ppbus_softc * ppbus = device_private(dev);

	if(ppbus->sc_capabilities & PPBUS_HAS_DMA)
		return (ppbus->ppbus_dma_malloc(device_parent(dev), buf, addr,
			size));
	else
		return ENODEV;
}

/* Free memory allocated with ppbus_dma_malloc() */
int
ppbus_dma_free(device_t dev, void ** buf, bus_addr_t * addr,
	bus_size_t size)
{
	struct ppbus_softc * ppbus = device_private(dev);

	if(ppbus->sc_capabilities & PPBUS_HAS_DMA) {
		ppbus->ppbus_dma_free(device_parent(dev), buf, addr, size);
		return 0;
	}
	else {
		return ENODEV;
	}
}

/* Install a handler to be called by hardware interrupt handler */
int ppbus_add_handler(device_t dev, void (*func)(void *), void *arg)
{
	struct ppbus_softc * bus = device_private(dev);

	if(bus->sc_capabilities & PPBUS_HAS_INTR)
		return bus->ppbus_add_handler(device_parent(dev), func, arg);
	else
		return ENODEV;
}

/* Remove a handler registered with ppbus_add_handler() */
int ppbus_remove_handler(device_t dev, void (*func)(void *))
{
	struct ppbus_softc * bus = device_private(dev);

	if(bus->sc_capabilities & PPBUS_HAS_INTR)
		return bus->ppbus_remove_handler(device_parent(dev), func);
	else
		return ENODEV;
}

/*
 * ppbus_get_status()
 *
 * Read the status register and update the status info
 */
int
ppbus_get_status(device_t dev, struct ppbus_status * status)
{
	register char r = status->status = ppbus_rstr(dev);

	status->timeout	= r & TIMEOUT;
	status->error	= !(r & nFAULT);
	status->select	= r & SELECT;
	status->paper_end = r & PERROR;
	status->ack	= !(r & nACK);
	status->busy	= !(r & nBUSY);

	return (0);
}

/* Allocate the device to perform transfers */
int
ppbus_request_bus(device_t dev, device_t busdev, int how,
	unsigned int timeout)
{
	struct ppbus_softc * bus = device_private(dev);
	unsigned int counter = timeout;
	int priority = PPBUSPRI;
	int error;

	if(how & PPBUS_INTR)
		priority |= PCATCH;

	/* Loop until lock acquired (if PPBUS_WAIT) or an error occurs */
	for(;;) {
		if (mutex_tryenter(&(bus->sc_lock)))
			break;

		if(how & PPBUS_WAIT) {
			error = ltsleep(bus, priority, __func__, hz/2, NULL);
			counter -= (hz/2);
			if(!(error))
				continue;
			else if(error != EWOULDBLOCK)
				goto end;
			if(counter == 0) {
				error = ETIMEDOUT;
				goto end;
			}
		}
		else {
			error = EWOULDBLOCK;
			goto end;
		}
	}

	/* Set bus owner or return error if bus is taken */
	if(bus->ppbus_owner == NULL) {
		bus->ppbus_owner = busdev;
		error = 0;
	}
	else {
		error = EBUSY;
	}

	/* Release lock */
	mutex_exit(&(bus->sc_lock));

end:
	return error;
}

/* Release the device allocated with ppbus_request_bus() */
int
ppbus_release_bus(device_t dev, device_t busdev, int how,
	unsigned int timeout)
{
	struct ppbus_softc * bus = device_private(dev);
	unsigned int counter = timeout;
	int priority = PPBUSPRI;
	int error;

	if(how & PPBUS_INTR)
		priority |= PCATCH;

	/* Loop until lock acquired (if PPBUS_WAIT) or an error occurs */
	for(;;) {
		if (mutex_tryenter(&(bus->sc_lock)))
			break;

		if(how & PPBUS_WAIT) {
			error = ltsleep(bus, priority, __func__, hz/2, NULL);
			counter -= (hz/2);
			if(!(error))
				continue;
			else if(error != EWOULDBLOCK)
				goto end;
			if(counter == 0) {
				error = ETIMEDOUT;
				goto end;
			}
		}
		else {
			error = EWOULDBLOCK;
			goto end;
		}
	}

	/* If the device is the owner, release bus */
	if(bus->ppbus_owner != busdev) {
		error = EINVAL;
	}
	else {
		bus->ppbus_owner = NULL;
		error = 0;
	}

	/* Release lock */
	mutex_exit(&(bus->sc_lock));

end:
	return error;
}


/* IEEE 1284-based probes */

#ifndef DONTPROBE_1284

static const char *pnp_tokens[] = {
	"PRINTER", "MODEM", "NET", "HDC", "PCMCIA", "MEDIA",
	"FDC", "PORTS", "SCANNER", "DIGICAM", "", NULL };

/* ??? */
#if 0
static char *pnp_classes[] = {
	"printer", "modem", "network device",
	"hard disk", "PCMCIA", "multimedia device",
	"floppy disk", "ports", "scanner",
	"digital camera", "unknown device", NULL };
#endif

/*
 * Search the first occurence of a token within a string
 * XXX should use strxxx() calls
 */
static char *
search_token(char *str, int slen, const char *token)
{
	const char *p;
	int tlen, i, j;

#define UNKNOWN_LENGTH  -1

	if (slen == UNKNOWN_LENGTH)
	       /* get string's length */
	       for (slen = 0, p = str; *p != '\0'; p++)
		       slen++;

       /* get token's length */
       for (tlen = 0, p = token; *p != '\0'; p++)
	       tlen++;

       if (tlen == 0)
	       return (str);

       for (i = 0; i <= slen-tlen; i++) {
	       for (j = 0; j < tlen; j++)
		       if (str[i+j] != token[j])
			       break;
	       if (j == tlen)
		       return (&str[i]);
       }

	return (NULL);
}

/* Stores the class ID of the peripherial in soft config data */
void
ppbus_pnp_detect(device_t dev)
{
	struct ppbus_softc * bus = device_private(dev);
	int i;
	int error;
	size_t len = 0;
	size_t str_sz = 0;
	char * str = NULL;
	char * class = NULL;
	char * token;

#ifdef PPBUS_VERBOSE
	printf("%s: Probing for PnP devices.\n", device_xname(dev));
#endif

	error = ppbus_1284_read_id(dev, PPBUS_NIBBLE, &str, &str_sz, &len);
	if(str_sz != len) {
#ifdef DEBUG_1284
		printf("%s(%s): device returned less characters than expected "
			"in device ID.\n", __func__, device_xname(dev));
#endif
	}
	if(error) {
		printf("%s: Error getting device ID (errno = %d)\n",
			device_xname(dev), error);
		goto end_detect;
	}

#ifdef DEBUG_1284
	printf("%s: <PnP> %d characters: ", device_xname(dev), len);
	for (i = 0; i < len; i++)
		printf("%c(0x%x) ", str[i], str[i]);
	printf("\n");
#endif

	/* replace ';' characters by '\0' */
	for (i = 0; i < len; i++)
		if(str[i] == ';') str[i] = '\0';
		/* str[i] = (str[i] == ';') ? '\0' : str[i]; */

	if ((token = search_token(str, len, "MFG")) != NULL ||
		(token = search_token(str, len, "MANUFACTURER")) != NULL)
		printf("%s: <%s", device_xname(dev),
			search_token(token, UNKNOWN_LENGTH, ":") + 1);
	else
		printf("%s: <unknown", device_xname(dev));

	if ((token = search_token(str, len, "MDL")) != NULL ||
		(token = search_token(str, len, "MODEL")) != NULL)
		printf(" %s",
			search_token(token, UNKNOWN_LENGTH, ":") + 1);

	if ((token = search_token(str, len, "REV")) != NULL)
		printf(".%s",
			search_token(token, UNKNOWN_LENGTH, ":") + 1);

	printf(">");

	if ((token = search_token(str, len, "CLS")) != NULL) {
		class = search_token(token, UNKNOWN_LENGTH, ":") + 1;
		printf(" %s", class);
	}

	if ((token = search_token(str, len, "CMD")) != NULL ||
		(token = search_token(str, len, "COMMAND")) != NULL)
		printf(" %s",
			search_token(token, UNKNOWN_LENGTH, ":") + 1);

	printf("\n");

	if (class) {
		/* identify class ident */
		for (i = 0; pnp_tokens[i] != NULL; i++) {
			if (search_token(class, len, pnp_tokens[i]) != NULL) {
				bus->sc_class_id = i;
				goto end_detect;
			}
		}
	}
	bus->sc_class_id = PPBUS_PNP_UNKNOWN;

end_detect:
	if(str)
		free(str, M_DEVBUF);
        return;
}

/* Scan the ppbus for IEEE1284 compliant devices */
int
ppbus_scan_bus(device_t dev)
{
	struct ppbus_softc * bus = device_private(dev);
	int error;

	/* Try IEEE1284 modes, one device only (no IEEE1284.3 support) */

	error = ppbus_1284_negotiate(dev, PPBUS_NIBBLE, 0);
	if (error && bus->sc_1284_state == PPBUS_ERROR
	    && bus->sc_1284_error == PPBUS_NOT_IEEE1284)
		return (error);
	ppbus_1284_terminate(dev);

#if defined(PPBUS_VERBOSE) || defined(PPBUS_DEBUG)
	/* IEEE1284 supported, print info */
	printf("%s: IEEE1284 negotiation: modes %s",
	    device_xname(dev), "NIBBLE");

	error = ppbus_1284_negotiate(dev, PPBUS_PS2, 0);
	if (!error)
		printf("/PS2");
	ppbus_1284_terminate(dev);

	error = ppbus_1284_negotiate(dev, PPBUS_ECP, 0);
	if (!error)
		printf("/ECP");
	ppbus_1284_terminate(dev);

	error = ppbus_1284_negotiate(dev, PPBUS_ECP, PPBUS_USE_RLE);
	if (!error)
		printf("/ECP_RLE");
	ppbus_1284_terminate(dev);

	error = ppbus_1284_negotiate(dev, PPBUS_EPP, 0);
	if (!error)
		printf("/EPP");
	ppbus_1284_terminate(dev);

	printf("\n");
#endif /* PPBUS_VERBOSE || PPBUS_DEBUG */

	return 0;
}

#endif /* !DONTPROBE_1284 */