Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
ieee1284_ops.c
Go to the documentation of this file.
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 <[email protected]>
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);
Generated on Thu Jan 10 2013 14:13:46 for Linux Kernel by   doxygen 1.8.2