[PATCH] kprobes: bad manipulation of 2 byte opcode on x86_64
[linux-2.6] / 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/config.h>
18 #include <linux/module.h>
19 #include <linux/parport.h>
20 #include <linux/delay.h>
21 #include <linux/sched.h>
22 #include <asm/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. */
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. */
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. */
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
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
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. */
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. */
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 (count && 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. */
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. */
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. */
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. */
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. */
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                                       PARPORT_CONTROL_SELECT);
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);