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