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