xref: /openbmc/linux/drivers/parport/ieee1284.c (revision 7f904d7e1f3ec7c2de47c024a5a5c30988b54703)
1  /*
2   * IEEE-1284 implementation for parport.
3   *
4   * Authors: Phil Blundell <philb@gnu.org>
5   *          Carsten Gross <carsten@sol.wohnheim.uni-ulm.de>
6   *	    Jose Renau <renau@acm.org>
7   *          Tim Waugh <tim@cyberelk.demon.co.uk> (largely rewritten)
8   *
9   * This file is responsible for IEEE 1284 negotiation, and for handing
10   * read/write requests to low-level drivers.
11   *
12   * Any part of this program may be used in documents licensed under
13   * the GNU Free Documentation License, Version 1.1 or any later version
14   * published by the Free Software Foundation.
15   *
16   * Various hacks, Fred Barnes <frmb2@ukc.ac.uk>, 04/2000
17   */
18  
19  #include <linux/module.h>
20  #include <linux/threads.h>
21  #include <linux/parport.h>
22  #include <linux/delay.h>
23  #include <linux/kernel.h>
24  #include <linux/interrupt.h>
25  #include <linux/timer.h>
26  #include <linux/sched/signal.h>
27  
28  #undef DEBUG /* undef me for production */
29  
30  #ifdef CONFIG_LP_CONSOLE
31  #undef DEBUG /* Don't want a garbled console */
32  #endif
33  
34  #ifdef DEBUG
35  #define DPRINTK(stuff...) printk (stuff)
36  #else
37  #define DPRINTK(stuff...)
38  #endif
39  
40  /* Make parport_wait_peripheral wake up.
41   * It will be useful to call this from an interrupt handler. */
42  static void parport_ieee1284_wakeup (struct parport *port)
43  {
44  	up (&port->physport->ieee1284.irq);
45  }
46  
47  static void timeout_waiting_on_port (struct timer_list *t)
48  {
49  	struct parport *port = from_timer(port, t, timer);
50  
51  	parport_ieee1284_wakeup (port);
52  }
53  
54  /**
55   *	parport_wait_event - wait for an event on a parallel port
56   *	@port: port to wait on
57   *	@timeout: time to wait (in jiffies)
58   *
59   *	This function waits for up to @timeout jiffies for an
60   *	interrupt to occur on a parallel port.  If the port timeout is
61   *	set to zero, it returns immediately.
62   *
63   *	If an interrupt occurs before the timeout period elapses, this
64   *	function returns zero immediately.  If it times out, it returns
65   *	one.  An error code less than zero indicates an error (most
66   *	likely a pending signal), and the calling code should finish
67   *	what it's doing as soon as it can.
68   */
69  
70  int parport_wait_event (struct parport *port, signed long timeout)
71  {
72  	int ret;
73  
74  	if (!port->physport->cad->timeout)
75  		/* Zero timeout is special, and we can't down() the
76  		   semaphore. */
77  		return 1;
78  
79  	timer_setup(&port->timer, timeout_waiting_on_port, 0);
80  	mod_timer(&port->timer, jiffies + timeout);
81  	ret = down_interruptible (&port->physport->ieee1284.irq);
82  	if (!del_timer_sync(&port->timer) && !ret)
83  		/* Timed out. */
84  		ret = 1;
85  
86  	return ret;
87  }
88  
89  /**
90   *	parport_poll_peripheral - poll status lines
91   *	@port: port to watch
92   *	@mask: status lines to watch
93   *	@result: desired values of chosen status lines
94   *	@usec: timeout
95   *
96   *	This function busy-waits until the masked status lines have
97   *	the desired values, or until the timeout period elapses.  The
98   *	@mask and @result parameters are bitmasks, with the bits
99   *	defined by the constants in parport.h: %PARPORT_STATUS_BUSY,
100   *	and so on.
101   *
102   *	This function does not call schedule(); instead it busy-waits
103   *	using udelay().  It currently has a resolution of 5usec.
104   *
105   *	If the status lines take on the desired values before the
106   *	timeout period elapses, parport_poll_peripheral() returns zero
107   *	immediately.  A return value greater than zero indicates
108   *	a timeout.  An error code (less than zero) indicates an error,
109   *	most likely a signal that arrived, and the caller should
110   *	finish what it is doing as soon as possible.
111  */
112  
113  int parport_poll_peripheral(struct parport *port,
114  			    unsigned char mask,
115  			    unsigned char result,
116  			    int usec)
117  {
118  	/* Zero return code is success, >0 is timeout. */
119  	int count = usec / 5 + 2;
120  	int i;
121  	unsigned char status;
122  	for (i = 0; i < count; i++) {
123  		status = parport_read_status (port);
124  		if ((status & mask) == result)
125  			return 0;
126  		if (signal_pending (current))
127  			return -EINTR;
128  		if (need_resched())
129  			break;
130  		if (i >= 2)
131  			udelay (5);
132  	}
133  
134  	return 1;
135  }
136  
137  /**
138   *	parport_wait_peripheral - wait for status lines to change in 35ms
139   *	@port: port to watch
140   *	@mask: status lines to watch
141   *	@result: desired values of chosen status lines
142   *
143   *	This function waits until the masked status lines have the
144   *	desired values, or until 35ms have elapsed (see IEEE 1284-1994
145   *	page 24 to 25 for why this value in particular is hardcoded).
146   *	The @mask and @result parameters are bitmasks, with the bits
147   *	defined by the constants in parport.h: %PARPORT_STATUS_BUSY,
148   *	and so on.
149   *
150   *	The port is polled quickly to start off with, in anticipation
151   *	of a fast response from the peripheral.  This fast polling
152   *	time is configurable (using /proc), and defaults to 500usec.
153   *	If the timeout for this port (see parport_set_timeout()) is
154   *	zero, the fast polling time is 35ms, and this function does
155   *	not call schedule().
156   *
157   *	If the timeout for this port is non-zero, after the fast
158   *	polling fails it uses parport_wait_event() to wait for up to
159   *	10ms, waking up if an interrupt occurs.
160   */
161  
162  int parport_wait_peripheral(struct parport *port,
163  			    unsigned char mask,
164  			    unsigned char result)
165  {
166  	int ret;
167  	int usec;
168  	unsigned long deadline;
169  	unsigned char status;
170  
171  	usec = port->physport->spintime; /* usecs of fast polling */
172  	if (!port->physport->cad->timeout)
173  		/* A zero timeout is "special": busy wait for the
174  		   entire 35ms. */
175  		usec = 35000;
176  
177  	/* Fast polling.
178  	 *
179  	 * This should be adjustable.
180  	 * How about making a note (in the device structure) of how long
181  	 * it takes, so we know for next time?
182  	 */
183  	ret = parport_poll_peripheral (port, mask, result, usec);
184  	if (ret != 1)
185  		return ret;
186  
187  	if (!port->physport->cad->timeout)
188  		/* We may be in an interrupt handler, so we can't poll
189  		 * slowly anyway. */
190  		return 1;
191  
192  	/* 40ms of slow polling. */
193  	deadline = jiffies + msecs_to_jiffies(40);
194  	while (time_before (jiffies, deadline)) {
195  		if (signal_pending (current))
196  			return -EINTR;
197  
198  		/* Wait for 10ms (or until an interrupt occurs if
199  		 * the handler is set) */
200  		if ((ret = parport_wait_event (port, msecs_to_jiffies(10))) < 0)
201  			return ret;
202  
203  		status = parport_read_status (port);
204  		if ((status & mask) == result)
205  			return 0;
206  
207  		if (!ret) {
208  			/* parport_wait_event didn't time out, but the
209  			 * peripheral wasn't actually ready either.
210  			 * Wait for another 10ms. */
211  			schedule_timeout_interruptible(msecs_to_jiffies(10));
212  		}
213  	}
214  
215  	return 1;
216  }
217  
218  #ifdef CONFIG_PARPORT_1284
219  /* Terminate a negotiated mode. */
220  static void parport_ieee1284_terminate (struct parport *port)
221  {
222  	int r;
223  	port = port->physport;
224  
225  	/* EPP terminates differently. */
226  	switch (port->ieee1284.mode) {
227  	case IEEE1284_MODE_EPP:
228  	case IEEE1284_MODE_EPPSL:
229  	case IEEE1284_MODE_EPPSWE:
230  		/* Terminate from EPP mode. */
231  
232  		/* Event 68: Set nInit low */
233  		parport_frob_control (port, PARPORT_CONTROL_INIT, 0);
234  		udelay (50);
235  
236  		/* Event 69: Set nInit high, nSelectIn low */
237  		parport_frob_control (port,
238  				      PARPORT_CONTROL_SELECT
239  				      | PARPORT_CONTROL_INIT,
240  				      PARPORT_CONTROL_SELECT
241  				      | PARPORT_CONTROL_INIT);
242  		break;
243  
244  	case IEEE1284_MODE_ECP:
245  	case IEEE1284_MODE_ECPRLE:
246  	case IEEE1284_MODE_ECPSWE:
247  		/* In ECP we can only terminate from fwd idle phase. */
248  		if (port->ieee1284.phase != IEEE1284_PH_FWD_IDLE) {
249  			/* Event 47: Set nInit high */
250  			parport_frob_control (port,
251  					      PARPORT_CONTROL_INIT
252  					      | PARPORT_CONTROL_AUTOFD,
253  					      PARPORT_CONTROL_INIT
254  					      | PARPORT_CONTROL_AUTOFD);
255  
256  			/* Event 49: PError goes high */
257  			r = parport_wait_peripheral (port,
258  						     PARPORT_STATUS_PAPEROUT,
259  						     PARPORT_STATUS_PAPEROUT);
260  			if (r)
261  				DPRINTK (KERN_INFO "%s: Timeout at event 49\n",
262  					 port->name);
263  
264  			parport_data_forward (port);
265  			DPRINTK (KERN_DEBUG "%s: ECP direction: forward\n",
266  				 port->name);
267  			port->ieee1284.phase = IEEE1284_PH_FWD_IDLE;
268  		}
269  
270  		/* fall through */
271  
272  	default:
273  		/* Terminate from all other modes. */
274  
275  		/* Event 22: Set nSelectIn low, nAutoFd high */
276  		parport_frob_control (port,
277  				      PARPORT_CONTROL_SELECT
278  				      | PARPORT_CONTROL_AUTOFD,
279  				      PARPORT_CONTROL_SELECT);
280  
281  		/* Event 24: nAck goes low */
282  		r = parport_wait_peripheral (port, PARPORT_STATUS_ACK, 0);
283  		if (r)
284  			DPRINTK (KERN_INFO "%s: Timeout at event 24\n",
285  				 port->name);
286  
287  		/* Event 25: Set nAutoFd low */
288  		parport_frob_control (port,
289  				      PARPORT_CONTROL_AUTOFD,
290  				      PARPORT_CONTROL_AUTOFD);
291  
292  		/* Event 27: nAck goes high */
293  		r = parport_wait_peripheral (port,
294  					     PARPORT_STATUS_ACK,
295  					     PARPORT_STATUS_ACK);
296  		if (r)
297  			DPRINTK (KERN_INFO "%s: Timeout at event 27\n",
298  				 port->name);
299  
300  		/* Event 29: Set nAutoFd high */
301  		parport_frob_control (port, PARPORT_CONTROL_AUTOFD, 0);
302  	}
303  
304  	port->ieee1284.mode = IEEE1284_MODE_COMPAT;
305  	port->ieee1284.phase = IEEE1284_PH_FWD_IDLE;
306  
307  	DPRINTK (KERN_DEBUG "%s: In compatibility (forward idle) mode\n",
308  		 port->name);
309  }
310  #endif /* IEEE1284 support */
311  
312  /**
313   *	parport_negotiate - negotiate an IEEE 1284 mode
314   *	@port: port to use
315   *	@mode: mode to negotiate to
316   *
317   *	Use this to negotiate to a particular IEEE 1284 transfer mode.
318   *	The @mode parameter should be one of the constants in
319   *	parport.h starting %IEEE1284_MODE_xxx.
320   *
321   *	The return value is 0 if the peripheral has accepted the
322   *	negotiation to the mode specified, -1 if the peripheral is not
323   *	IEEE 1284 compliant (or not present), or 1 if the peripheral
324   *	has rejected the negotiation.
325   */
326  
327  int parport_negotiate (struct parport *port, int mode)
328  {
329  #ifndef CONFIG_PARPORT_1284
330  	if (mode == IEEE1284_MODE_COMPAT)
331  		return 0;
332  	printk (KERN_ERR "parport: IEEE1284 not supported in this kernel\n");
333  	return -1;
334  #else
335  	int m = mode & ~IEEE1284_ADDR;
336  	int r;
337  	unsigned char xflag;
338  
339  	port = port->physport;
340  
341  	/* Is there anything to do? */
342  	if (port->ieee1284.mode == mode)
343  		return 0;
344  
345  	/* Is the difference just an address-or-not bit? */
346  	if ((port->ieee1284.mode & ~IEEE1284_ADDR) == (mode & ~IEEE1284_ADDR)){
347  		port->ieee1284.mode = mode;
348  		return 0;
349  	}
350  
351  	/* Go to compatibility forward idle mode */
352  	if (port->ieee1284.mode != IEEE1284_MODE_COMPAT)
353  		parport_ieee1284_terminate (port);
354  
355  	if (mode == IEEE1284_MODE_COMPAT)
356  		/* Compatibility mode: no negotiation. */
357  		return 0;
358  
359  	switch (mode) {
360  	case IEEE1284_MODE_ECPSWE:
361  		m = IEEE1284_MODE_ECP;
362  		break;
363  	case IEEE1284_MODE_EPPSL:
364  	case IEEE1284_MODE_EPPSWE:
365  		m = IEEE1284_MODE_EPP;
366  		break;
367  	case IEEE1284_MODE_BECP:
368  		return -ENOSYS; /* FIXME (implement BECP) */
369  	}
370  
371  	if (mode & IEEE1284_EXT_LINK)
372  		m = 1<<7; /* request extensibility link */
373  
374  	port->ieee1284.phase = IEEE1284_PH_NEGOTIATION;
375  
376  	/* Start off with nStrobe and nAutoFd high, and nSelectIn low */
377  	parport_frob_control (port,
378  			      PARPORT_CONTROL_STROBE
379  			      | PARPORT_CONTROL_AUTOFD
380  			      | PARPORT_CONTROL_SELECT,
381  			      PARPORT_CONTROL_SELECT);
382  	udelay(1);
383  
384  	/* Event 0: Set data */
385  	parport_data_forward (port);
386  	parport_write_data (port, m);
387  	udelay (400); /* Shouldn't need to wait this long. */
388  
389  	/* Event 1: Set nSelectIn high, nAutoFd low */
390  	parport_frob_control (port,
391  			      PARPORT_CONTROL_SELECT
392  			      | PARPORT_CONTROL_AUTOFD,
393  			      PARPORT_CONTROL_AUTOFD);
394  
395  	/* Event 2: PError, Select, nFault go high, nAck goes low */
396  	if (parport_wait_peripheral (port,
397  				     PARPORT_STATUS_ERROR
398  				     | PARPORT_STATUS_SELECT
399  				     | PARPORT_STATUS_PAPEROUT
400  				     | PARPORT_STATUS_ACK,
401  				     PARPORT_STATUS_ERROR
402  				     | PARPORT_STATUS_SELECT
403  				     | PARPORT_STATUS_PAPEROUT)) {
404  		/* Timeout */
405  		parport_frob_control (port,
406  				      PARPORT_CONTROL_SELECT
407  				      | PARPORT_CONTROL_AUTOFD,
408  				      PARPORT_CONTROL_SELECT);
409  		DPRINTK (KERN_DEBUG
410  			 "%s: Peripheral not IEEE1284 compliant (0x%02X)\n",
411  			 port->name, parport_read_status (port));
412  		port->ieee1284.phase = IEEE1284_PH_FWD_IDLE;
413  		return -1; /* Not IEEE1284 compliant */
414  	}
415  
416  	/* Event 3: Set nStrobe low */
417  	parport_frob_control (port,
418  			      PARPORT_CONTROL_STROBE,
419  			      PARPORT_CONTROL_STROBE);
420  
421  	/* Event 4: Set nStrobe and nAutoFd high */
422  	udelay (5);
423  	parport_frob_control (port,
424  			      PARPORT_CONTROL_STROBE
425  			      | PARPORT_CONTROL_AUTOFD,
426  			      0);
427  
428  	/* Event 6: nAck goes high */
429  	if (parport_wait_peripheral (port,
430  				     PARPORT_STATUS_ACK,
431  				     PARPORT_STATUS_ACK)) {
432  		/* This shouldn't really happen with a compliant device. */
433  		DPRINTK (KERN_DEBUG
434  			 "%s: Mode 0x%02x not supported? (0x%02x)\n",
435  			 port->name, mode, port->ops->read_status (port));
436  		parport_ieee1284_terminate (port);
437  		return 1;
438  	}
439  
440  	xflag = parport_read_status (port) & PARPORT_STATUS_SELECT;
441  
442  	/* xflag should be high for all modes other than nibble (0). */
443  	if (mode && !xflag) {
444  		/* Mode not supported. */
445  		DPRINTK (KERN_DEBUG "%s: Mode 0x%02x rejected by peripheral\n",
446  			 port->name, mode);
447  		parport_ieee1284_terminate (port);
448  		return 1;
449  	}
450  
451  	/* More to do if we've requested extensibility link. */
452  	if (mode & IEEE1284_EXT_LINK) {
453  		m = mode & 0x7f;
454  		udelay (1);
455  		parport_write_data (port, m);
456  		udelay (1);
457  
458  		/* Event 51: Set nStrobe low */
459  		parport_frob_control (port,
460  				      PARPORT_CONTROL_STROBE,
461  				      PARPORT_CONTROL_STROBE);
462  
463  		/* Event 52: nAck goes low */
464  		if (parport_wait_peripheral (port, PARPORT_STATUS_ACK, 0)) {
465  			/* This peripheral is _very_ slow. */
466  			DPRINTK (KERN_DEBUG
467  				 "%s: Event 52 didn't happen\n",
468  				 port->name);
469  			parport_ieee1284_terminate (port);
470  			return 1;
471  		}
472  
473  		/* Event 53: Set nStrobe high */
474  		parport_frob_control (port,
475  				      PARPORT_CONTROL_STROBE,
476  				      0);
477  
478  		/* Event 55: nAck goes high */
479  		if (parport_wait_peripheral (port,
480  					     PARPORT_STATUS_ACK,
481  					     PARPORT_STATUS_ACK)) {
482  			/* This shouldn't really happen with a compliant
483  			 * device. */
484  			DPRINTK (KERN_DEBUG
485  				 "%s: Mode 0x%02x not supported? (0x%02x)\n",
486  				 port->name, mode,
487  				 port->ops->read_status (port));
488  			parport_ieee1284_terminate (port);
489  			return 1;
490  		}
491  
492  		/* Event 54: Peripheral sets XFlag to reflect support */
493  		xflag = parport_read_status (port) & PARPORT_STATUS_SELECT;
494  
495  		/* xflag should be high. */
496  		if (!xflag) {
497  			/* Extended mode not supported. */
498  			DPRINTK (KERN_DEBUG "%s: Extended mode 0x%02x not "
499  				 "supported\n", port->name, mode);
500  			parport_ieee1284_terminate (port);
501  			return 1;
502  		}
503  
504  		/* Any further setup is left to the caller. */
505  	}
506  
507  	/* Mode is supported */
508  	DPRINTK (KERN_DEBUG "%s: In mode 0x%02x\n", port->name, mode);
509  	port->ieee1284.mode = mode;
510  
511  	/* But ECP is special */
512  	if (!(mode & IEEE1284_EXT_LINK) && (m & IEEE1284_MODE_ECP)) {
513  		port->ieee1284.phase = IEEE1284_PH_ECP_SETUP;
514  
515  		/* Event 30: Set nAutoFd low */
516  		parport_frob_control (port,
517  				      PARPORT_CONTROL_AUTOFD,
518  				      PARPORT_CONTROL_AUTOFD);
519  
520  		/* Event 31: PError goes high. */
521  		r = parport_wait_peripheral (port,
522  					     PARPORT_STATUS_PAPEROUT,
523  					     PARPORT_STATUS_PAPEROUT);
524  		if (r) {
525  			DPRINTK (KERN_INFO "%s: Timeout at event 31\n",
526  				port->name);
527  		}
528  
529  		port->ieee1284.phase = IEEE1284_PH_FWD_IDLE;
530  		DPRINTK (KERN_DEBUG "%s: ECP direction: forward\n",
531  			 port->name);
532  	} else switch (mode) {
533  	case IEEE1284_MODE_NIBBLE:
534  	case IEEE1284_MODE_BYTE:
535  		port->ieee1284.phase = IEEE1284_PH_REV_IDLE;
536  		break;
537  	default:
538  		port->ieee1284.phase = IEEE1284_PH_FWD_IDLE;
539  	}
540  
541  
542  	return 0;
543  #endif /* IEEE1284 support */
544  }
545  
546  /* Acknowledge that the peripheral has data available.
547   * Events 18-20, in order to get from Reverse Idle phase
548   * to Host Busy Data Available.
549   * This will most likely be called from an interrupt.
550   * Returns zero if data was available.
551   */
552  #ifdef CONFIG_PARPORT_1284
553  static int parport_ieee1284_ack_data_avail (struct parport *port)
554  {
555  	if (parport_read_status (port) & PARPORT_STATUS_ERROR)
556  		/* Event 18 didn't happen. */
557  		return -1;
558  
559  	/* Event 20: nAutoFd goes high. */
560  	port->ops->frob_control (port, PARPORT_CONTROL_AUTOFD, 0);
561  	port->ieee1284.phase = IEEE1284_PH_HBUSY_DAVAIL;
562  	return 0;
563  }
564  #endif /* IEEE1284 support */
565  
566  /* Handle an interrupt. */
567  void parport_ieee1284_interrupt (void *handle)
568  {
569  	struct parport *port = handle;
570  	parport_ieee1284_wakeup (port);
571  
572  #ifdef CONFIG_PARPORT_1284
573  	if (port->ieee1284.phase == IEEE1284_PH_REV_IDLE) {
574  		/* An interrupt in this phase means that data
575  		 * is now available. */
576  		DPRINTK (KERN_DEBUG "%s: Data available\n", port->name);
577  		parport_ieee1284_ack_data_avail (port);
578  	}
579  #endif /* IEEE1284 support */
580  }
581  
582  /**
583   *	parport_write - write a block of data to a parallel port
584   *	@port: port to write to
585   *	@buffer: data buffer (in kernel space)
586   *	@len: number of bytes of data to transfer
587   *
588   *	This will write up to @len bytes of @buffer to the port
589   *	specified, using the IEEE 1284 transfer mode most recently
590   *	negotiated to (using parport_negotiate()), as long as that
591   *	mode supports forward transfers (host to peripheral).
592   *
593   *	It is the caller's responsibility to ensure that the first
594   *	@len bytes of @buffer are valid.
595   *
596   *	This function returns the number of bytes transferred (if zero
597   *	or positive), or else an error code.
598   */
599  
600  ssize_t parport_write (struct parport *port, const void *buffer, size_t len)
601  {
602  #ifndef CONFIG_PARPORT_1284
603  	return port->ops->compat_write_data (port, buffer, len, 0);
604  #else
605  	ssize_t retval;
606  	int mode = port->ieee1284.mode;
607  	int addr = mode & IEEE1284_ADDR;
608  	size_t (*fn) (struct parport *, const void *, size_t, int);
609  
610  	/* Ignore the device-ID-request bit and the address bit. */
611  	mode &= ~(IEEE1284_DEVICEID | IEEE1284_ADDR);
612  
613  	/* Use the mode we're in. */
614  	switch (mode) {
615  	case IEEE1284_MODE_NIBBLE:
616  	case IEEE1284_MODE_BYTE:
617  		parport_negotiate (port, IEEE1284_MODE_COMPAT);
618  		/* fall through */
619  	case IEEE1284_MODE_COMPAT:
620  		DPRINTK (KERN_DEBUG "%s: Using compatibility mode\n",
621  			 port->name);
622  		fn = port->ops->compat_write_data;
623  		break;
624  
625  	case IEEE1284_MODE_EPP:
626  		DPRINTK (KERN_DEBUG "%s: Using EPP mode\n", port->name);
627  		if (addr) {
628  			fn = port->ops->epp_write_addr;
629  		} else {
630  			fn = port->ops->epp_write_data;
631  		}
632  		break;
633  	case IEEE1284_MODE_EPPSWE:
634  		DPRINTK (KERN_DEBUG "%s: Using software-emulated EPP mode\n",
635  			port->name);
636  		if (addr) {
637  			fn = parport_ieee1284_epp_write_addr;
638  		} else {
639  			fn = parport_ieee1284_epp_write_data;
640  		}
641  		break;
642  	case IEEE1284_MODE_ECP:
643  	case IEEE1284_MODE_ECPRLE:
644  		DPRINTK (KERN_DEBUG "%s: Using ECP mode\n", port->name);
645  		if (addr) {
646  			fn = port->ops->ecp_write_addr;
647  		} else {
648  			fn = port->ops->ecp_write_data;
649  		}
650  		break;
651  
652  	case IEEE1284_MODE_ECPSWE:
653  		DPRINTK (KERN_DEBUG "%s: Using software-emulated ECP mode\n",
654  			 port->name);
655  		/* The caller has specified that it must be emulated,
656  		 * even if we have ECP hardware! */
657  		if (addr) {
658  			fn = parport_ieee1284_ecp_write_addr;
659  		} else {
660  			fn = parport_ieee1284_ecp_write_data;
661  		}
662  		break;
663  
664  	default:
665  		DPRINTK (KERN_DEBUG "%s: Unknown mode 0x%02x\n", port->name,
666  			port->ieee1284.mode);
667  		return -ENOSYS;
668  	}
669  
670  	retval = (*fn) (port, buffer, len, 0);
671  	DPRINTK (KERN_DEBUG "%s: wrote %d/%d bytes\n", port->name, retval, len);
672  	return retval;
673  #endif /* IEEE1284 support */
674  }
675  
676  /**
677   *	parport_read - read a block of data from a parallel port
678   *	@port: port to read from
679   *	@buffer: data buffer (in kernel space)
680   *	@len: number of bytes of data to transfer
681   *
682   *	This will read up to @len bytes of @buffer to the port
683   *	specified, using the IEEE 1284 transfer mode most recently
684   *	negotiated to (using parport_negotiate()), as long as that
685   *	mode supports reverse transfers (peripheral to host).
686   *
687   *	It is the caller's responsibility to ensure that the first
688   *	@len bytes of @buffer are available to write to.
689   *
690   *	This function returns the number of bytes transferred (if zero
691   *	or positive), or else an error code.
692   */
693  
694  ssize_t parport_read (struct parport *port, void *buffer, size_t len)
695  {
696  #ifndef CONFIG_PARPORT_1284
697  	printk (KERN_ERR "parport: IEEE1284 not supported in this kernel\n");
698  	return -ENODEV;
699  #else
700  	int mode = port->physport->ieee1284.mode;
701  	int addr = mode & IEEE1284_ADDR;
702  	size_t (*fn) (struct parport *, void *, size_t, int);
703  
704  	/* Ignore the device-ID-request bit and the address bit. */
705  	mode &= ~(IEEE1284_DEVICEID | IEEE1284_ADDR);
706  
707  	/* Use the mode we're in. */
708  	switch (mode) {
709  	case IEEE1284_MODE_COMPAT:
710  		/* if we can tri-state use BYTE mode instead of NIBBLE mode,
711  		 * if that fails, revert to NIBBLE mode -- ought to store somewhere
712  		 * the device's ability to do BYTE mode reverse transfers, so we don't
713  		 * end up needlessly calling negotiate(BYTE) repeately..  (fb)
714  		 */
715  		if ((port->physport->modes & PARPORT_MODE_TRISTATE) &&
716  		    !parport_negotiate (port, IEEE1284_MODE_BYTE)) {
717  			/* got into BYTE mode OK */
718  			DPRINTK (KERN_DEBUG "%s: Using byte mode\n", port->name);
719  			fn = port->ops->byte_read_data;
720  			break;
721  		}
722  		if (parport_negotiate (port, IEEE1284_MODE_NIBBLE)) {
723  			return -EIO;
724  		}
725  		/* fall through - to NIBBLE */
726  	case IEEE1284_MODE_NIBBLE:
727  		DPRINTK (KERN_DEBUG "%s: Using nibble mode\n", port->name);
728  		fn = port->ops->nibble_read_data;
729  		break;
730  
731  	case IEEE1284_MODE_BYTE:
732  		DPRINTK (KERN_DEBUG "%s: Using byte mode\n", port->name);
733  		fn = port->ops->byte_read_data;
734  		break;
735  
736  	case IEEE1284_MODE_EPP:
737  		DPRINTK (KERN_DEBUG "%s: Using EPP mode\n", port->name);
738  		if (addr) {
739  			fn = port->ops->epp_read_addr;
740  		} else {
741  			fn = port->ops->epp_read_data;
742  		}
743  		break;
744  	case IEEE1284_MODE_EPPSWE:
745  		DPRINTK (KERN_DEBUG "%s: Using software-emulated EPP mode\n",
746  			port->name);
747  		if (addr) {
748  			fn = parport_ieee1284_epp_read_addr;
749  		} else {
750  			fn = parport_ieee1284_epp_read_data;
751  		}
752  		break;
753  	case IEEE1284_MODE_ECP:
754  	case IEEE1284_MODE_ECPRLE:
755  		DPRINTK (KERN_DEBUG "%s: Using ECP mode\n", port->name);
756  		fn = port->ops->ecp_read_data;
757  		break;
758  
759  	case IEEE1284_MODE_ECPSWE:
760  		DPRINTK (KERN_DEBUG "%s: Using software-emulated ECP mode\n",
761  			 port->name);
762  		fn = parport_ieee1284_ecp_read_data;
763  		break;
764  
765  	default:
766  		DPRINTK (KERN_DEBUG "%s: Unknown mode 0x%02x\n", port->name,
767  			 port->physport->ieee1284.mode);
768  		return -ENOSYS;
769  	}
770  
771  	return (*fn) (port, buffer, len, 0);
772  #endif /* IEEE1284 support */
773  }
774  
775  /**
776   *	parport_set_timeout - set the inactivity timeout for a device
777   *	@dev: device on a port
778   *	@inactivity: inactivity timeout (in jiffies)
779   *
780   *	This sets the inactivity timeout for a particular device on a
781   *	port.  This affects functions like parport_wait_peripheral().
782   *	The special value 0 means not to call schedule() while dealing
783   *	with this device.
784   *
785   *	The return value is the previous inactivity timeout.
786   *
787   *	Any callers of parport_wait_event() for this device are woken
788   *	up.
789   */
790  
791  long parport_set_timeout (struct pardevice *dev, long inactivity)
792  {
793  	long int old = dev->timeout;
794  
795  	dev->timeout = inactivity;
796  
797  	if (dev->port->physport->cad == dev)
798  		parport_ieee1284_wakeup (dev->port);
799  
800  	return old;
801  }
802  
803  /* Exported symbols for modules. */
804  
805  EXPORT_SYMBOL(parport_negotiate);
806  EXPORT_SYMBOL(parport_write);
807  EXPORT_SYMBOL(parport_read);
808  EXPORT_SYMBOL(parport_wait_peripheral);
809  EXPORT_SYMBOL(parport_wait_event);
810  EXPORT_SYMBOL(parport_set_timeout);
811  EXPORT_SYMBOL(parport_ieee1284_interrupt);
812