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