?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Fix typos.
[linux-2.6/linux-mips.git] / drivers / parport / ieee1284_ops.c
blob1c423e053da717b9a0b74058ad75085ade7b28ab
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/config.h>
18 #include <linux/parport.h>
19 #include <linux/delay.h>
20 #include <linux/sched.h>
21 #include <asm/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 = (HZ + 99) / 100;
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 __set_current_state (TASK_INTERRUPTIBLE);
100 schedule_timeout (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. */
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 port->physport->ieee1284.phase = IEEE1284_PH_HBUSY_DNA;
169 DPRINTK (KERN_DEBUG
170 "%s: No more nibble data (%d bytes)\n",
171 port->name, i/2);
172
173 /* Go to reverse idle phase. */
174 parport_frob_control (port,
175 PARPORT_CONTROL_AUTOFD,
176 PARPORT_CONTROL_AUTOFD);
177 port->physport->ieee1284.phase = IEEE1284_PH_REV_IDLE;
178 break;
179 }
180
181 /* Event 7: Set nAutoFd low. */
182 parport_frob_control (port,
183 PARPORT_CONTROL_AUTOFD,
184 PARPORT_CONTROL_AUTOFD);
185
186 /* Event 9: nAck goes low. */
187 port->ieee1284.phase = IEEE1284_PH_REV_DATA;
188 if (parport_wait_peripheral (port,
189 PARPORT_STATUS_ACK, 0)) {
190 /* Timeout -- no more data? */
191 DPRINTK (KERN_DEBUG
192 "%s: Nibble timeout at event 9 (%d bytes)\n",
193 port->name, i/2);
194 parport_frob_control (port, PARPORT_CONTROL_AUTOFD, 0);
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 } else {
364 DPRINTK (KERN_DEBUG "%s: ECP direction: failed to reverse\n",
365 port->name);
366 port->ieee1284.phase = IEEE1284_PH_ECP_DIR_UNKNOWN;
367 }
368
369 return retval;
370 }
371
372 static inline
373 int ecp_reverse_to_forward (struct parport *port)
374 {
375 int retval;
376
377 /* Event 47: Set nInit high */
378 parport_frob_control (port,
379 PARPORT_CONTROL_INIT
380 | PARPORT_CONTROL_AUTOFD,
381 PARPORT_CONTROL_INIT
382 | PARPORT_CONTROL_AUTOFD);
383
384 /* Event 49: PError goes high */
385 retval = parport_wait_peripheral (port,
386 PARPORT_STATUS_PAPEROUT,
387 PARPORT_STATUS_PAPEROUT);
388
389 if (!retval) {
390 parport_data_forward (port);
391 DPRINTK (KERN_DEBUG "%s: ECP direction: forward\n",
392 port->name);
393 port->ieee1284.phase = IEEE1284_PH_FWD_IDLE;
394 } else {
395 DPRINTK (KERN_DEBUG
396 "%s: ECP direction: failed to switch forward\n",
397 port->name);
398 port->ieee1284.phase = IEEE1284_PH_ECP_DIR_UNKNOWN;
399 }
400
401
402 return retval;
403 }
404
405 #endif /* IEEE1284 support */
406
407 /* ECP mode, forward channel, data. */
408 size_t parport_ieee1284_ecp_write_data (struct parport *port,
409 const void *buffer, size_t len,
410 int flags)
411 {
412 #ifndef CONFIG_PARPORT_1284
413 return 0;
414 #else
415 const unsigned char *buf = buffer;
416 size_t written;
417 int retry;
418
419 port = port->physport;
420
421 if (port->ieee1284.phase != IEEE1284_PH_FWD_IDLE)
422 if (ecp_reverse_to_forward (port))
423 return 0;
424
425 port->ieee1284.phase = IEEE1284_PH_FWD_DATA;
426
427 /* HostAck high (data, not command) */
428 parport_frob_control (port,
429 PARPORT_CONTROL_AUTOFD
430 | PARPORT_CONTROL_STROBE
431 | PARPORT_CONTROL_INIT,
432 PARPORT_CONTROL_INIT);
433 for (written = 0; written < len; written++, buf++) {
434 unsigned long expire = jiffies + port->cad->timeout;
435 unsigned char byte;
436
437 byte = *buf;
438 try_again:
439 parport_write_data (port, byte);
440 parport_frob_control (port, PARPORT_CONTROL_STROBE,
441 PARPORT_CONTROL_STROBE);
442 udelay (5);
443 for (retry = 0; retry < 100; retry++) {
444 if (!parport_wait_peripheral (port,
445 PARPORT_STATUS_BUSY, 0))
446 goto success;
447
448 if (signal_pending (current)) {
449 parport_frob_control (port,
450 PARPORT_CONTROL_STROBE,
451 0);
452 break;
453 }
454 }
455
456 /* Time for Host Transfer Recovery (page 41 of IEEE1284) */
457 DPRINTK (KERN_DEBUG "%s: ECP transfer stalled!\n", port->name);
458
459 parport_frob_control (port, PARPORT_CONTROL_INIT,
460 PARPORT_CONTROL_INIT);
461 udelay (50);
462 if (parport_read_status (port) & PARPORT_STATUS_PAPEROUT) {
463 /* It's buggered. */
464 parport_frob_control (port, PARPORT_CONTROL_INIT, 0);
465 break;
466 }
467
468 parport_frob_control (port, PARPORT_CONTROL_INIT, 0);
469 udelay (50);
470 if (!(parport_read_status (port) & PARPORT_STATUS_PAPEROUT))
471 break;
472
473 DPRINTK (KERN_DEBUG "%s: Host transfer recovered\n",
474 port->name);
475
476 if (time_after_eq (jiffies, expire)) break;
477 goto try_again;
478 success:
479 parport_frob_control (port, PARPORT_CONTROL_STROBE, 0);
480 udelay (5);
481 if (parport_wait_peripheral (port,
482 PARPORT_STATUS_BUSY,
483 PARPORT_STATUS_BUSY))
484 /* Peripheral hasn't accepted the data. */
485 break;
486 }
487
488 port->ieee1284.phase = IEEE1284_PH_FWD_IDLE;
489
490 return written;
491 #endif /* IEEE1284 support */
492 }
493
494 /* ECP mode, reverse channel, data. */
495 size_t parport_ieee1284_ecp_read_data (struct parport *port,
496 void *buffer, size_t len, int flags)
497 {
498 #ifndef CONFIG_PARPORT_1284
499 return 0;
500 #else
501 struct pardevice *dev = port->cad;
502 unsigned char *buf = buffer;
503 int rle_count = 0; /* shut gcc up */
504 unsigned char ctl;
505 int rle = 0;
506 ssize_t count = 0;
507
508 port = port->physport;
509
510 if (port->ieee1284.phase != IEEE1284_PH_REV_IDLE)
511 if (ecp_forward_to_reverse (port))
512 return 0;
513
514 port->ieee1284.phase = IEEE1284_PH_REV_DATA;
515
516 /* Set HostAck low to start accepting data. */
517 ctl = parport_read_control (port);
518 ctl &= ~(PARPORT_CONTROL_STROBE | PARPORT_CONTROL_INIT |
519 PARPORT_CONTROL_AUTOFD);
520 parport_write_control (port,
521 ctl | PARPORT_CONTROL_AUTOFD);
522 while (count < len) {
523 unsigned long expire = jiffies + dev->timeout;
524 unsigned char byte;
525 int command;
526
527 /* Event 43: Peripheral sets nAck low. It can take as
528 long as it wants. */
529 while (parport_wait_peripheral (port, PARPORT_STATUS_ACK, 0)) {
530 /* The peripheral hasn't given us data in
531 35ms. If we have data to give back to the
532 caller, do it now. */
533 if (count)
534 goto out;
535
536 /* If we've used up all the time we were allowed,
537 give up altogether. */
538 if (!time_before (jiffies, expire))
539 goto out;
540
541 /* Yield the port for a while. */
542 if (count && dev->port->irq != PARPORT_IRQ_NONE) {
543 parport_release (dev);
544 __set_current_state (TASK_INTERRUPTIBLE);
545 schedule_timeout ((HZ + 24) / 25);
546 parport_claim_or_block (dev);
547 }
548 else
549 /* We must have the device claimed here. */
550 parport_wait_event (port, (HZ + 24) / 25);
551
552 /* Is there a signal pending? */
553 if (signal_pending (current))
554 goto out;
555 }
556
557 /* Is this a command? */
558 if (rle)
559 /* The last byte was a run-length count, so
560 this can't be as well. */
561 command = 0;
562 else
563 command = (parport_read_status (port) &
564 PARPORT_STATUS_BUSY) ? 1 : 0;
565
566 /* Read the data. */
567 byte = parport_read_data (port);
568
569 /* If this is a channel command, rather than an RLE
570 command or a normal data byte, don't accept it. */
571 if (command) {
572 if (byte & 0x80) {
573 DPRINTK (KERN_DEBUG "%s: stopping short at "
574 "channel command (%02x)\n",
575 port->name, byte);
576 goto out;
577 }
578 else if (port->ieee1284.mode != IEEE1284_MODE_ECPRLE)
579 DPRINTK (KERN_DEBUG "%s: device illegally "
580 "using RLE; accepting anyway\n",
581 port->name);
582
583 rle_count = byte + 1;
584
585 /* Are we allowed to read that many bytes? */
586 if (rle_count > (len - count)) {
587 DPRINTK (KERN_DEBUG "%s: leaving %d RLE bytes "
588 "for next time\n", port->name,
589 rle_count);
590 break;
591 }
592
593 rle = 1;
594 }
595
596 /* Event 44: Set HostAck high, acknowledging handshake. */
597 parport_write_control (port, ctl);
598
599 /* Event 45: The peripheral has 35ms to set nAck high. */
600 if (parport_wait_peripheral (port, PARPORT_STATUS_ACK,
601 PARPORT_STATUS_ACK)) {
602 /* It's gone wrong. Return what data we have
603 to the caller. */
604 DPRINTK (KERN_DEBUG "ECP read timed out at 45\n");
605
606 if (command)
607 printk (KERN_WARNING
608 "%s: command ignored (%02x)\n",
609 port->name, byte);
610
611 break;
612 }
613
614 /* Event 46: Set HostAck low and accept the data. */
615 parport_write_control (port,
616 ctl | PARPORT_CONTROL_AUTOFD);
617
618 /* If we just read a run-length count, fetch the data. */
619 if (command)
620 continue;
621
622 /* If this is the byte after a run-length count, decompress. */
623 if (rle) {
624 rle = 0;
625 memset (buf, byte, rle_count);
626 buf += rle_count;
627 count += rle_count;
628 DPRINTK (KERN_DEBUG "%s: decompressed to %d bytes\n",
629 port->name, rle_count);
630 } else {
631 /* Normal data byte. */
632 *buf = byte;
633 buf++, count++;
634 }
635 }
636
637 out:
638 port->ieee1284.phase = IEEE1284_PH_REV_IDLE;
639 return count;
640 #endif /* IEEE1284 support */
641 }
642
643 /* ECP mode, forward channel, commands. */
644 size_t parport_ieee1284_ecp_write_addr (struct parport *port,
645 const void *buffer, size_t len,
646 int flags)
647 {
648 #ifndef CONFIG_PARPORT_1284
649 return 0;
650 #else
651 const unsigned char *buf = buffer;
652 size_t written;
653 int retry;
654
655 port = port->physport;
656
657 if (port->ieee1284.phase != IEEE1284_PH_FWD_IDLE)
658 if (ecp_reverse_to_forward (port))
659 return 0;
660
661 port->ieee1284.phase = IEEE1284_PH_FWD_DATA;
662
663 /* HostAck low (command, not data) */
664 parport_frob_control (port,
665 PARPORT_CONTROL_AUTOFD
666 | PARPORT_CONTROL_STROBE
667 | PARPORT_CONTROL_INIT,
668 PARPORT_CONTROL_AUTOFD
669 | PARPORT_CONTROL_INIT);
670 for (written = 0; written < len; written++, buf++) {
671 unsigned long expire = jiffies + port->cad->timeout;
672 unsigned char byte;
673
674 byte = *buf;
675 try_again:
676 parport_write_data (port, byte);
677 parport_frob_control (port, PARPORT_CONTROL_STROBE,
678 PARPORT_CONTROL_STROBE);
679 udelay (5);
680 for (retry = 0; retry < 100; retry++) {
681 if (!parport_wait_peripheral (port,
682 PARPORT_STATUS_BUSY, 0))
683 goto success;
684
685 if (signal_pending (current)) {
686 parport_frob_control (port,
687 PARPORT_CONTROL_STROBE,
688 0);
689 break;
690 }
691 }
692
693 /* Time for Host Transfer Recovery (page 41 of IEEE1284) */
694 DPRINTK (KERN_DEBUG "%s: ECP transfer stalled!\n", port->name);
695
696 parport_frob_control (port, PARPORT_CONTROL_INIT,
697 PARPORT_CONTROL_INIT);
698 udelay (50);
699 if (parport_read_status (port) & PARPORT_STATUS_PAPEROUT) {
700 /* It's buggered. */
701 parport_frob_control (port, PARPORT_CONTROL_INIT, 0);
702 break;
703 }
704
705 parport_frob_control (port, PARPORT_CONTROL_INIT, 0);
706 udelay (50);
707 if (!(parport_read_status (port) & PARPORT_STATUS_PAPEROUT))
708 break;
709
710 DPRINTK (KERN_DEBUG "%s: Host transfer recovered\n",
711 port->name);
712
713 if (time_after_eq (jiffies, expire)) break;
714 goto try_again;
715 success:
716 parport_frob_control (port, PARPORT_CONTROL_STROBE, 0);
717 udelay (5);
718 if (parport_wait_peripheral (port,
719 PARPORT_STATUS_BUSY,
720 PARPORT_STATUS_BUSY))
721 /* Peripheral hasn't accepted the data. */
722 break;
723 }
724
725 port->ieee1284.phase = IEEE1284_PH_FWD_IDLE;
726
727 return written;
728 #endif /* IEEE1284 support */
729 }
730
731 /*** *
732 * EPP functions. *
733 * ***/
734
735 /* EPP mode, forward channel, data. */
736 size_t parport_ieee1284_epp_write_data (struct parport *port,
737 const void *buffer, size_t len,
738 int flags)
739 {
740 unsigned char *bp = (unsigned char *) buffer;
741 size_t ret = 0;
742
743 /* set EPP idle state (just to make sure) with strobe low */
744 parport_frob_control (port,
745 PARPORT_CONTROL_STROBE |
746 PARPORT_CONTROL_AUTOFD |
747 PARPORT_CONTROL_SELECT |
748 PARPORT_CONTROL_INIT,
749 PARPORT_CONTROL_STROBE |
750 PARPORT_CONTROL_INIT);
751 port->ops->data_forward (port);
752 for (; len > 0; len--, bp++) {
753 /* Event 62: Write data and set autofd low */
754 parport_write_data (port, *bp);
755 parport_frob_control (port, PARPORT_CONTROL_AUTOFD,
756 PARPORT_CONTROL_AUTOFD);
757
758 /* Event 58: wait for busy (nWait) to go high */
759 if (parport_poll_peripheral (port, PARPORT_STATUS_BUSY, 0, 10))
760 break;
761
762 /* Event 63: set nAutoFd (nDStrb) high */
763 parport_frob_control (port, PARPORT_CONTROL_AUTOFD, 0);
764
765 /* Event 60: wait for busy (nWait) to go low */
766 if (parport_poll_peripheral (port, PARPORT_STATUS_BUSY,
767 PARPORT_STATUS_BUSY, 5))
768 break;
769
770 ret++;
771 }
772
773 /* Event 61: set strobe (nWrite) high */
774 parport_frob_control (port, PARPORT_CONTROL_STROBE, 0);
775
776 return ret;
777 }
778
779 /* EPP mode, reverse channel, data. */
780 size_t parport_ieee1284_epp_read_data (struct parport *port,
781 void *buffer, size_t len,
782 int flags)
783 {
784 unsigned char *bp = (unsigned char *) buffer;
785 unsigned ret = 0;
786
787 /* set EPP idle state (just to make sure) with strobe high */
788 parport_frob_control (port,
789 PARPORT_CONTROL_STROBE |
790 PARPORT_CONTROL_AUTOFD |
791 PARPORT_CONTROL_SELECT |
792 PARPORT_CONTROL_INIT,
793 PARPORT_CONTROL_INIT);
794 port->ops->data_reverse (port);
795 for (; len > 0; len--, bp++) {
796 /* Event 67: set nAutoFd (nDStrb) low */
797 parport_frob_control (port,
798 PARPORT_CONTROL_AUTOFD,
799 PARPORT_CONTROL_AUTOFD);
800 /* Event 58: wait for Busy to go high */
801 if (parport_wait_peripheral (port, PARPORT_STATUS_BUSY, 0)) {
802 break;
803 }
804
805 *bp = parport_read_data (port);
806
807 /* Event 63: set nAutoFd (nDStrb) high */
808 parport_frob_control (port, PARPORT_CONTROL_AUTOFD, 0);
809
810 /* Event 60: wait for Busy to go low */
811 if (parport_poll_peripheral (port, PARPORT_STATUS_BUSY,
812 PARPORT_STATUS_BUSY, 5)) {
813 break;
814 }
815
816 ret++;
817 }
818 port->ops->data_forward (port);
819
820 return ret;
821 }
822
823 /* EPP mode, forward channel, addresses. */
824 size_t parport_ieee1284_epp_write_addr (struct parport *port,
825 const void *buffer, size_t len,
826 int flags)
827 {
828 unsigned char *bp = (unsigned char *) buffer;
829 size_t ret = 0;
830
831 /* set EPP idle state (just to make sure) with strobe low */
832 parport_frob_control (port,
833 PARPORT_CONTROL_STROBE |
834 PARPORT_CONTROL_AUTOFD |
835 PARPORT_CONTROL_SELECT |
836 PARPORT_CONTROL_INIT,
837 PARPORT_CONTROL_STROBE |
838 PARPORT_CONTROL_INIT);
839 port->ops->data_forward (port);
840 for (; len > 0; len--, bp++) {
841 /* Event 56: Write data and set nAStrb low. */
842 parport_write_data (port, *bp);
843 parport_frob_control (port, PARPORT_CONTROL_SELECT,
844 PARPORT_CONTROL_SELECT);
845
846 /* Event 58: wait for busy (nWait) to go high */
847 if (parport_poll_peripheral (port, PARPORT_STATUS_BUSY, 0, 10))
848 break;
849
850 /* Event 59: set nAStrb high */
851 parport_frob_control (port, PARPORT_CONTROL_SELECT, 0);
852
853 /* Event 60: wait for busy (nWait) to go low */
854 if (parport_poll_peripheral (port, PARPORT_STATUS_BUSY,
855 PARPORT_STATUS_BUSY, 5))
856 break;
857
858 ret++;
859 }
860
861 /* Event 61: set strobe (nWrite) high */
862 parport_frob_control (port, PARPORT_CONTROL_STROBE, 0);
863
864 return ret;
865 }
866
867 /* EPP mode, reverse channel, addresses. */
868 size_t parport_ieee1284_epp_read_addr (struct parport *port,
869 void *buffer, size_t len,
870 int flags)
871 {
872 unsigned char *bp = (unsigned char *) buffer;
873 unsigned ret = 0;
874
875 /* Set EPP idle state (just to make sure) with strobe high */
876 parport_frob_control (port,
877 PARPORT_CONTROL_STROBE |
878 PARPORT_CONTROL_AUTOFD |
879 PARPORT_CONTROL_SELECT |
880 PARPORT_CONTROL_INIT,
881 PARPORT_CONTROL_INIT);
882 port->ops->data_reverse (port);
883 for (; len > 0; len--, bp++) {
884 /* Event 64: set nSelectIn (nAStrb) low */
885 parport_frob_control (port, PARPORT_CONTROL_SELECT,
886 PARPORT_CONTROL_SELECT);
887
888 /* Event 58: wait for Busy to go high */
889 if (parport_wait_peripheral (port, PARPORT_STATUS_BUSY, 0)) {
890 break;
891 }
892
893 *bp = parport_read_data (port);
894
895 /* Event 59: set nSelectIn (nAStrb) high */
896 parport_frob_control (port, PARPORT_CONTROL_SELECT,
897 PARPORT_CONTROL_SELECT);
898
899 /* Event 60: wait for Busy to go low */
900 if (parport_poll_peripheral (port, PARPORT_STATUS_BUSY,
901 PARPORT_STATUS_BUSY, 5))
902 break;
903
904 ret++;
905 }
906 port->ops->data_forward (port);
907
908 return ret;
909 }
910
911
Mirror of the linux-mips.org kernel tree