Documentation/driver-api/parport-lowlevel.rst

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