1 // SPDX-License-Identifier: GPL-2.0
2 /* IEEE-1284 operations for parport.
3  *
4  * This file is for generic IEEE 1284 operations.  The idea is that
5  * they are used by the low-level drivers.  If they have a special way
6  * of doing something, they can provide their own routines (and put
7  * the function pointers in port->ops); if not, they can just use these
8  * as a fallback.
9  *
10  * Note: Make no assumptions about hardware or architecture in this file!
11  *
12  * Author: Tim Waugh <tim@cyberelk.demon.co.uk>
13  * Fixed AUTOFD polarity in ecp_forward_to_reverse().  Fred Barnes, 1999
14  * Software emulated EPP fixes, Fred Barnes, 04/2001.
15  */
16 
17 
18 #include <linux/module.h>
19 #include <linux/parport.h>
20 #include <linux/delay.h>
21 #include <linux/sched/signal.h>
22 #include <linux/uaccess.h>
23 
24 #undef DEBUG /* undef me for production */
25 
26 #ifdef CONFIG_LP_CONSOLE
27 #undef DEBUG /* Don't want a garbled console */
28 #endif
29 
30 /***                                *
31  * One-way data transfer functions. *
32  *                                ***/
33 
34 /* Compatibility mode. */
35 size_t parport_ieee1284_write_compat (struct parport *port,
36 				      const void *buffer, size_t len,
37 				      int flags)
38 {
39 	int no_irq = 1;
40 	ssize_t count = 0;
41 	const unsigned char *addr = buffer;
42 	unsigned char byte;
43 	struct pardevice *dev = port->physport->cad;
44 	unsigned char ctl = (PARPORT_CONTROL_SELECT
45 			     | PARPORT_CONTROL_INIT);
46 
47 	if (port->irq != PARPORT_IRQ_NONE) {
48 		parport_enable_irq (port);
49 		no_irq = 0;
50 	}
51 
52 	port->physport->ieee1284.phase = IEEE1284_PH_FWD_DATA;
53 	parport_write_control (port, ctl);
54 	parport_data_forward (port);
55 	while (count < len) {
56 		unsigned long expire = jiffies + dev->timeout;
57 		long wait = msecs_to_jiffies(10);
58 		unsigned char mask = (PARPORT_STATUS_ERROR
59 				      | PARPORT_STATUS_BUSY);
60 		unsigned char val = (PARPORT_STATUS_ERROR
61 				     | PARPORT_STATUS_BUSY);
62 
63 		/* Wait until the peripheral's ready */
64 		do {
65 			/* Is the peripheral ready yet? */
66 			if (!parport_wait_peripheral (port, mask, val))
67 				/* Skip the loop */
68 				goto ready;
69 
70 			/* Is the peripheral upset? */
71 			if ((parport_read_status (port) &
72 			     (PARPORT_STATUS_PAPEROUT |
73 			      PARPORT_STATUS_SELECT |
74 			      PARPORT_STATUS_ERROR))
75 			    != (PARPORT_STATUS_SELECT |
76 				PARPORT_STATUS_ERROR))
77 				/* If nFault is asserted (i.e. no
78 				 * error) and PAPEROUT and SELECT are
79 				 * just red herrings, give the driver
80 				 * a chance to check it's happy with
81 				 * that before continuing. */
82 				goto stop;
83 
84 			/* Have we run out of time? */
85 			if (!time_before (jiffies, expire))
86 				break;
87 
88 			/* Yield the port for a while.  If this is the
89                            first time around the loop, don't let go of
90                            the port.  This way, we find out if we have
91                            our interrupt handler called. */
92 			if (count && no_irq) {
93 				parport_release (dev);
94 				schedule_timeout_interruptible(wait);
95 				parport_claim_or_block (dev);
96 			}
97 			else
98 				/* We must have the device claimed here */
99 				parport_wait_event (port, wait);
100 
101 			/* Is there a signal pending? */
102 			if (signal_pending (current))
103 				break;
104 
105 			/* Wait longer next time. */
106 			wait *= 2;
107 		} while (time_before (jiffies, expire));
108 
109 		if (signal_pending (current))
110 			break;
111 
112 		pr_debug("%s: Timed out\n", port->name);
113 		break;
114 
115 	ready:
116 		/* Write the character to the data lines. */
117 		byte = *addr++;
118 		parport_write_data (port, byte);
119 		udelay (1);
120 
121 		/* Pulse strobe. */
122 		parport_write_control (port, ctl | PARPORT_CONTROL_STROBE);
123 		udelay (1); /* strobe */
124 
125 		parport_write_control (port, ctl);
126 		udelay (1); /* hold */
127 
128 		/* Assume the peripheral received it. */
129 		count++;
130 
131                 /* Let another process run if it needs to. */
132 		if (time_before (jiffies, expire))
133 			if (!parport_yield_blocking (dev)
134 			    && need_resched())
135 				schedule ();
136 	}
137  stop:
138 	port->physport->ieee1284.phase = IEEE1284_PH_FWD_IDLE;
139 
140 	return count;
141 }
142 
143 /* Nibble mode. */
144 size_t parport_ieee1284_read_nibble (struct parport *port,
145 				     void *buffer, size_t len,
146 				     int flags)
147 {
148 #ifndef CONFIG_PARPORT_1284
149 	return 0;
150 #else
151 	unsigned char *buf = buffer;
152 	int i;
153 	unsigned char byte = 0;
154 
155 	len *= 2; /* in nibbles */
156 	for (i=0; i < len; i++) {
157 		unsigned char nibble;
158 
159 		/* Does the error line indicate end of data? */
160 		if (((i & 1) == 0) &&
161 		    (parport_read_status(port) & PARPORT_STATUS_ERROR)) {
162 			goto end_of_data;
163 		}
164 
165 		/* Event 7: Set nAutoFd low. */
166 		parport_frob_control (port,
167 				      PARPORT_CONTROL_AUTOFD,
168 				      PARPORT_CONTROL_AUTOFD);
169 
170 		/* Event 9: nAck goes low. */
171 		port->ieee1284.phase = IEEE1284_PH_REV_DATA;
172 		if (parport_wait_peripheral (port,
173 					     PARPORT_STATUS_ACK, 0)) {
174 			/* Timeout -- no more data? */
175 			pr_debug("%s: Nibble timeout at event 9 (%d bytes)\n",
176 				 port->name, i / 2);
177 			parport_frob_control (port, PARPORT_CONTROL_AUTOFD, 0);
178 			break;
179 		}
180 
181 
182 		/* Read a nibble. */
183 		nibble = parport_read_status (port) >> 3;
184 		nibble &= ~8;
185 		if ((nibble & 0x10) == 0)
186 			nibble |= 8;
187 		nibble &= 0xf;
188 
189 		/* Event 10: Set nAutoFd high. */
190 		parport_frob_control (port, PARPORT_CONTROL_AUTOFD, 0);
191 
192 		/* Event 11: nAck goes high. */
193 		if (parport_wait_peripheral (port,
194 					     PARPORT_STATUS_ACK,
195 					     PARPORT_STATUS_ACK)) {
196 			/* Timeout -- no more data? */
197 			pr_debug("%s: Nibble timeout at event 11\n",
198 				 port->name);
199 			break;
200 		}
201 
202 		if (i & 1) {
203 			/* Second nibble */
204 			byte |= nibble << 4;
205 			*buf++ = byte;
206 		} else
207 			byte = nibble;
208 	}
209 
210 	if (i == len) {
211 		/* Read the last nibble without checking data avail. */
212 		if (parport_read_status (port) & PARPORT_STATUS_ERROR) {
213 		end_of_data:
214 			pr_debug("%s: No more nibble data (%d bytes)\n",
215 				 port->name, i / 2);
216 
217 			/* Go to reverse idle phase. */
218 			parport_frob_control (port,
219 					      PARPORT_CONTROL_AUTOFD,
220 					      PARPORT_CONTROL_AUTOFD);
221 			port->physport->ieee1284.phase = IEEE1284_PH_REV_IDLE;
222 		}
223 		else
224 			port->physport->ieee1284.phase = IEEE1284_PH_HBUSY_DAVAIL;
225 	}
226 
227 	return i/2;
228 #endif /* IEEE1284 support */
229 }
230 
231 /* Byte mode. */
232 size_t parport_ieee1284_read_byte (struct parport *port,
233 				   void *buffer, size_t len,
234 				   int flags)
235 {
236 #ifndef CONFIG_PARPORT_1284
237 	return 0;
238 #else
239 	unsigned char *buf = buffer;
240 	ssize_t count = 0;
241 
242 	for (count = 0; count < len; count++) {
243 		unsigned char byte;
244 
245 		/* Data available? */
246 		if (parport_read_status (port) & PARPORT_STATUS_ERROR) {
247 			goto end_of_data;
248 		}
249 
250 		/* Event 14: Place data bus in high impedance state. */
251 		parport_data_reverse (port);
252 
253 		/* Event 7: Set nAutoFd low. */
254 		parport_frob_control (port,
255 				      PARPORT_CONTROL_AUTOFD,
256 				      PARPORT_CONTROL_AUTOFD);
257 
258 		/* Event 9: nAck goes low. */
259 		port->physport->ieee1284.phase = IEEE1284_PH_REV_DATA;
260 		if (parport_wait_peripheral (port,
261 					     PARPORT_STATUS_ACK,
262 					     0)) {
263 			/* Timeout -- no more data? */
264 			parport_frob_control (port, PARPORT_CONTROL_AUTOFD,
265 						 0);
266 			pr_debug("%s: Byte timeout at event 9\n", port->name);
267 			break;
268 		}
269 
270 		byte = parport_read_data (port);
271 		*buf++ = byte;
272 
273 		/* Event 10: Set nAutoFd high */
274 		parport_frob_control (port, PARPORT_CONTROL_AUTOFD, 0);
275 
276 		/* Event 11: nAck goes high. */
277 		if (parport_wait_peripheral (port,
278 					     PARPORT_STATUS_ACK,
279 					     PARPORT_STATUS_ACK)) {
280 			/* Timeout -- no more data? */
281 			pr_debug("%s: Byte timeout at event 11\n", port->name);
282 			break;
283 		}
284 
285 		/* Event 16: Set nStrobe low. */
286 		parport_frob_control (port,
287 				      PARPORT_CONTROL_STROBE,
288 				      PARPORT_CONTROL_STROBE);
289 		udelay (5);
290 
291 		/* Event 17: Set nStrobe high. */
292 		parport_frob_control (port, PARPORT_CONTROL_STROBE, 0);
293 	}
294 
295 	if (count == len) {
296 		/* Read the last byte without checking data avail. */
297 		if (parport_read_status (port) & PARPORT_STATUS_ERROR) {
298 		end_of_data:
299 			pr_debug("%s: No more byte data (%zd bytes)\n",
300 				 port->name, count);
301 
302 			/* Go to reverse idle phase. */
303 			parport_frob_control (port,
304 					      PARPORT_CONTROL_AUTOFD,
305 					      PARPORT_CONTROL_AUTOFD);
306 			port->physport->ieee1284.phase = IEEE1284_PH_REV_IDLE;
307 		}
308 		else
309 			port->physport->ieee1284.phase = IEEE1284_PH_HBUSY_DAVAIL;
310 	}
311 
312 	return count;
313 #endif /* IEEE1284 support */
314 }
315 
316 /***              *
317  * ECP Functions. *
318  *              ***/
319 
320 #ifdef CONFIG_PARPORT_1284
321 
322 static inline
323 int ecp_forward_to_reverse (struct parport *port)
324 {
325 	int retval;
326 
327 	/* Event 38: Set nAutoFd low */
328 	parport_frob_control (port,
329 			      PARPORT_CONTROL_AUTOFD,
330 			      PARPORT_CONTROL_AUTOFD);
331 	parport_data_reverse (port);
332 	udelay (5);
333 
334 	/* Event 39: Set nInit low to initiate bus reversal */
335 	parport_frob_control (port,
336 			      PARPORT_CONTROL_INIT,
337 			      0);
338 
339 	/* Event 40: PError goes low */
340 	retval = parport_wait_peripheral (port,
341 					  PARPORT_STATUS_PAPEROUT, 0);
342 
343 	if (!retval) {
344 		pr_debug("%s: ECP direction: reverse\n", port->name);
345 		port->ieee1284.phase = IEEE1284_PH_REV_IDLE;
346 	} else {
347 		pr_debug("%s: ECP direction: failed to reverse\n", port->name);
348 		port->ieee1284.phase = IEEE1284_PH_ECP_DIR_UNKNOWN;
349 	}
350 
351 	return retval;
352 }
353 
354 static inline
355 int ecp_reverse_to_forward (struct parport *port)
356 {
357 	int retval;
358 
359 	/* Event 47: Set nInit high */
360 	parport_frob_control (port,
361 			      PARPORT_CONTROL_INIT
362 			      | PARPORT_CONTROL_AUTOFD,
363 			      PARPORT_CONTROL_INIT
364 			      | PARPORT_CONTROL_AUTOFD);
365 
366 	/* Event 49: PError goes high */
367 	retval = parport_wait_peripheral (port,
368 					  PARPORT_STATUS_PAPEROUT,
369 					  PARPORT_STATUS_PAPEROUT);
370 
371 	if (!retval) {
372 		parport_data_forward (port);
373 		pr_debug("%s: ECP direction: forward\n", port->name);
374 		port->ieee1284.phase = IEEE1284_PH_FWD_IDLE;
375 	} else {
376 		pr_debug("%s: ECP direction: failed to switch forward\n",
377 			 port->name);
378 		port->ieee1284.phase = IEEE1284_PH_ECP_DIR_UNKNOWN;
379 	}
380 
381 
382 	return retval;
383 }
384 
385 #endif /* IEEE1284 support */
386 
387 /* ECP mode, forward channel, data. */
388 size_t parport_ieee1284_ecp_write_data (struct parport *port,
389 					const void *buffer, size_t len,
390 					int flags)
391 {
392 #ifndef CONFIG_PARPORT_1284
393 	return 0;
394 #else
395 	const unsigned char *buf = buffer;
396 	size_t written;
397 	int retry;
398 
399 	port = port->physport;
400 
401 	if (port->ieee1284.phase != IEEE1284_PH_FWD_IDLE)
402 		if (ecp_reverse_to_forward (port))
403 			return 0;
404 
405 	port->ieee1284.phase = IEEE1284_PH_FWD_DATA;
406 
407 	/* HostAck high (data, not command) */
408 	parport_frob_control (port,
409 			      PARPORT_CONTROL_AUTOFD
410 			      | PARPORT_CONTROL_STROBE
411 			      | PARPORT_CONTROL_INIT,
412 			      PARPORT_CONTROL_INIT);
413 	for (written = 0; written < len; written++, buf++) {
414 		unsigned long expire = jiffies + port->cad->timeout;
415 		unsigned char byte;
416 
417 		byte = *buf;
418 	try_again:
419 		parport_write_data (port, byte);
420 		parport_frob_control (port, PARPORT_CONTROL_STROBE,
421 				      PARPORT_CONTROL_STROBE);
422 		udelay (5);
423 		for (retry = 0; retry < 100; retry++) {
424 			if (!parport_wait_peripheral (port,
425 						      PARPORT_STATUS_BUSY, 0))
426 				goto success;
427 
428 			if (signal_pending (current)) {
429 				parport_frob_control (port,
430 						      PARPORT_CONTROL_STROBE,
431 						      0);
432 				break;
433 			}
434 		}
435 
436 		/* Time for Host Transfer Recovery (page 41 of IEEE1284) */
437 		pr_debug("%s: ECP transfer stalled!\n", port->name);
438 
439 		parport_frob_control (port, PARPORT_CONTROL_INIT,
440 				      PARPORT_CONTROL_INIT);
441 		udelay (50);
442 		if (parport_read_status (port) & PARPORT_STATUS_PAPEROUT) {
443 			/* It's buggered. */
444 			parport_frob_control (port, PARPORT_CONTROL_INIT, 0);
445 			break;
446 		}
447 
448 		parport_frob_control (port, PARPORT_CONTROL_INIT, 0);
449 		udelay (50);
450 		if (!(parport_read_status (port) & PARPORT_STATUS_PAPEROUT))
451 			break;
452 
453 		pr_debug("%s: Host transfer recovered\n", port->name);
454 
455 		if (time_after_eq (jiffies, expire)) break;
456 		goto try_again;
457 	success:
458 		parport_frob_control (port, PARPORT_CONTROL_STROBE, 0);
459 		udelay (5);
460 		if (parport_wait_peripheral (port,
461 					     PARPORT_STATUS_BUSY,
462 					     PARPORT_STATUS_BUSY))
463 			/* Peripheral hasn't accepted the data. */
464 			break;
465 	}
466 
467 	port->ieee1284.phase = IEEE1284_PH_FWD_IDLE;
468 
469 	return written;
470 #endif /* IEEE1284 support */
471 }
472 
473 /* ECP mode, reverse channel, data. */
474 size_t parport_ieee1284_ecp_read_data (struct parport *port,
475 				       void *buffer, size_t len, int flags)
476 {
477 #ifndef CONFIG_PARPORT_1284
478 	return 0;
479 #else
480 	struct pardevice *dev = port->cad;
481 	unsigned char *buf = buffer;
482 	int rle_count = 0; /* shut gcc up */
483 	unsigned char ctl;
484 	int rle = 0;
485 	ssize_t count = 0;
486 
487 	port = port->physport;
488 
489 	if (port->ieee1284.phase != IEEE1284_PH_REV_IDLE)
490 		if (ecp_forward_to_reverse (port))
491 			return 0;
492 
493 	port->ieee1284.phase = IEEE1284_PH_REV_DATA;
494 
495 	/* Set HostAck low to start accepting data. */
496 	ctl = parport_read_control (port);
497 	ctl &= ~(PARPORT_CONTROL_STROBE | PARPORT_CONTROL_INIT |
498 		 PARPORT_CONTROL_AUTOFD);
499 	parport_write_control (port,
500 			       ctl | PARPORT_CONTROL_AUTOFD);
501 	while (count < len) {
502 		unsigned long expire = jiffies + dev->timeout;
503 		unsigned char byte;
504 		int command;
505 
506 		/* Event 43: Peripheral sets nAck low. It can take as
507                    long as it wants. */
508 		while (parport_wait_peripheral (port, PARPORT_STATUS_ACK, 0)) {
509 			/* The peripheral hasn't given us data in
510 			   35ms.  If we have data to give back to the
511 			   caller, do it now. */
512 			if (count)
513 				goto out;
514 
515 			/* If we've used up all the time we were allowed,
516 			   give up altogether. */
517 			if (!time_before (jiffies, expire))
518 				goto out;
519 
520 			/* Yield the port for a while. */
521 			if (dev->port->irq != PARPORT_IRQ_NONE) {
522 				parport_release (dev);
523 				schedule_timeout_interruptible(msecs_to_jiffies(40));
524 				parport_claim_or_block (dev);
525 			}
526 			else
527 				/* We must have the device claimed here. */
528 				parport_wait_event (port, msecs_to_jiffies(40));
529 
530 			/* Is there a signal pending? */
531 			if (signal_pending (current))
532 				goto out;
533 		}
534 
535 		/* Is this a command? */
536 		if (rle)
537 			/* The last byte was a run-length count, so
538                            this can't be as well. */
539 			command = 0;
540 		else
541 			command = (parport_read_status (port) &
542 				   PARPORT_STATUS_BUSY) ? 1 : 0;
543 
544 		/* Read the data. */
545 		byte = parport_read_data (port);
546 
547 		/* If this is a channel command, rather than an RLE
548                    command or a normal data byte, don't accept it. */
549 		if (command) {
550 			if (byte & 0x80) {
551 				pr_debug("%s: stopping short at channel command (%02x)\n",
552 					 port->name, byte);
553 				goto out;
554 			}
555 			else if (port->ieee1284.mode != IEEE1284_MODE_ECPRLE)
556 				pr_debug("%s: device illegally using RLE; accepting anyway\n",
557 					 port->name);
558 
559 			rle_count = byte + 1;
560 
561 			/* Are we allowed to read that many bytes? */
562 			if (rle_count > (len - count)) {
563 				pr_debug("%s: leaving %d RLE bytes for next time\n",
564 					 port->name, rle_count);
565 				break;
566 			}
567 
568 			rle = 1;
569 		}
570 
571 		/* Event 44: Set HostAck high, acknowledging handshake. */
572 		parport_write_control (port, ctl);
573 
574 		/* Event 45: The peripheral has 35ms to set nAck high. */
575 		if (parport_wait_peripheral (port, PARPORT_STATUS_ACK,
576 					     PARPORT_STATUS_ACK)) {
577 			/* It's gone wrong.  Return what data we have
578                            to the caller. */
579 			pr_debug("ECP read timed out at 45\n");
580 
581 			if (command)
582 				pr_warn("%s: command ignored (%02x)\n",
583 					port->name, byte);
584 
585 			break;
586 		}
587 
588 		/* Event 46: Set HostAck low and accept the data. */
589 		parport_write_control (port,
590 				       ctl | PARPORT_CONTROL_AUTOFD);
591 
592 		/* If we just read a run-length count, fetch the data. */
593 		if (command)
594 			continue;
595 
596 		/* If this is the byte after a run-length count, decompress. */
597 		if (rle) {
598 			rle = 0;
599 			memset (buf, byte, rle_count);
600 			buf += rle_count;
601 			count += rle_count;
602 			pr_debug("%s: decompressed to %d bytes\n",
603 				 port->name, rle_count);
604 		} else {
605 			/* Normal data byte. */
606 			*buf = byte;
607 			buf++, count++;
608 		}
609 	}
610 
611  out:
612 	port->ieee1284.phase = IEEE1284_PH_REV_IDLE;
613 	return count;
614 #endif /* IEEE1284 support */
615 }
616 
617 /* ECP mode, forward channel, commands. */
618 size_t parport_ieee1284_ecp_write_addr (struct parport *port,
619 					const void *buffer, size_t len,
620 					int flags)
621 {
622 #ifndef CONFIG_PARPORT_1284
623 	return 0;
624 #else
625 	const unsigned char *buf = buffer;
626 	size_t written;
627 	int retry;
628 
629 	port = port->physport;
630 
631 	if (port->ieee1284.phase != IEEE1284_PH_FWD_IDLE)
632 		if (ecp_reverse_to_forward (port))
633 			return 0;
634 
635 	port->ieee1284.phase = IEEE1284_PH_FWD_DATA;
636 
637 	/* HostAck low (command, not data) */
638 	parport_frob_control (port,
639 			      PARPORT_CONTROL_AUTOFD
640 			      | PARPORT_CONTROL_STROBE
641 			      | PARPORT_CONTROL_INIT,
642 			      PARPORT_CONTROL_AUTOFD
643 			      | PARPORT_CONTROL_INIT);
644 	for (written = 0; written < len; written++, buf++) {
645 		unsigned long expire = jiffies + port->cad->timeout;
646 		unsigned char byte;
647 
648 		byte = *buf;
649 	try_again:
650 		parport_write_data (port, byte);
651 		parport_frob_control (port, PARPORT_CONTROL_STROBE,
652 				      PARPORT_CONTROL_STROBE);
653 		udelay (5);
654 		for (retry = 0; retry < 100; retry++) {
655 			if (!parport_wait_peripheral (port,
656 						      PARPORT_STATUS_BUSY, 0))
657 				goto success;
658 
659 			if (signal_pending (current)) {
660 				parport_frob_control (port,
661 						      PARPORT_CONTROL_STROBE,
662 						      0);
663 				break;
664 			}
665 		}
666 
667 		/* Time for Host Transfer Recovery (page 41 of IEEE1284) */
668 		pr_debug("%s: ECP transfer stalled!\n", port->name);
669 
670 		parport_frob_control (port, PARPORT_CONTROL_INIT,
671 				      PARPORT_CONTROL_INIT);
672 		udelay (50);
673 		if (parport_read_status (port) & PARPORT_STATUS_PAPEROUT) {
674 			/* It's buggered. */
675 			parport_frob_control (port, PARPORT_CONTROL_INIT, 0);
676 			break;
677 		}
678 
679 		parport_frob_control (port, PARPORT_CONTROL_INIT, 0);
680 		udelay (50);
681 		if (!(parport_read_status (port) & PARPORT_STATUS_PAPEROUT))
682 			break;
683 
684 		pr_debug("%s: Host transfer recovered\n", port->name);
685 
686 		if (time_after_eq (jiffies, expire)) break;
687 		goto try_again;
688 	success:
689 		parport_frob_control (port, PARPORT_CONTROL_STROBE, 0);
690 		udelay (5);
691 		if (parport_wait_peripheral (port,
692 					     PARPORT_STATUS_BUSY,
693 					     PARPORT_STATUS_BUSY))
694 			/* Peripheral hasn't accepted the data. */
695 			break;
696 	}
697 
698 	port->ieee1284.phase = IEEE1284_PH_FWD_IDLE;
699 
700 	return written;
701 #endif /* IEEE1284 support */
702 }
703 
704 /***              *
705  * EPP functions. *
706  *              ***/
707 
708 /* EPP mode, forward channel, data. */
709 size_t parport_ieee1284_epp_write_data (struct parport *port,
710 					const void *buffer, size_t len,
711 					int flags)
712 {
713 	unsigned char *bp = (unsigned char *) buffer;
714 	size_t ret = 0;
715 
716 	/* set EPP idle state (just to make sure) with strobe low */
717 	parport_frob_control (port,
718 			      PARPORT_CONTROL_STROBE |
719 			      PARPORT_CONTROL_AUTOFD |
720 			      PARPORT_CONTROL_SELECT |
721 			      PARPORT_CONTROL_INIT,
722 			      PARPORT_CONTROL_STROBE |
723 			      PARPORT_CONTROL_INIT);
724 	port->ops->data_forward (port);
725 	for (; len > 0; len--, bp++) {
726 		/* Event 62: Write data and set autofd low */
727 		parport_write_data (port, *bp);
728 		parport_frob_control (port, PARPORT_CONTROL_AUTOFD,
729 				      PARPORT_CONTROL_AUTOFD);
730 
731 		/* Event 58: wait for busy (nWait) to go high */
732 		if (parport_poll_peripheral (port, PARPORT_STATUS_BUSY, 0, 10))
733 			break;
734 
735 		/* Event 63: set nAutoFd (nDStrb) high */
736 		parport_frob_control (port, PARPORT_CONTROL_AUTOFD, 0);
737 
738 		/* Event 60: wait for busy (nWait) to go low */
739 		if (parport_poll_peripheral (port, PARPORT_STATUS_BUSY,
740 					     PARPORT_STATUS_BUSY, 5))
741 			break;
742 
743 		ret++;
744 	}
745 
746 	/* Event 61: set strobe (nWrite) high */
747 	parport_frob_control (port, PARPORT_CONTROL_STROBE, 0);
748 
749 	return ret;
750 }
751 
752 /* EPP mode, reverse channel, data. */
753 size_t parport_ieee1284_epp_read_data (struct parport *port,
754 				       void *buffer, size_t len,
755 				       int flags)
756 {
757 	unsigned char *bp = (unsigned char *) buffer;
758 	unsigned ret = 0;
759 
760 	/* set EPP idle state (just to make sure) with strobe high */
761 	parport_frob_control (port,
762 			      PARPORT_CONTROL_STROBE |
763 			      PARPORT_CONTROL_AUTOFD |
764 			      PARPORT_CONTROL_SELECT |
765 			      PARPORT_CONTROL_INIT,
766 			      PARPORT_CONTROL_INIT);
767 	port->ops->data_reverse (port);
768 	for (; len > 0; len--, bp++) {
769 		/* Event 67: set nAutoFd (nDStrb) low */
770 		parport_frob_control (port,
771 				      PARPORT_CONTROL_AUTOFD,
772 				      PARPORT_CONTROL_AUTOFD);
773 		/* Event 58: wait for Busy to go high */
774 		if (parport_wait_peripheral (port, PARPORT_STATUS_BUSY, 0)) {
775 			break;
776 		}
777 
778 		*bp = parport_read_data (port);
779 
780 		/* Event 63: set nAutoFd (nDStrb) high */
781 		parport_frob_control (port, PARPORT_CONTROL_AUTOFD, 0);
782 
783 		/* Event 60: wait for Busy to go low */
784 		if (parport_poll_peripheral (port, PARPORT_STATUS_BUSY,
785 					     PARPORT_STATUS_BUSY, 5)) {
786 			break;
787 		}
788 
789 		ret++;
790 	}
791 	port->ops->data_forward (port);
792 
793 	return ret;
794 }
795 
796 /* EPP mode, forward channel, addresses. */
797 size_t parport_ieee1284_epp_write_addr (struct parport *port,
798 					const void *buffer, size_t len,
799 					int flags)
800 {
801 	unsigned char *bp = (unsigned char *) buffer;
802 	size_t ret = 0;
803 
804 	/* set EPP idle state (just to make sure) with strobe low */
805 	parport_frob_control (port,
806 			      PARPORT_CONTROL_STROBE |
807 			      PARPORT_CONTROL_AUTOFD |
808 			      PARPORT_CONTROL_SELECT |
809 			      PARPORT_CONTROL_INIT,
810 			      PARPORT_CONTROL_STROBE |
811 			      PARPORT_CONTROL_INIT);
812 	port->ops->data_forward (port);
813 	for (; len > 0; len--, bp++) {
814 		/* Event 56: Write data and set nAStrb low. */
815 		parport_write_data (port, *bp);
816 		parport_frob_control (port, PARPORT_CONTROL_SELECT,
817 				      PARPORT_CONTROL_SELECT);
818 
819 		/* Event 58: wait for busy (nWait) to go high */
820 		if (parport_poll_peripheral (port, PARPORT_STATUS_BUSY, 0, 10))
821 			break;
822 
823 		/* Event 59: set nAStrb high */
824 		parport_frob_control (port, PARPORT_CONTROL_SELECT, 0);
825 
826 		/* Event 60: wait for busy (nWait) to go low */
827 		if (parport_poll_peripheral (port, PARPORT_STATUS_BUSY,
828 					     PARPORT_STATUS_BUSY, 5))
829 			break;
830 
831 		ret++;
832 	}
833 
834 	/* Event 61: set strobe (nWrite) high */
835 	parport_frob_control (port, PARPORT_CONTROL_STROBE, 0);
836 
837 	return ret;
838 }
839 
840 /* EPP mode, reverse channel, addresses. */
841 size_t parport_ieee1284_epp_read_addr (struct parport *port,
842 				       void *buffer, size_t len,
843 				       int flags)
844 {
845 	unsigned char *bp = (unsigned char *) buffer;
846 	unsigned ret = 0;
847 
848 	/* Set EPP idle state (just to make sure) with strobe high */
849 	parport_frob_control (port,
850 			      PARPORT_CONTROL_STROBE |
851 			      PARPORT_CONTROL_AUTOFD |
852 			      PARPORT_CONTROL_SELECT |
853 			      PARPORT_CONTROL_INIT,
854 			      PARPORT_CONTROL_INIT);
855 	port->ops->data_reverse (port);
856 	for (; len > 0; len--, bp++) {
857 		/* Event 64: set nSelectIn (nAStrb) low */
858 		parport_frob_control (port, PARPORT_CONTROL_SELECT,
859 				      PARPORT_CONTROL_SELECT);
860 
861 		/* Event 58: wait for Busy to go high */
862 		if (parport_wait_peripheral (port, PARPORT_STATUS_BUSY, 0)) {
863 			break;
864 		}
865 
866 		*bp = parport_read_data (port);
867 
868 		/* Event 59: set nSelectIn (nAStrb) high */
869 		parport_frob_control (port, PARPORT_CONTROL_SELECT,
870 				      0);
871 
872 		/* Event 60: wait for Busy to go low */
873 		if (parport_poll_peripheral (port, PARPORT_STATUS_BUSY,
874 					     PARPORT_STATUS_BUSY, 5))
875 			break;
876 
877 		ret++;
878 	}
879 	port->ops->data_forward (port);
880 
881 	return ret;
882 }
883 
884 EXPORT_SYMBOL(parport_ieee1284_ecp_write_data);
885 EXPORT_SYMBOL(parport_ieee1284_ecp_read_data);
886 EXPORT_SYMBOL(parport_ieee1284_ecp_write_addr);
887 EXPORT_SYMBOL(parport_ieee1284_write_compat);
888 EXPORT_SYMBOL(parport_ieee1284_read_nibble);
889 EXPORT_SYMBOL(parport_ieee1284_read_byte);
890 EXPORT_SYMBOL(parport_ieee1284_epp_write_data);
891 EXPORT_SYMBOL(parport_ieee1284_epp_read_data);
892 EXPORT_SYMBOL(parport_ieee1284_epp_write_addr);
893 EXPORT_SYMBOL(parport_ieee1284_epp_read_addr);
894