/*

   * 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
  ",

  					 port->name);
  
  			parport_data_forward (port);

  			pr_debug("%s: ECP direction: forward
  ", 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
  ", 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
  ", 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
  ", 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
  ");

  	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)
  ",

  			 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)
  ",

  			 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
  ",

  			 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
  ", 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)
  ",

  				 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
  ",
  				 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
  ", 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
  ", port->name);

  		}
  
  		port->ieee1284.phase = IEEE1284_PH_FWD_IDLE;

  		pr_debug("%s: ECP direction: forward
  ", 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
  ", 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
  ", port->name);

  		fn = port->ops->compat_write_data;
  		break;
  
  	case IEEE1284_MODE_EPP:

  		pr_debug("%s: Using EPP mode
  ", 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
  ", 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
  ", 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
  ", 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
  ",
  			 port->name, port->ieee1284.mode);

  		return -ENOSYS;
  	}
  
  	retval = (*fn) (port, buffer, len, 0);

  	pr_debug("%s: wrote %zd/%zu bytes
  ", 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
  ");

  	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
  ", 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
  ", port->name);

  		fn = port->ops->nibble_read_data;
  		break;
  
  	case IEEE1284_MODE_BYTE:

  		pr_debug("%s: Using byte mode
  ", port->name);

  		fn = port->ops->byte_read_data;
  		break;
  
  	case IEEE1284_MODE_EPP:

  		pr_debug("%s: Using EPP mode
  ", 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
  ", 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
  ", port->name);

  		fn = port->ops->ecp_read_data;
  		break;
  
  	case IEEE1284_MODE_ECPSWE:

  		pr_debug("%s: Using software-emulated ECP mode
  ", port->name);

  		fn = parport_ieee1284_ecp_read_data;
  		break;
  
  	default:

  		pr_debug("%s: Unknown mode 0x%02x
  ",
  			 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);