/* * IEEE-1284 implementation for parport. * * Authors: Phil Blundell <philb@gnu.org> * Carsten Gross <carsten@sol.wohnheim.uni-ulm.de> * Jose Renau <renau@acm.org> * Tim Waugh <tim@cyberelk.demon.co.uk> (largely rewritten) * * This file is responsible for IEEE 1284 negotiation, and for handing * read/write requests to low-level drivers. * * Any part of this program may be used in documents licensed under * the GNU Free Documentation License, Version 1.1 or any later version * published by the Free Software Foundation. * * Various hacks, Fred Barnes <frmb2@ukc.ac.uk>, 04/2000 */ #include <linux/module.h> #include <linux/threads.h> #include <linux/parport.h> #include <linux/delay.h> #include <linux/kernel.h> #include <linux/interrupt.h> #include <linux/timer.h> #include <linux/sched/signal.h> #undef DEBUG /* undef me for production */ #ifdef CONFIG_LP_CONSOLE #undef DEBUG /* Don't want a garbled console */ #endif /* Make parport_wait_peripheral wake up. * It will be useful to call this from an interrupt handler. */ static void parport_ieee1284_wakeup (struct parport *port) { up (&port->physport->ieee1284.irq); } static void timeout_waiting_on_port (struct timer_list *t) { struct parport *port = from_timer(port, t, timer); parport_ieee1284_wakeup (port); } /** * parport_wait_event - wait for an event on a parallel port * @port: port to wait on * @timeout: time to wait (in jiffies) * * This function waits for up to @timeout jiffies for an * interrupt to occur on a parallel port. If the port timeout is * set to zero, it returns immediately. * * If an interrupt occurs before the timeout period elapses, this * function returns zero immediately. If it times out, it returns * one. An error code less than zero indicates an error (most * likely a pending signal), and the calling code should finish * what it's doing as soon as it can. */ int parport_wait_event (struct parport *port, signed long timeout) { int ret; if (!port->physport->cad->timeout) /* Zero timeout is special, and we can't down() the semaphore. */ return 1; timer_setup(&port->timer, timeout_waiting_on_port, 0); mod_timer(&port->timer, jiffies + timeout); ret = down_interruptible (&port->physport->ieee1284.irq); if (!del_timer_sync(&port->timer) && !ret) /* Timed out. */ ret = 1; return ret; } /** * parport_poll_peripheral - poll status lines * @port: port to watch * @mask: status lines to watch * @result: desired values of chosen status lines * @usec: timeout * * This function busy-waits until the masked status lines have * the desired values, or until the timeout period elapses. The * @mask and @result parameters are bitmasks, with the bits * defined by the constants in parport.h: %PARPORT_STATUS_BUSY, * and so on. * * This function does not call schedule(); instead it busy-waits * using udelay(). It currently has a resolution of 5usec. * * If the status lines take on the desired values before the * timeout period elapses, parport_poll_peripheral() returns zero * immediately. A return value greater than zero indicates * a timeout. An error code (less than zero) indicates an error, * most likely a signal that arrived, and the caller should * finish what it is doing as soon as possible. */ int parport_poll_peripheral(struct parport *port, unsigned char mask, unsigned char result, int usec) { /* Zero return code is success, >0 is timeout. */ int count = usec / 5 + 2; int i; unsigned char status; for (i = 0; i < count; i++) { status = parport_read_status (port); if ((status & mask) == result) return 0; if (signal_pending (current)) return -EINTR; if (need_resched()) break; if (i >= 2) udelay (5); } return 1; } /** * parport_wait_peripheral - wait for status lines to change in 35ms * @port: port to watch * @mask: status lines to watch * @result: desired values of chosen status lines * * This function waits until the masked status lines have the * desired values, or until 35ms have elapsed (see IEEE 1284-1994 * page 24 to 25 for why this value in particular is hardcoded). * The @mask and @result parameters are bitmasks, with the bits * defined by the constants in parport.h: %PARPORT_STATUS_BUSY, * and so on. * * The port is polled quickly to start off with, in anticipation * of a fast response from the peripheral. This fast polling * time is configurable (using /proc), and defaults to 500usec. * If the timeout for this port (see parport_set_timeout()) is * zero, the fast polling time is 35ms, and this function does * not call schedule(). * * If the timeout for this port is non-zero, after the fast * polling fails it uses parport_wait_event() to wait for up to * 10ms, waking up if an interrupt occurs. */ int parport_wait_peripheral(struct parport *port, unsigned char mask, unsigned char result) { int ret; int usec; unsigned long deadline; unsigned char status; usec = port->physport->spintime; /* usecs of fast polling */ if (!port->physport->cad->timeout) /* A zero timeout is "special": busy wait for the entire 35ms. */ usec = 35000; /* Fast polling. * * This should be adjustable. * How about making a note (in the device structure) of how long * it takes, so we know for next time? */ ret = parport_poll_peripheral (port, mask, result, usec); if (ret != 1) return ret; if (!port->physport->cad->timeout) /* We may be in an interrupt handler, so we can't poll * slowly anyway. */ return 1; /* 40ms of slow polling. */ deadline = jiffies + msecs_to_jiffies(40); while (time_before (jiffies, deadline)) { if (signal_pending (current)) return -EINTR; /* Wait for 10ms (or until an interrupt occurs if * the handler is set) */ if ((ret = parport_wait_event (port, msecs_to_jiffies(10))) < 0) return ret; status = parport_read_status (port); if ((status & mask) == result) return 0; if (!ret) { /* parport_wait_event didn't time out, but the * peripheral wasn't actually ready either. * Wait for another 10ms. */ schedule_timeout_interruptible(msecs_to_jiffies(10)); } } return 1; } #ifdef CONFIG_PARPORT_1284 /* Terminate a negotiated mode. */ static void parport_ieee1284_terminate (struct parport *port) { int r; port = port->physport; /* EPP terminates differently. */ switch (port->ieee1284.mode) { case IEEE1284_MODE_EPP: case IEEE1284_MODE_EPPSL: case IEEE1284_MODE_EPPSWE: /* Terminate from EPP mode. */ /* Event 68: Set nInit low */ parport_frob_control (port, PARPORT_CONTROL_INIT, 0); udelay (50); /* Event 69: Set nInit high, nSelectIn low */ parport_frob_control (port, PARPORT_CONTROL_SELECT | PARPORT_CONTROL_INIT, PARPORT_CONTROL_SELECT | PARPORT_CONTROL_INIT); break; case IEEE1284_MODE_ECP: case IEEE1284_MODE_ECPRLE: case IEEE1284_MODE_ECPSWE: /* In ECP we can only terminate from fwd idle phase. */ if (port->ieee1284.phase != IEEE1284_PH_FWD_IDLE) { /* Event 47: Set nInit high */ parport_frob_control (port, PARPORT_CONTROL_INIT | PARPORT_CONTROL_AUTOFD, PARPORT_CONTROL_INIT | PARPORT_CONTROL_AUTOFD); /* Event 49: PError goes high */ r = parport_wait_peripheral (port, PARPORT_STATUS_PAPEROUT, PARPORT_STATUS_PAPEROUT); if (r) pr_debug("%s: Timeout at event 49\n", port->name); parport_data_forward (port); pr_debug("%s: ECP direction: forward\n", port->name); port->ieee1284.phase = IEEE1284_PH_FWD_IDLE; } fallthrough; default: /* Terminate from all other modes. */ /* Event 22: Set nSelectIn low, nAutoFd high */ parport_frob_control (port, PARPORT_CONTROL_SELECT | PARPORT_CONTROL_AUTOFD, PARPORT_CONTROL_SELECT); /* Event 24: nAck goes low */ r = parport_wait_peripheral (port, PARPORT_STATUS_ACK, 0); if (r) pr_debug("%s: Timeout at event 24\n", port->name); /* Event 25: Set nAutoFd low */ parport_frob_control (port, PARPORT_CONTROL_AUTOFD, PARPORT_CONTROL_AUTOFD); /* Event 27: nAck goes high */ r = parport_wait_peripheral (port, PARPORT_STATUS_ACK, PARPORT_STATUS_ACK); if (r) pr_debug("%s: Timeout at event 27\n", port->name); /* Event 29: Set nAutoFd high */ parport_frob_control (port, PARPORT_CONTROL_AUTOFD, 0); } port->ieee1284.mode = IEEE1284_MODE_COMPAT; port->ieee1284.phase = IEEE1284_PH_FWD_IDLE; pr_debug("%s: In compatibility (forward idle) mode\n", port->name); } #endif /* IEEE1284 support */ /** * parport_negotiate - negotiate an IEEE 1284 mode * @port: port to use * @mode: mode to negotiate to * * Use this to negotiate to a particular IEEE 1284 transfer mode. * The @mode parameter should be one of the constants in * parport.h starting %IEEE1284_MODE_xxx. * * The return value is 0 if the peripheral has accepted the * negotiation to the mode specified, -1 if the peripheral is not * IEEE 1284 compliant (or not present), or 1 if the peripheral * has rejected the negotiation. */ int parport_negotiate (struct parport *port, int mode) { #ifndef CONFIG_PARPORT_1284 if (mode == IEEE1284_MODE_COMPAT) return 0; pr_err("parport: IEEE1284 not supported in this kernel\n"); return -1; #else int m = mode & ~IEEE1284_ADDR; int r; unsigned char xflag; port = port->physport; /* Is there anything to do? */ if (port->ieee1284.mode == mode) return 0; /* Is the difference just an address-or-not bit? */ if ((port->ieee1284.mode & ~IEEE1284_ADDR) == (mode & ~IEEE1284_ADDR)){ port->ieee1284.mode = mode; return 0; } /* Go to compatibility forward idle mode */ if (port->ieee1284.mode != IEEE1284_MODE_COMPAT) parport_ieee1284_terminate (port); if (mode == IEEE1284_MODE_COMPAT) /* Compatibility mode: no negotiation. */ return 0; switch (mode) { case IEEE1284_MODE_ECPSWE: m = IEEE1284_MODE_ECP; break; case IEEE1284_MODE_EPPSL: case IEEE1284_MODE_EPPSWE: m = IEEE1284_MODE_EPP; break; case IEEE1284_MODE_BECP: return -ENOSYS; /* FIXME (implement BECP) */ } if (mode & IEEE1284_EXT_LINK) m = 1<<7; /* request extensibility link */ port->ieee1284.phase = IEEE1284_PH_NEGOTIATION; /* Start off with nStrobe and nAutoFd high, and nSelectIn low */ parport_frob_control (port, PARPORT_CONTROL_STROBE | PARPORT_CONTROL_AUTOFD | PARPORT_CONTROL_SELECT, PARPORT_CONTROL_SELECT); udelay(1); /* Event 0: Set data */ parport_data_forward (port); parport_write_data (port, m); udelay (400); /* Shouldn't need to wait this long. */ /* Event 1: Set nSelectIn high, nAutoFd low */ parport_frob_control (port, PARPORT_CONTROL_SELECT | PARPORT_CONTROL_AUTOFD, PARPORT_CONTROL_AUTOFD); /* Event 2: PError, Select, nFault go high, nAck goes low */ if (parport_wait_peripheral (port, PARPORT_STATUS_ERROR | PARPORT_STATUS_SELECT | PARPORT_STATUS_PAPEROUT | PARPORT_STATUS_ACK, PARPORT_STATUS_ERROR | PARPORT_STATUS_SELECT | PARPORT_STATUS_PAPEROUT)) { /* Timeout */ parport_frob_control (port, PARPORT_CONTROL_SELECT | PARPORT_CONTROL_AUTOFD, PARPORT_CONTROL_SELECT); pr_debug("%s: Peripheral not IEEE1284 compliant (0x%02X)\n", port->name, parport_read_status (port)); port->ieee1284.phase = IEEE1284_PH_FWD_IDLE; return -1; /* Not IEEE1284 compliant */ } /* Event 3: Set nStrobe low */ parport_frob_control (port, PARPORT_CONTROL_STROBE, PARPORT_CONTROL_STROBE); /* Event 4: Set nStrobe and nAutoFd high */ udelay (5); parport_frob_control (port, PARPORT_CONTROL_STROBE | PARPORT_CONTROL_AUTOFD, 0); /* Event 6: nAck goes high */ if (parport_wait_peripheral (port, PARPORT_STATUS_ACK, PARPORT_STATUS_ACK)) { /* This shouldn't really happen with a compliant device. */ pr_debug("%s: Mode 0x%02x not supported? (0x%02x)\n", port->name, mode, port->ops->read_status (port)); parport_ieee1284_terminate (port); return 1; } xflag = parport_read_status (port) & PARPORT_STATUS_SELECT; /* xflag should be high for all modes other than nibble (0). */ if (mode && !xflag) { /* Mode not supported. */ pr_debug("%s: Mode 0x%02x rejected by peripheral\n", port->name, mode); parport_ieee1284_terminate (port); return 1; } /* More to do if we've requested extensibility link. */ if (mode & IEEE1284_EXT_LINK) { m = mode & 0x7f; udelay (1); parport_write_data (port, m); udelay (1); /* Event 51: Set nStrobe low */ parport_frob_control (port, PARPORT_CONTROL_STROBE, PARPORT_CONTROL_STROBE); /* Event 52: nAck goes low */ if (parport_wait_peripheral (port, PARPORT_STATUS_ACK, 0)) { /* This peripheral is _very_ slow. */ pr_debug("%s: Event 52 didn't happen\n", port->name); parport_ieee1284_terminate (port); return 1; } /* Event 53: Set nStrobe high */ parport_frob_control (port, PARPORT_CONTROL_STROBE, 0); /* Event 55: nAck goes high */ if (parport_wait_peripheral (port, PARPORT_STATUS_ACK, PARPORT_STATUS_ACK)) { /* This shouldn't really happen with a compliant * device. */ pr_debug("%s: Mode 0x%02x not supported? (0x%02x)\n", port->name, mode, port->ops->read_status(port)); parport_ieee1284_terminate (port); return 1; } /* Event 54: Peripheral sets XFlag to reflect support */ xflag = parport_read_status (port) & PARPORT_STATUS_SELECT; /* xflag should be high. */ if (!xflag) { /* Extended mode not supported. */ pr_debug("%s: Extended mode 0x%02x not supported\n", port->name, mode); parport_ieee1284_terminate (port); return 1; } /* Any further setup is left to the caller. */ } /* Mode is supported */ pr_debug("%s: In mode 0x%02x\n", port->name, mode); port->ieee1284.mode = mode; /* But ECP is special */ if (!(mode & IEEE1284_EXT_LINK) && (m & IEEE1284_MODE_ECP)) { port->ieee1284.phase = IEEE1284_PH_ECP_SETUP; /* Event 30: Set nAutoFd low */ parport_frob_control (port, PARPORT_CONTROL_AUTOFD, PARPORT_CONTROL_AUTOFD); /* Event 31: PError goes high. */ r = parport_wait_peripheral (port, PARPORT_STATUS_PAPEROUT, PARPORT_STATUS_PAPEROUT); if (r) { pr_debug("%s: Timeout at event 31\n", port->name); } port->ieee1284.phase = IEEE1284_PH_FWD_IDLE; pr_debug("%s: ECP direction: forward\n", port->name); } else switch (mode) { case IEEE1284_MODE_NIBBLE: case IEEE1284_MODE_BYTE: port->ieee1284.phase = IEEE1284_PH_REV_IDLE; break; default: port->ieee1284.phase = IEEE1284_PH_FWD_IDLE; } return 0; #endif /* IEEE1284 support */ } /* Acknowledge that the peripheral has data available. * Events 18-20, in order to get from Reverse Idle phase * to Host Busy Data Available. * This will most likely be called from an interrupt. * Returns zero if data was available. */ #ifdef CONFIG_PARPORT_1284 static int parport_ieee1284_ack_data_avail (struct parport *port) { if (parport_read_status (port) & PARPORT_STATUS_ERROR) /* Event 18 didn't happen. */ return -1; /* Event 20: nAutoFd goes high. */ port->ops->frob_control (port, PARPORT_CONTROL_AUTOFD, 0); port->ieee1284.phase = IEEE1284_PH_HBUSY_DAVAIL; return 0; } #endif /* IEEE1284 support */ /* Handle an interrupt. */ void parport_ieee1284_interrupt (void *handle) { struct parport *port = handle; parport_ieee1284_wakeup (port); #ifdef CONFIG_PARPORT_1284 if (port->ieee1284.phase == IEEE1284_PH_REV_IDLE) { /* An interrupt in this phase means that data * is now available. */ pr_debug("%s: Data available\n", port->name); parport_ieee1284_ack_data_avail (port); } #endif /* IEEE1284 support */ } /** * parport_write - write a block of data to a parallel port * @port: port to write to * @buffer: data buffer (in kernel space) * @len: number of bytes of data to transfer * * This will write up to @len bytes of @buffer to the port * specified, using the IEEE 1284 transfer mode most recently * negotiated to (using parport_negotiate()), as long as that * mode supports forward transfers (host to peripheral). * * It is the caller's responsibility to ensure that the first * @len bytes of @buffer are valid. * * This function returns the number of bytes transferred (if zero * or positive), or else an error code. */ ssize_t parport_write (struct parport *port, const void *buffer, size_t len) { #ifndef CONFIG_PARPORT_1284 return port->ops->compat_write_data (port, buffer, len, 0); #else ssize_t retval; int mode = port->ieee1284.mode; int addr = mode & IEEE1284_ADDR; size_t (*fn) (struct parport *, const void *, size_t, int); /* Ignore the device-ID-request bit and the address bit. */ mode &= ~(IEEE1284_DEVICEID | IEEE1284_ADDR); /* Use the mode we're in. */ switch (mode) { case IEEE1284_MODE_NIBBLE: case IEEE1284_MODE_BYTE: parport_negotiate (port, IEEE1284_MODE_COMPAT); fallthrough; case IEEE1284_MODE_COMPAT: pr_debug("%s: Using compatibility mode\n", port->name); fn = port->ops->compat_write_data; break; case IEEE1284_MODE_EPP: pr_debug("%s: Using EPP mode\n", port->name); if (addr) { fn = port->ops->epp_write_addr; } else { fn = port->ops->epp_write_data; } break; case IEEE1284_MODE_EPPSWE: pr_debug("%s: Using software-emulated EPP mode\n", port->name); if (addr) { fn = parport_ieee1284_epp_write_addr; } else { fn = parport_ieee1284_epp_write_data; } break; case IEEE1284_MODE_ECP: case IEEE1284_MODE_ECPRLE: pr_debug("%s: Using ECP mode\n", port->name); if (addr) { fn = port->ops->ecp_write_addr; } else { fn = port->ops->ecp_write_data; } break; case IEEE1284_MODE_ECPSWE: pr_debug("%s: Using software-emulated ECP mode\n", port->name); /* The caller has specified that it must be emulated, * even if we have ECP hardware! */ if (addr) { fn = parport_ieee1284_ecp_write_addr; } else { fn = parport_ieee1284_ecp_write_data; } break; default: pr_debug("%s: Unknown mode 0x%02x\n", port->name, port->ieee1284.mode); return -ENOSYS; } retval = (*fn) (port, buffer, len, 0); pr_debug("%s: wrote %zd/%zu bytes\n", port->name, retval, len); return retval; #endif /* IEEE1284 support */ } /** * parport_read - read a block of data from a parallel port * @port: port to read from * @buffer: data buffer (in kernel space) * @len: number of bytes of data to transfer * * This will read up to @len bytes of @buffer to the port * specified, using the IEEE 1284 transfer mode most recently * negotiated to (using parport_negotiate()), as long as that * mode supports reverse transfers (peripheral to host). * * It is the caller's responsibility to ensure that the first * @len bytes of @buffer are available to write to. * * This function returns the number of bytes transferred (if zero * or positive), or else an error code. */ ssize_t parport_read (struct parport *port, void *buffer, size_t len) { #ifndef CONFIG_PARPORT_1284 pr_err("parport: IEEE1284 not supported in this kernel\n"); return -ENODEV; #else int mode = port->physport->ieee1284.mode; int addr = mode & IEEE1284_ADDR; size_t (*fn) (struct parport *, void *, size_t, int); /* Ignore the device-ID-request bit and the address bit. */ mode &= ~(IEEE1284_DEVICEID | IEEE1284_ADDR); /* Use the mode we're in. */ switch (mode) { case IEEE1284_MODE_COMPAT: /* if we can tri-state use BYTE mode instead of NIBBLE mode, * if that fails, revert to NIBBLE mode -- ought to store somewhere * the device's ability to do BYTE mode reverse transfers, so we don't * end up needlessly calling negotiate(BYTE) repeately.. (fb) */ if ((port->physport->modes & PARPORT_MODE_TRISTATE) && !parport_negotiate (port, IEEE1284_MODE_BYTE)) { /* got into BYTE mode OK */ pr_debug("%s: Using byte mode\n", port->name); fn = port->ops->byte_read_data; break; } if (parport_negotiate (port, IEEE1284_MODE_NIBBLE)) { return -EIO; } fallthrough; /* to NIBBLE */ case IEEE1284_MODE_NIBBLE: pr_debug("%s: Using nibble mode\n", port->name); fn = port->ops->nibble_read_data; break; case IEEE1284_MODE_BYTE: pr_debug("%s: Using byte mode\n", port->name); fn = port->ops->byte_read_data; break; case IEEE1284_MODE_EPP: pr_debug("%s: Using EPP mode\n", port->name); if (addr) { fn = port->ops->epp_read_addr; } else { fn = port->ops->epp_read_data; } break; case IEEE1284_MODE_EPPSWE: pr_debug("%s: Using software-emulated EPP mode\n", port->name); if (addr) { fn = parport_ieee1284_epp_read_addr; } else { fn = parport_ieee1284_epp_read_data; } break; case IEEE1284_MODE_ECP: case IEEE1284_MODE_ECPRLE: pr_debug("%s: Using ECP mode\n", port->name); fn = port->ops->ecp_read_data; break; case IEEE1284_MODE_ECPSWE: pr_debug("%s: Using software-emulated ECP mode\n", port->name); fn = parport_ieee1284_ecp_read_data; break; default: pr_debug("%s: Unknown mode 0x%02x\n", port->name, port->physport->ieee1284.mode); return -ENOSYS; } return (*fn) (port, buffer, len, 0); #endif /* IEEE1284 support */ } /** * parport_set_timeout - set the inactivity timeout for a device * @dev: device on a port * @inactivity: inactivity timeout (in jiffies) * * This sets the inactivity timeout for a particular device on a * port. This affects functions like parport_wait_peripheral(). * The special value 0 means not to call schedule() while dealing * with this device. * * The return value is the previous inactivity timeout. * * Any callers of parport_wait_event() for this device are woken * up. */ long parport_set_timeout (struct pardevice *dev, long inactivity) { long int old = dev->timeout; dev->timeout = inactivity; if (dev->port->physport->cad == dev) parport_ieee1284_wakeup (dev->port); return old; } /* Exported symbols for modules. */ EXPORT_SYMBOL(parport_negotiate); EXPORT_SYMBOL(parport_write); EXPORT_SYMBOL(parport_read); EXPORT_SYMBOL(parport_wait_peripheral); EXPORT_SYMBOL(parport_wait_event); EXPORT_SYMBOL(parport_set_timeout); EXPORT_SYMBOL(parport_ieee1284_interrupt);