Version:  2.0.40 2.2.26 2.4.37 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2 4.3 4.4 4.5 4.6 4.7 4.8 4.9 4.10

Linux/Documentation/parport-lowlevel.txt

  1 PARPORT interface documentation
  2 -------------------------------
  3 
  4 Time-stamp: <2000-02-24 13:30:20 twaugh>
  5 
  6 Described here are the following functions:
  7 
  8 Global functions:
  9   parport_register_driver
 10   parport_unregister_driver
 11   parport_enumerate
 12   parport_register_device
 13   parport_unregister_device
 14   parport_claim
 15   parport_claim_or_block
 16   parport_release
 17   parport_yield
 18   parport_yield_blocking
 19   parport_wait_peripheral
 20   parport_poll_peripheral
 21   parport_wait_event
 22   parport_negotiate
 23   parport_read
 24   parport_write
 25   parport_open
 26   parport_close
 27   parport_device_id
 28   parport_device_coords
 29   parport_find_class
 30   parport_find_device
 31   parport_set_timeout
 32 
 33 Port functions (can be overridden by low-level drivers):
 34   SPP:
 35     port->ops->read_data
 36     port->ops->write_data
 37     port->ops->read_status
 38     port->ops->read_control
 39     port->ops->write_control
 40     port->ops->frob_control
 41     port->ops->enable_irq
 42     port->ops->disable_irq
 43     port->ops->data_forward
 44     port->ops->data_reverse
 45 
 46   EPP:
 47     port->ops->epp_write_data
 48     port->ops->epp_read_data
 49     port->ops->epp_write_addr
 50     port->ops->epp_read_addr
 51 
 52   ECP:
 53     port->ops->ecp_write_data
 54     port->ops->ecp_read_data
 55     port->ops->ecp_write_addr
 56 
 57   Other:
 58     port->ops->nibble_read_data
 59     port->ops->byte_read_data
 60     port->ops->compat_write_data
 61 
 62 The parport subsystem comprises 'parport' (the core port-sharing
 63 code), and a variety of low-level drivers that actually do the port
 64 accesses.  Each low-level driver handles a particular style of port
 65 (PC, Amiga, and so on).
 66 
 67 The parport interface to the device driver author can be broken down
 68 into global functions and port functions.
 69 
 70 The global functions are mostly for communicating between the device
 71 driver and the parport subsystem: acquiring a list of available ports,
 72 claiming a port for exclusive use, and so on.  They also include
 73 'generic' functions for doing standard things that will work on any
 74 IEEE 1284-capable architecture.
 75 
 76 The port functions are provided by the low-level drivers, although the
 77 core parport module provides generic 'defaults' for some routines.
 78 The port functions can be split into three groups: SPP, EPP, and ECP.
 79 
 80 SPP (Standard Parallel Port) functions modify so-called 'SPP'
 81 registers: data, status, and control.  The hardware may not actually
 82 have registers exactly like that, but the PC does and this interface is
 83 modelled after common PC implementations.  Other low-level drivers may
 84 be able to emulate most of the functionality.
 85 
 86 EPP (Enhanced Parallel Port) functions are provided for reading and
 87 writing in IEEE 1284 EPP mode, and ECP (Extended Capabilities Port)
 88 functions are used for IEEE 1284 ECP mode. (What about BECP? Does
 89 anyone care?)
 90 
 91 Hardware assistance for EPP and/or ECP transfers may or may not be
 92 available, and if it is available it may or may not be used.  If
 93 hardware is not used, the transfer will be software-driven.  In order
 94 to cope with peripherals that only tenuously support IEEE 1284, a
 95 low-level driver specific function is provided, for altering 'fudge
 96 factors'.
 97 
 98 GLOBAL FUNCTIONS
 99 ----------------
100 
101 parport_register_driver - register a device driver with parport
102 -----------------------
103 
104 SYNOPSIS
105 
106 #include <linux/parport.h>
107 
108 struct parport_driver {
109         const char *name;
110         void (*attach) (struct parport *);
111         void (*detach) (struct parport *);
112         struct parport_driver *next;
113 };
114 int parport_register_driver (struct parport_driver *driver);
115 
116 DESCRIPTION
117 
118 In order to be notified about parallel ports when they are detected,
119 parport_register_driver should be called.  Your driver will
120 immediately be notified of all ports that have already been detected,
121 and of each new port as low-level drivers are loaded.
122 
123 A 'struct parport_driver' contains the textual name of your driver,
124 a pointer to a function to handle new ports, and a pointer to a
125 function to handle ports going away due to a low-level driver
126 unloading.  Ports will only be detached if they are not being used
127 (i.e. there are no devices registered on them).
128 
129 The visible parts of the 'struct parport *' argument given to
130 attach/detach are:
131 
132 struct parport
133 {
134         struct parport *next; /* next parport in list */
135         const char *name;     /* port's name */
136         unsigned int modes;   /* bitfield of hardware modes */
137         struct parport_device_info probe_info;
138                               /* IEEE1284 info */
139         int number;           /* parport index */
140         struct parport_operations *ops;
141         ...
142 };
143 
144 There are other members of the structure, but they should not be
145 touched.
146 
147 The 'modes' member summarises the capabilities of the underlying
148 hardware.  It consists of flags which may be bitwise-ored together:
149 
150   PARPORT_MODE_PCSPP            IBM PC registers are available,
151                                 i.e. functions that act on data,
152                                 control and status registers are
153                                 probably writing directly to the
154                                 hardware.
155   PARPORT_MODE_TRISTATE         The data drivers may be turned off.
156                                 This allows the data lines to be used
157                                 for reverse (peripheral to host)
158                                 transfers.
159   PARPORT_MODE_COMPAT           The hardware can assist with
160                                 compatibility-mode (printer)
161                                 transfers, i.e. compat_write_block.
162   PARPORT_MODE_EPP              The hardware can assist with EPP
163                                 transfers.
164   PARPORT_MODE_ECP              The hardware can assist with ECP
165                                 transfers.
166   PARPORT_MODE_DMA              The hardware can use DMA, so you might
167                                 want to pass ISA DMA-able memory
168                                 (i.e. memory allocated using the
169                                 GFP_DMA flag with kmalloc) to the
170                                 low-level driver in order to take
171                                 advantage of it.
172 
173 There may be other flags in 'modes' as well.
174 
175 The contents of 'modes' is advisory only.  For example, if the
176 hardware is capable of DMA, and PARPORT_MODE_DMA is in 'modes', it
177 doesn't necessarily mean that DMA will always be used when possible.
178 Similarly, hardware that is capable of assisting ECP transfers won't
179 necessarily be used.
180 
181 RETURN VALUE
182 
183 Zero on success, otherwise an error code.
184 
185 ERRORS
186 
187 None. (Can it fail? Why return int?)
188 
189 EXAMPLE
190 
191 static void lp_attach (struct parport *port)
192 {
193         ...
194         private = kmalloc (...);
195         dev[count++] = parport_register_device (...);
196         ...
197 }
198 
199 static void lp_detach (struct parport *port)
200 {
201         ...
202 }
203 
204 static struct parport_driver lp_driver = {
205         "lp",
206         lp_attach,
207         lp_detach,
208         NULL /* always put NULL here */
209 };
210 
211 int lp_init (void)
212 {
213         ...
214         if (parport_register_driver (&lp_driver)) {
215                 /* Failed; nothing we can do. */
216                 return -EIO;
217         }
218         ...
219 }
220 
221 SEE ALSO
222 
223 parport_unregister_driver, parport_register_device, parport_enumerate
224 
225 parport_unregister_driver - tell parport to forget about this driver
226 -------------------------
227 
228 SYNOPSIS
229 
230 #include <linux/parport.h>
231 
232 struct parport_driver {
233         const char *name;
234         void (*attach) (struct parport *);
235         void (*detach) (struct parport *);
236         struct parport_driver *next;
237 };
238 void parport_unregister_driver (struct parport_driver *driver);
239 
240 DESCRIPTION
241 
242 This tells parport not to notify the device driver of new ports or of
243 ports going away.  Registered devices belonging to that driver are NOT
244 unregistered: parport_unregister_device must be used for each one.
245 
246 EXAMPLE
247 
248 void cleanup_module (void)
249 {
250         ...
251         /* Stop notifications. */
252         parport_unregister_driver (&lp_driver);
253 
254         /* Unregister devices. */
255         for (i = 0; i < NUM_DEVS; i++)
256                 parport_unregister_device (dev[i]);
257         ...
258 }
259 
260 SEE ALSO
261 
262 parport_register_driver, parport_enumerate
263 
264 parport_enumerate - retrieve a list of parallel ports (DEPRECATED)
265 -----------------
266 
267 SYNOPSIS
268 
269 #include <linux/parport.h>
270 
271 struct parport *parport_enumerate (void);
272 
273 DESCRIPTION
274 
275 Retrieve the first of a list of valid parallel ports for this machine.
276 Successive parallel ports can be found using the 'struct parport
277 *next' element of the 'struct parport *' that is returned.  If 'next'
278 is NULL, there are no more parallel ports in the list.  The number of
279 ports in the list will not exceed PARPORT_MAX.
280 
281 RETURN VALUE
282 
283 A 'struct parport *' describing a valid parallel port for the machine,
284 or NULL if there are none.
285 
286 ERRORS
287 
288 This function can return NULL to indicate that there are no parallel
289 ports to use.
290 
291 EXAMPLE
292 
293 int detect_device (void)
294 {
295         struct parport *port;
296 
297         for (port = parport_enumerate ();
298              port != NULL;
299              port = port->next) {
300                 /* Try to detect a device on the port... */
301                 ...
302              }
303         }
304 
305         ...
306 }
307 
308 NOTES
309 
310 parport_enumerate is deprecated; parport_register_driver should be
311 used instead.
312 
313 SEE ALSO
314 
315 parport_register_driver, parport_unregister_driver
316 
317 parport_register_device - register to use a port
318 -----------------------
319 
320 SYNOPSIS
321 
322 #include <linux/parport.h>
323 
324 typedef int (*preempt_func) (void *handle);
325 typedef void (*wakeup_func) (void *handle);
326 typedef int (*irq_func) (int irq, void *handle, struct pt_regs *);
327 
328 struct pardevice *parport_register_device(struct parport *port,
329                                           const char *name,
330                                           preempt_func preempt,
331                                           wakeup_func wakeup,
332                                           irq_func irq,
333                                           int flags,
334                                           void *handle);
335 
336 DESCRIPTION
337 
338 Use this function to register your device driver on a parallel port
339 ('port').  Once you have done that, you will be able to use
340 parport_claim and parport_release in order to use the port.
341 
342 The ('name') argument is the name of the device that appears in /proc
343 filesystem. The string must be valid for the whole lifetime of the
344 device (until parport_unregister_device is called).
345 
346 This function will register three callbacks into your driver:
347 'preempt', 'wakeup' and 'irq'.  Each of these may be NULL in order to
348 indicate that you do not want a callback.
349 
350 When the 'preempt' function is called, it is because another driver
351 wishes to use the parallel port.  The 'preempt' function should return
352 non-zero if the parallel port cannot be released yet -- if zero is
353 returned, the port is lost to another driver and the port must be
354 re-claimed before use.
355 
356 The 'wakeup' function is called once another driver has released the
357 port and no other driver has yet claimed it.  You can claim the
358 parallel port from within the 'wakeup' function (in which case the
359 claim is guaranteed to succeed), or choose not to if you don't need it
360 now.
361 
362 If an interrupt occurs on the parallel port your driver has claimed,
363 the 'irq' function will be called. (Write something about shared
364 interrupts here.)
365 
366 The 'handle' is a pointer to driver-specific data, and is passed to
367 the callback functions.
368 
369 'flags' may be a bitwise combination of the following flags:
370 
371         Flag            Meaning
372   PARPORT_DEV_EXCL      The device cannot share the parallel port at all.
373                         Use this only when absolutely necessary.
374 
375 The typedefs are not actually defined -- they are only shown in order
376 to make the function prototype more readable.
377 
378 The visible parts of the returned 'struct pardevice' are:
379 
380 struct pardevice {
381         struct parport *port;   /* Associated port */
382         void *private;          /* Device driver's 'handle' */
383         ...
384 };
385 
386 RETURN VALUE
387 
388 A 'struct pardevice *': a handle to the registered parallel port
389 device that can be used for parport_claim, parport_release, etc.
390 
391 ERRORS
392 
393 A return value of NULL indicates that there was a problem registering
394 a device on that port.
395 
396 EXAMPLE
397 
398 static int preempt (void *handle)
399 {
400         if (busy_right_now)
401                 return 1;
402 
403         must_reclaim_port = 1;
404         return 0;
405 }
406 
407 static void wakeup (void *handle)
408 {
409         struct toaster *private = handle;
410         struct pardevice *dev = private->dev;
411         if (!dev) return; /* avoid races */
412 
413         if (want_port)
414                 parport_claim (dev);
415 }
416 
417 static int toaster_detect (struct toaster *private, struct parport *port)
418 {
419         private->dev = parport_register_device (port, "toaster", preempt,
420                                                 wakeup, NULL, 0,
421                                                 private);
422         if (!private->dev)
423                 /* Couldn't register with parport. */
424                 return -EIO;
425 
426         must_reclaim_port = 0;
427         busy_right_now = 1;
428         parport_claim_or_block (private->dev);
429         ...
430         /* Don't need the port while the toaster warms up. */
431         busy_right_now = 0;
432         ...
433         busy_right_now = 1;
434         if (must_reclaim_port) {
435                 parport_claim_or_block (private->dev);
436                 must_reclaim_port = 0;
437         }
438         ...
439 }
440 
441 SEE ALSO
442 
443 parport_unregister_device, parport_claim
444 
445 parport_unregister_device - finish using a port
446 -------------------------
447 
448 SYNPOPSIS
449 
450 #include <linux/parport.h>
451 
452 void parport_unregister_device (struct pardevice *dev);
453 
454 DESCRIPTION
455 
456 This function is the opposite of parport_register_device.  After using
457 parport_unregister_device, 'dev' is no longer a valid device handle.
458 
459 You should not unregister a device that is currently claimed, although
460 if you do it will be released automatically.
461 
462 EXAMPLE
463 
464         ...
465         kfree (dev->private); /* before we lose the pointer */
466         parport_unregister_device (dev);
467         ...
468 
469 SEE ALSO
470 
471 parport_unregister_driver
472 
473 parport_claim, parport_claim_or_block - claim the parallel port for a device
474 -------------------------------------
475 
476 SYNOPSIS
477 
478 #include <linux/parport.h>
479 
480 int parport_claim (struct pardevice *dev);
481 int parport_claim_or_block (struct pardevice *dev);
482 
483 DESCRIPTION
484 
485 These functions attempt to gain control of the parallel port on which
486 'dev' is registered.  'parport_claim' does not block, but
487 'parport_claim_or_block' may do. (Put something here about blocking
488 interruptibly or non-interruptibly.)
489 
490 You should not try to claim a port that you have already claimed.
491 
492 RETURN VALUE
493 
494 A return value of zero indicates that the port was successfully
495 claimed, and the caller now has possession of the parallel port.
496 
497 If 'parport_claim_or_block' blocks before returning successfully, the
498 return value is positive.
499 
500 ERRORS
501 
502   -EAGAIN  The port is unavailable at the moment, but another attempt
503            to claim it may succeed.
504 
505 SEE ALSO
506 
507 parport_release
508 
509 parport_release - release the parallel port
510 ---------------
511 
512 SYNOPSIS
513 
514 #include <linux/parport.h>
515 
516 void parport_release (struct pardevice *dev);
517 
518 DESCRIPTION
519 
520 Once a parallel port device has been claimed, it can be released using
521 'parport_release'.  It cannot fail, but you should not release a
522 device that you do not have possession of.
523 
524 EXAMPLE
525 
526 static size_t write (struct pardevice *dev, const void *buf,
527                      size_t len)
528 {
529         ...
530         written = dev->port->ops->write_ecp_data (dev->port, buf,
531                                                   len);
532         parport_release (dev);
533         ...
534 }
535 
536 
537 SEE ALSO
538 
539 change_mode, parport_claim, parport_claim_or_block, parport_yield
540 
541 parport_yield, parport_yield_blocking - temporarily release a parallel port
542 -------------------------------------
543 
544 SYNOPSIS
545 
546 #include <linux/parport.h>
547 
548 int parport_yield (struct pardevice *dev)
549 int parport_yield_blocking (struct pardevice *dev);
550 
551 DESCRIPTION
552 
553 When a driver has control of a parallel port, it may allow another
554 driver to temporarily 'borrow' it.  'parport_yield' does not block;
555 'parport_yield_blocking' may do.
556 
557 RETURN VALUE
558 
559 A return value of zero indicates that the caller still owns the port
560 and the call did not block.
561 
562 A positive return value from 'parport_yield_blocking' indicates that
563 the caller still owns the port and the call blocked.
564 
565 A return value of -EAGAIN indicates that the caller no longer owns the
566 port, and it must be re-claimed before use.
567 
568 ERRORS
569 
570   -EAGAIN  Ownership of the parallel port was given away.
571 
572 SEE ALSO
573 
574 parport_release
575 
576 parport_wait_peripheral - wait for status lines, up to 35ms
577 -----------------------
578 
579 SYNOPSIS
580 
581 #include <linux/parport.h>
582 
583 int parport_wait_peripheral (struct parport *port,
584                              unsigned char mask,
585                              unsigned char val);
586 
587 DESCRIPTION
588 
589 Wait for the status lines in mask to match the values in val.
590 
591 RETURN VALUE
592 
593  -EINTR  a signal is pending
594       0  the status lines in mask have values in val
595       1  timed out while waiting (35ms elapsed)
596 
597 SEE ALSO
598 
599 parport_poll_peripheral
600 
601 parport_poll_peripheral - wait for status lines, in usec
602 -----------------------
603 
604 SYNOPSIS
605 
606 #include <linux/parport.h>
607 
608 int parport_poll_peripheral (struct parport *port,
609                              unsigned char mask,
610                              unsigned char val,
611                              int usec);
612 
613 DESCRIPTION
614 
615 Wait for the status lines in mask to match the values in val.
616 
617 RETURN VALUE
618 
619  -EINTR  a signal is pending
620       0  the status lines in mask have values in val
621       1  timed out while waiting (usec microseconds have elapsed)
622 
623 SEE ALSO
624 
625 parport_wait_peripheral
626 
627 parport_wait_event - wait for an event on a port
628 ------------------
629 
630 SYNOPSIS
631 
632 #include <linux/parport.h>
633 
634 int parport_wait_event (struct parport *port, signed long timeout)
635 
636 DESCRIPTION
637 
638 Wait for an event (e.g. interrupt) on a port.  The timeout is in
639 jiffies.
640 
641 RETURN VALUE
642 
643       0  success
644      <0  error (exit as soon as possible)
645      >0  timed out
646 
647 parport_negotiate - perform IEEE 1284 negotiation
648 -----------------
649 
650 SYNOPSIS
651 
652 #include <linux/parport.h>
653 
654 int parport_negotiate (struct parport *, int mode);
655 
656 DESCRIPTION
657 
658 Perform IEEE 1284 negotiation.
659 
660 RETURN VALUE
661 
662      0  handshake OK; IEEE 1284 peripheral and mode available
663     -1  handshake failed; peripheral not compliant (or none present)
664      1  handshake OK; IEEE 1284 peripheral present but mode not
665         available
666 
667 SEE ALSO
668 
669 parport_read, parport_write
670 
671 parport_read - read data from device
672 ------------
673 
674 SYNOPSIS
675 
676 #include <linux/parport.h>
677 
678 ssize_t parport_read (struct parport *, void *buf, size_t len);
679 
680 DESCRIPTION
681 
682 Read data from device in current IEEE 1284 transfer mode.  This only
683 works for modes that support reverse data transfer.
684 
685 RETURN VALUE
686 
687 If negative, an error code; otherwise the number of bytes transferred.
688 
689 SEE ALSO
690 
691 parport_write, parport_negotiate
692 
693 parport_write - write data to device
694 -------------
695 
696 SYNOPSIS
697 
698 #include <linux/parport.h>
699 
700 ssize_t parport_write (struct parport *, const void *buf, size_t len);
701 
702 DESCRIPTION
703 
704 Write data to device in current IEEE 1284 transfer mode.  This only
705 works for modes that support forward data transfer.
706 
707 RETURN VALUE
708 
709 If negative, an error code; otherwise the number of bytes transferred.
710 
711 SEE ALSO
712 
713 parport_read, parport_negotiate
714 
715 parport_open - register device for particular device number
716 ------------
717 
718 SYNOPSIS
719 
720 #include <linux/parport.h>
721 
722 struct pardevice *parport_open (int devnum, const char *name,
723                                 int (*pf) (void *),
724                                 void (*kf) (void *),
725                                 void (*irqf) (int, void *,
726                                               struct pt_regs *),
727                                 int flags, void *handle);
728 
729 DESCRIPTION
730 
731 This is like parport_register_device but takes a device number instead
732 of a pointer to a struct parport.
733 
734 RETURN VALUE
735 
736 See parport_register_device.  If no device is associated with devnum,
737 NULL is returned.
738 
739 SEE ALSO
740 
741 parport_register_device
742 
743 parport_close - unregister device for particular device number
744 -------------
745 
746 SYNOPSIS
747 
748 #include <linux/parport.h>
749 
750 void parport_close (struct pardevice *dev);
751 
752 DESCRIPTION
753 
754 This is the equivalent of parport_unregister_device for parport_open.
755 
756 SEE ALSO
757 
758 parport_unregister_device, parport_open
759 
760 parport_device_id - obtain IEEE 1284 Device ID
761 -----------------
762 
763 SYNOPSIS
764 
765 #include <linux/parport.h>
766 
767 ssize_t parport_device_id (int devnum, char *buffer, size_t len);
768 
769 DESCRIPTION
770 
771 Obtains the IEEE 1284 Device ID associated with a given device.
772 
773 RETURN VALUE
774 
775 If negative, an error code; otherwise, the number of bytes of buffer
776 that contain the device ID.  The format of the device ID is as
777 follows:
778 
779 [length][ID]
780 
781 The first two bytes indicate the inclusive length of the entire Device
782 ID, and are in big-endian order.  The ID is a sequence of pairs of the
783 form:
784 
785 key:value;
786 
787 NOTES
788 
789 Many devices have ill-formed IEEE 1284 Device IDs.
790 
791 SEE ALSO
792 
793 parport_find_class, parport_find_device
794 
795 parport_device_coords - convert device number to device coordinates
796 ------------------
797 
798 SYNOPSIS
799 
800 #include <linux/parport.h>
801 
802 int parport_device_coords (int devnum, int *parport, int *mux,
803                            int *daisy);
804 
805 DESCRIPTION
806 
807 Convert between device number (zero-based) and device coordinates
808 (port, multiplexor, daisy chain address).
809 
810 RETURN VALUE
811 
812 Zero on success, in which case the coordinates are (*parport, *mux,
813 *daisy).
814 
815 SEE ALSO
816 
817 parport_open, parport_device_id
818 
819 parport_find_class - find a device by its class
820 ------------------
821 
822 SYNOPSIS
823 
824 #include <linux/parport.h>
825 
826 typedef enum {
827         PARPORT_CLASS_LEGACY = 0,       /* Non-IEEE1284 device */
828         PARPORT_CLASS_PRINTER,
829         PARPORT_CLASS_MODEM,
830         PARPORT_CLASS_NET,
831         PARPORT_CLASS_HDC,              /* Hard disk controller */
832         PARPORT_CLASS_PCMCIA,
833         PARPORT_CLASS_MEDIA,            /* Multimedia device */
834         PARPORT_CLASS_FDC,              /* Floppy disk controller */
835         PARPORT_CLASS_PORTS,
836         PARPORT_CLASS_SCANNER,
837         PARPORT_CLASS_DIGCAM,
838         PARPORT_CLASS_OTHER,            /* Anything else */
839         PARPORT_CLASS_UNSPEC,           /* No CLS field in ID */
840         PARPORT_CLASS_SCSIADAPTER
841 } parport_device_class;
842 
843 int parport_find_class (parport_device_class cls, int from);
844 
845 DESCRIPTION
846 
847 Find a device by class.  The search starts from device number from+1.
848 
849 RETURN VALUE
850 
851 The device number of the next device in that class, or -1 if no such
852 device exists.
853 
854 NOTES
855 
856 Example usage:
857 
858 int devnum = -1;
859 while ((devnum = parport_find_class (PARPORT_CLASS_DIGCAM, devnum)) != -1) {
860     struct pardevice *dev = parport_open (devnum, ...);
861     ...
862 }
863 
864 SEE ALSO
865 
866 parport_find_device, parport_open, parport_device_id
867 
868 parport_find_device - find a device by its class
869 ------------------
870 
871 SYNOPSIS
872 
873 #include <linux/parport.h>
874 
875 int parport_find_device (const char *mfg, const char *mdl, int from);
876 
877 DESCRIPTION
878 
879 Find a device by vendor and model.  The search starts from device
880 number from+1.
881 
882 RETURN VALUE
883 
884 The device number of the next device matching the specifications, or
885 -1 if no such device exists.
886 
887 NOTES
888 
889 Example usage:
890 
891 int devnum = -1;
892 while ((devnum = parport_find_device ("IOMEGA", "ZIP+", devnum)) != -1) {
893     struct pardevice *dev = parport_open (devnum, ...);
894     ...
895 }
896 
897 SEE ALSO
898 
899 parport_find_class, parport_open, parport_device_id
900 
901 parport_set_timeout - set the inactivity timeout
902 -------------------
903 
904 SYNOPSIS
905 
906 #include <linux/parport.h>
907 
908 long parport_set_timeout (struct pardevice *dev, long inactivity);
909 
910 DESCRIPTION
911 
912 Set the inactivity timeout, in jiffies, for a registered device.  The
913 previous timeout is returned.
914 
915 RETURN VALUE
916 
917 The previous timeout, in jiffies.
918 
919 NOTES
920 
921 Some of the port->ops functions for a parport may take time, owing to
922 delays at the peripheral.  After the peripheral has not responded for
923 'inactivity' jiffies, a timeout will occur and the blocking function
924 will return.
925 
926 A timeout of 0 jiffies is a special case: the function must do as much
927 as it can without blocking or leaving the hardware in an unknown
928 state.  If port operations are performed from within an interrupt
929 handler, for instance, a timeout of 0 jiffies should be used.
930 
931 Once set for a registered device, the timeout will remain at the set
932 value until set again.
933 
934 SEE ALSO
935 
936 port->ops->xxx_read/write_yyy
937 
938 PORT FUNCTIONS
939 --------------
940 
941 The functions in the port->ops structure (struct parport_operations)
942 are provided by the low-level driver responsible for that port.
943 
944 port->ops->read_data - read the data register
945 --------------------
946 
947 SYNOPSIS
948 
949 #include <linux/parport.h>
950 
951 struct parport_operations {
952         ...
953         unsigned char (*read_data) (struct parport *port);
954         ...
955 };
956 
957 DESCRIPTION
958 
959 If port->modes contains the PARPORT_MODE_TRISTATE flag and the
960 PARPORT_CONTROL_DIRECTION bit in the control register is set, this
961 returns the value on the data pins.  If port->modes contains the
962 PARPORT_MODE_TRISTATE flag and the PARPORT_CONTROL_DIRECTION bit is
963 not set, the return value _may_ be the last value written to the data
964 register.  Otherwise the return value is undefined.
965 
966 SEE ALSO
967 
968 write_data, read_status, write_control
969 
970 port->ops->write_data - write the data register
971 ---------------------
972 
973 SYNOPSIS
974 
975 #include <linux/parport.h>
976 
977 struct parport_operations {
978         ...
979         void (*write_data) (struct parport *port, unsigned char d);
980         ...
981 };
982 
983 DESCRIPTION
984 
985 Writes to the data register.  May have side-effects (a STROBE pulse,
986 for instance).
987 
988 SEE ALSO
989 
990 read_data, read_status, write_control
991 
992 port->ops->read_status - read the status register
993 ----------------------
994 
995 SYNOPSIS
996 
997 #include <linux/parport.h>
998 
999 struct parport_operations {
1000         ...
1001         unsigned char (*read_status) (struct parport *port);
1002         ...
1003 };
1004 
1005 DESCRIPTION
1006 
1007 Reads from the status register.  This is a bitmask:
1008 
1009 - PARPORT_STATUS_ERROR (printer fault, "nFault")
1010 - PARPORT_STATUS_SELECT (on-line, "Select")
1011 - PARPORT_STATUS_PAPEROUT (no paper, "PError")
1012 - PARPORT_STATUS_ACK (handshake, "nAck")
1013 - PARPORT_STATUS_BUSY (busy, "Busy")
1014 
1015 There may be other bits set.
1016 
1017 SEE ALSO
1018 
1019 read_data, write_data, write_control
1020 
1021 port->ops->read_control - read the control register
1022 -----------------------
1023 
1024 SYNOPSIS
1025 
1026 #include <linux/parport.h>
1027 
1028 struct parport_operations {
1029         ...
1030         unsigned char (*read_control) (struct parport *port);
1031         ...
1032 };
1033 
1034 DESCRIPTION
1035 
1036 Returns the last value written to the control register (either from
1037 write_control or frob_control).  No port access is performed.
1038 
1039 SEE ALSO
1040 
1041 read_data, write_data, read_status, write_control
1042 
1043 port->ops->write_control - write the control register
1044 ------------------------
1045 
1046 SYNOPSIS
1047 
1048 #include <linux/parport.h>
1049 
1050 struct parport_operations {
1051         ...
1052         void (*write_control) (struct parport *port, unsigned char s);
1053         ...
1054 };
1055 
1056 DESCRIPTION
1057 
1058 Writes to the control register. This is a bitmask:
1059                           _______
1060 - PARPORT_CONTROL_STROBE (nStrobe)
1061                           _______
1062 - PARPORT_CONTROL_AUTOFD (nAutoFd)
1063                         _____
1064 - PARPORT_CONTROL_INIT (nInit)
1065                           _________
1066 - PARPORT_CONTROL_SELECT (nSelectIn)
1067 
1068 SEE ALSO
1069 
1070 read_data, write_data, read_status, frob_control
1071 
1072 port->ops->frob_control - write control register bits
1073 -----------------------
1074 
1075 SYNOPSIS
1076 
1077 #include <linux/parport.h>
1078 
1079 struct parport_operations {
1080         ...
1081         unsigned char (*frob_control) (struct parport *port,
1082                                        unsigned char mask,
1083                                        unsigned char val);
1084         ...
1085 };
1086 
1087 DESCRIPTION
1088 
1089 This is equivalent to reading from the control register, masking out
1090 the bits in mask, exclusive-or'ing with the bits in val, and writing
1091 the result to the control register.
1092 
1093 As some ports don't allow reads from the control port, a software copy
1094 of its contents is maintained, so frob_control is in fact only one
1095 port access.
1096 
1097 SEE ALSO
1098 
1099 read_data, write_data, read_status, write_control
1100 
1101 port->ops->enable_irq - enable interrupt generation
1102 ---------------------
1103 
1104 SYNOPSIS
1105 
1106 #include <linux/parport.h>
1107 
1108 struct parport_operations {
1109         ...
1110         void (*enable_irq) (struct parport *port);
1111         ...
1112 };
1113 
1114 DESCRIPTION
1115 
1116 The parallel port hardware is instructed to generate interrupts at
1117 appropriate moments, although those moments are
1118 architecture-specific.  For the PC architecture, interrupts are
1119 commonly generated on the rising edge of nAck.
1120 
1121 SEE ALSO
1122 
1123 disable_irq
1124 
1125 port->ops->disable_irq - disable interrupt generation
1126 ----------------------
1127 
1128 SYNOPSIS
1129 
1130 #include <linux/parport.h>
1131 
1132 struct parport_operations {
1133         ...
1134         void (*disable_irq) (struct parport *port);
1135         ...
1136 };
1137 
1138 DESCRIPTION
1139 
1140 The parallel port hardware is instructed not to generate interrupts.
1141 The interrupt itself is not masked.
1142 
1143 SEE ALSO
1144 
1145 enable_irq
1146 
1147 port->ops->data_forward - enable data drivers
1148 -----------------------
1149 
1150 SYNOPSIS
1151 
1152 #include <linux/parport.h>
1153 
1154 struct parport_operations {
1155         ...
1156         void (*data_forward) (struct parport *port);
1157         ...
1158 };
1159 
1160 DESCRIPTION
1161 
1162 Enables the data line drivers, for 8-bit host-to-peripheral
1163 communications.
1164 
1165 SEE ALSO
1166 
1167 data_reverse
1168 
1169 port->ops->data_reverse - tristate the buffer
1170 -----------------------
1171 
1172 SYNOPSIS
1173 
1174 #include <linux/parport.h>
1175 
1176 struct parport_operations {
1177         ...
1178         void (*data_reverse) (struct parport *port);
1179         ...
1180 };
1181 
1182 DESCRIPTION
1183 
1184 Places the data bus in a high impedance state, if port->modes has the
1185 PARPORT_MODE_TRISTATE bit set.
1186 
1187 SEE ALSO
1188 
1189 data_forward
1190 
1191 port->ops->epp_write_data - write EPP data
1192 -------------------------
1193 
1194 SYNOPSIS
1195 
1196 #include <linux/parport.h>
1197 
1198 struct parport_operations {
1199         ...
1200         size_t (*epp_write_data) (struct parport *port, const void *buf,
1201                                   size_t len, int flags);
1202         ...
1203 };
1204 
1205 DESCRIPTION
1206 
1207 Writes data in EPP mode, and returns the number of bytes written.
1208 
1209 The 'flags' parameter may be one or more of the following,
1210 bitwise-or'ed together:
1211 
1212 PARPORT_EPP_FAST        Use fast transfers. Some chips provide 16-bit and
1213                         32-bit registers.  However, if a transfer
1214                         times out, the return value may be unreliable.
1215 
1216 SEE ALSO
1217 
1218 epp_read_data, epp_write_addr, epp_read_addr
1219 
1220 port->ops->epp_read_data - read EPP data
1221 ------------------------
1222 
1223 SYNOPSIS
1224 
1225 #include <linux/parport.h>
1226 
1227 struct parport_operations {
1228         ...
1229         size_t (*epp_read_data) (struct parport *port, void *buf,
1230                                  size_t len, int flags);
1231         ...
1232 };
1233 
1234 DESCRIPTION
1235 
1236 Reads data in EPP mode, and returns the number of bytes read.
1237 
1238 The 'flags' parameter may be one or more of the following,
1239 bitwise-or'ed together:
1240 
1241 PARPORT_EPP_FAST        Use fast transfers. Some chips provide 16-bit and
1242                         32-bit registers.  However, if a transfer
1243                         times out, the return value may be unreliable.
1244 
1245 SEE ALSO
1246 
1247 epp_write_data, epp_write_addr, epp_read_addr
1248 
1249 port->ops->epp_write_addr - write EPP address
1250 -------------------------
1251 
1252 SYNOPSIS
1253 
1254 #include <linux/parport.h>
1255 
1256 struct parport_operations {
1257         ...
1258         size_t (*epp_write_addr) (struct parport *port,
1259                                   const void *buf, size_t len, int flags);
1260         ...
1261 };
1262 
1263 DESCRIPTION
1264 
1265 Writes EPP addresses (8 bits each), and returns the number written.
1266 
1267 The 'flags' parameter may be one or more of the following,
1268 bitwise-or'ed together:
1269 
1270 PARPORT_EPP_FAST        Use fast transfers. Some chips provide 16-bit and
1271                         32-bit registers.  However, if a transfer
1272                         times out, the return value may be unreliable.
1273 
1274 (Does PARPORT_EPP_FAST make sense for this function?)
1275 
1276 SEE ALSO
1277 
1278 epp_write_data, epp_read_data, epp_read_addr
1279 
1280 port->ops->epp_read_addr - read EPP address
1281 ------------------------
1282 
1283 SYNOPSIS
1284 
1285 #include <linux/parport.h>
1286 
1287 struct parport_operations {
1288         ...
1289         size_t (*epp_read_addr) (struct parport *port, void *buf,
1290                                  size_t len, int flags);
1291         ...
1292 };
1293 
1294 DESCRIPTION
1295 
1296 Reads EPP addresses (8 bits each), and returns the number read.
1297 
1298 The 'flags' parameter may be one or more of the following,
1299 bitwise-or'ed together:
1300 
1301 PARPORT_EPP_FAST        Use fast transfers. Some chips provide 16-bit and
1302                         32-bit registers.  However, if a transfer
1303                         times out, the return value may be unreliable.
1304 
1305 (Does PARPORT_EPP_FAST make sense for this function?)
1306 
1307 SEE ALSO
1308 
1309 epp_write_data, epp_read_data, epp_write_addr
1310 
1311 port->ops->ecp_write_data - write a block of ECP data
1312 -------------------------
1313 
1314 SYNOPSIS
1315 
1316 #include <linux/parport.h>
1317 
1318 struct parport_operations {
1319         ...
1320         size_t (*ecp_write_data) (struct parport *port,
1321                                   const void *buf, size_t len, int flags);
1322         ...
1323 };
1324 
1325 DESCRIPTION
1326 
1327 Writes a block of ECP data.  The 'flags' parameter is ignored.
1328 
1329 RETURN VALUE
1330 
1331 The number of bytes written.
1332 
1333 SEE ALSO
1334 
1335 ecp_read_data, ecp_write_addr
1336 
1337 port->ops->ecp_read_data - read a block of ECP data
1338 ------------------------
1339 
1340 SYNOPSIS
1341 
1342 #include <linux/parport.h>
1343 
1344 struct parport_operations {
1345         ...
1346         size_t (*ecp_read_data) (struct parport *port,
1347                                  void *buf, size_t len, int flags);
1348         ...
1349 };
1350 
1351 DESCRIPTION
1352 
1353 Reads a block of ECP data.  The 'flags' parameter is ignored.
1354 
1355 RETURN VALUE
1356 
1357 The number of bytes read.  NB. There may be more unread data in a
1358 FIFO.  Is there a way of stunning the FIFO to prevent this?
1359 
1360 SEE ALSO
1361 
1362 ecp_write_block, ecp_write_addr
1363 
1364 port->ops->ecp_write_addr - write a block of ECP addresses
1365 -------------------------
1366 
1367 SYNOPSIS
1368 
1369 #include <linux/parport.h>
1370 
1371 struct parport_operations {
1372         ...
1373         size_t (*ecp_write_addr) (struct parport *port,
1374                                   const void *buf, size_t len, int flags);
1375         ...
1376 };
1377 
1378 DESCRIPTION
1379 
1380 Writes a block of ECP addresses.  The 'flags' parameter is ignored.
1381 
1382 RETURN VALUE
1383 
1384 The number of bytes written.
1385 
1386 NOTES
1387 
1388 This may use a FIFO, and if so shall not return until the FIFO is empty.
1389 
1390 SEE ALSO
1391 
1392 ecp_read_data, ecp_write_data
1393 
1394 port->ops->nibble_read_data - read a block of data in nibble mode
1395 ---------------------------
1396 
1397 SYNOPSIS
1398 
1399 #include <linux/parport.h>
1400 
1401 struct parport_operations {
1402         ...
1403         size_t (*nibble_read_data) (struct parport *port,
1404                                     void *buf, size_t len, int flags);
1405         ...
1406 };
1407 
1408 DESCRIPTION
1409 
1410 Reads a block of data in nibble mode.  The 'flags' parameter is ignored.
1411 
1412 RETURN VALUE
1413 
1414 The number of whole bytes read.
1415 
1416 SEE ALSO
1417 
1418 byte_read_data, compat_write_data
1419 
1420 port->ops->byte_read_data - read a block of data in byte mode
1421 -------------------------
1422 
1423 SYNOPSIS
1424 
1425 #include <linux/parport.h>
1426 
1427 struct parport_operations {
1428         ...
1429         size_t (*byte_read_data) (struct parport *port,
1430                                   void *buf, size_t len, int flags);
1431         ...
1432 };
1433 
1434 DESCRIPTION
1435 
1436 Reads a block of data in byte mode.  The 'flags' parameter is ignored.
1437 
1438 RETURN VALUE
1439 
1440 The number of bytes read.
1441 
1442 SEE ALSO
1443 
1444 nibble_read_data, compat_write_data
1445 
1446 port->ops->compat_write_data - write a block of data in compatibility mode
1447 ----------------------------
1448 
1449 SYNOPSIS
1450 
1451 #include <linux/parport.h>
1452 
1453 struct parport_operations {
1454         ...
1455         size_t (*compat_write_data) (struct parport *port,
1456                                      const void *buf, size_t len, int flags);
1457         ...
1458 };
1459 
1460 DESCRIPTION
1461 
1462 Writes a block of data in compatibility mode.  The 'flags' parameter
1463 is ignored.
1464 
1465 RETURN VALUE
1466 
1467 The number of bytes written.
1468 
1469 SEE ALSO
1470 
1471 nibble_read_data, byte_read_data

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us