pcmcia: dev_node removal (write-only drivers)
[linux-2.6.git] / drivers / parport / ieee1284_ops.c
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.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 = 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);