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