diff options
Diffstat (limited to 'Documentation/parport-lowlevel.txt')
| -rw-r--r-- | Documentation/parport-lowlevel.txt | 1471 |
1 files changed, 0 insertions, 1471 deletions
diff --git a/Documentation/parport-lowlevel.txt b/Documentation/parport-lowlevel.txt deleted file mode 100644 index 120eb20dbb09..000000000000 --- a/Documentation/parport-lowlevel.txt +++ /dev/null @@ -1,1471 +0,0 @@ -PARPORT interface documentation -------------------------------- - -Time-stamp: <2000-02-24 13:30:20 twaugh> - -Described here are the following functions: - -Global functions: - parport_register_driver - parport_unregister_driver - parport_enumerate - parport_register_device - parport_unregister_device - parport_claim - parport_claim_or_block - parport_release - parport_yield - parport_yield_blocking - parport_wait_peripheral - parport_poll_peripheral - parport_wait_event - parport_negotiate - parport_read - parport_write - parport_open - parport_close - parport_device_id - parport_device_coords - parport_find_class - parport_find_device - parport_set_timeout - -Port functions (can be overridden by low-level drivers): - SPP: - port->ops->read_data - port->ops->write_data - port->ops->read_status - port->ops->read_control - port->ops->write_control - port->ops->frob_control - port->ops->enable_irq - port->ops->disable_irq - port->ops->data_forward - port->ops->data_reverse - - EPP: - port->ops->epp_write_data - port->ops->epp_read_data - port->ops->epp_write_addr - port->ops->epp_read_addr - - ECP: - port->ops->ecp_write_data - port->ops->ecp_read_data - port->ops->ecp_write_addr - - Other: - port->ops->nibble_read_data - port->ops->byte_read_data - port->ops->compat_write_data - -The parport subsystem comprises 'parport' (the core port-sharing -code), and a variety of low-level drivers that actually do the port -accesses. Each low-level driver handles a particular style of port -(PC, Amiga, and so on). - -The parport interface to the device driver author can be broken down -into global functions and port functions. - -The global functions are mostly for communicating between the device -driver and the parport subsystem: acquiring a list of available ports, -claiming a port for exclusive use, and so on. They also include -'generic' functions for doing standard things that will work on any -IEEE 1284-capable architecture. - -The port functions are provided by the low-level drivers, although the -core parport module provides generic 'defaults' for some routines. -The port functions can be split into three groups: SPP, EPP, and ECP. - -SPP (Standard Parallel Port) functions modify so-called 'SPP' -registers: data, status, and control. The hardware may not actually -have registers exactly like that, but the PC does and this interface is -modelled after common PC implementations. Other low-level drivers may -be able to emulate most of the functionality. - -EPP (Enhanced Parallel Port) functions are provided for reading and -writing in IEEE 1284 EPP mode, and ECP (Extended Capabilities Port) -functions are used for IEEE 1284 ECP mode. (What about BECP? Does -anyone care?) - -Hardware assistance for EPP and/or ECP transfers may or may not be -available, and if it is available it may or may not be used. If -hardware is not used, the transfer will be software-driven. In order -to cope with peripherals that only tenuously support IEEE 1284, a -low-level driver specific function is provided, for altering 'fudge -factors'. - -GLOBAL FUNCTIONS ----------------- - -parport_register_driver - register a device driver with parport ------------------------ - -SYNOPSIS - -#include <linux/parport.h> - -struct parport_driver { - const char *name; - void (*attach) (struct parport *); - void (*detach) (struct parport *); - struct parport_driver *next; -}; -int parport_register_driver (struct parport_driver *driver); - -DESCRIPTION - -In order to be notified about parallel ports when they are detected, -parport_register_driver should be called. Your driver will -immediately be notified of all ports that have already been detected, -and of each new port as low-level drivers are loaded. - -A 'struct parport_driver' contains the textual name of your driver, -a pointer to a function to handle new ports, and a pointer to a -function to handle ports going away due to a low-level driver -unloading. Ports will only be detached if they are not being used -(i.e. there are no devices registered on them). - -The visible parts of the 'struct parport *' argument given to -attach/detach are: - -struct parport -{ - struct parport *next; /* next parport in list */ - const char *name; /* port's name */ - unsigned int modes; /* bitfield of hardware modes */ - struct parport_device_info probe_info; - /* IEEE1284 info */ - int number; /* parport index */ - struct parport_operations *ops; - ... -}; - -There are other members of the structure, but they should not be -touched. - -The 'modes' member summarises the capabilities of the underlying -hardware. It consists of flags which may be bitwise-ored together: - - PARPORT_MODE_PCSPP IBM PC registers are available, - i.e. functions that act on data, - control and status registers are - probably writing directly to the - hardware. - PARPORT_MODE_TRISTATE The data drivers may be turned off. - This allows the data lines to be used - for reverse (peripheral to host) - transfers. - PARPORT_MODE_COMPAT The hardware can assist with - compatibility-mode (printer) - transfers, i.e. compat_write_block. - PARPORT_MODE_EPP The hardware can assist with EPP - transfers. - PARPORT_MODE_ECP The hardware can assist with ECP - transfers. - PARPORT_MODE_DMA The hardware can use DMA, so you might - want to pass ISA DMA-able memory - (i.e. memory allocated using the - GFP_DMA flag with kmalloc) to the - low-level driver in order to take - advantage of it. - -There may be other flags in 'modes' as well. - -The contents of 'modes' is advisory only. For example, if the -hardware is capable of DMA, and PARPORT_MODE_DMA is in 'modes', it -doesn't necessarily mean that DMA will always be used when possible. -Similarly, hardware that is capable of assisting ECP transfers won't -necessarily be used. - -RETURN VALUE - -Zero on success, otherwise an error code. - -ERRORS - -None. (Can it fail? Why return int?) - -EXAMPLE - -static void lp_attach (struct parport *port) -{ - ... - private = kmalloc (...); - dev[count++] = parport_register_device (...); - ... -} - -static void lp_detach (struct parport *port) -{ - ... -} - -static struct parport_driver lp_driver = { - "lp", - lp_attach, - lp_detach, - NULL /* always put NULL here */ -}; - -int lp_init (void) -{ - ... - if (parport_register_driver (&lp_driver)) { - /* Failed; nothing we can do. */ - return -EIO; - } - ... -} - -SEE ALSO - -parport_unregister_driver, parport_register_device, parport_enumerate - -parport_unregister_driver - tell parport to forget about this driver -------------------------- - -SYNOPSIS - -#include <linux/parport.h> - -struct parport_driver { - const char *name; - void (*attach) (struct parport *); - void (*detach) (struct parport *); - struct parport_driver *next; -}; -void parport_unregister_driver (struct parport_driver *driver); - -DESCRIPTION - -This tells parport not to notify the device driver of new ports or of -ports going away. Registered devices belonging to that driver are NOT -unregistered: parport_unregister_device must be used for each one. - -EXAMPLE - -void cleanup_module (void) -{ - ... - /* Stop notifications. */ - parport_unregister_driver (&lp_driver); - - /* Unregister devices. */ - for (i = 0; i < NUM_DEVS; i++) - parport_unregister_device (dev[i]); - ... -} - -SEE ALSO - -parport_register_driver, parport_enumerate - -parport_enumerate - retrieve a list of parallel ports (DEPRECATED) ------------------ - -SYNOPSIS - -#include <linux/parport.h> - -struct parport *parport_enumerate (void); - -DESCRIPTION - -Retrieve the first of a list of valid parallel ports for this machine. -Successive parallel ports can be found using the 'struct parport -*next' element of the 'struct parport *' that is returned. If 'next' -is NULL, there are no more parallel ports in the list. The number of -ports in the list will not exceed PARPORT_MAX. - -RETURN VALUE - -A 'struct parport *' describing a valid parallel port for the machine, -or NULL if there are none. - -ERRORS - -This function can return NULL to indicate that there are no parallel -ports to use. - -EXAMPLE - -int detect_device (void) -{ - struct parport *port; - - for (port = parport_enumerate (); - port != NULL; - port = port->next) { - /* Try to detect a device on the port... */ - ... - } - } - - ... -} - -NOTES - -parport_enumerate is deprecated; parport_register_driver should be -used instead. - -SEE ALSO - -parport_register_driver, parport_unregister_driver - -parport_register_device - register to use a port ------------------------ - -SYNOPSIS - -#include <linux/parport.h> - -typedef int (*preempt_func) (void *handle); -typedef void (*wakeup_func) (void *handle); -typedef int (*irq_func) (int irq, void *handle, struct pt_regs *); - -struct pardevice *parport_register_device(struct parport *port, - const char *name, - preempt_func preempt, - wakeup_func wakeup, - irq_func irq, - int flags, - void *handle); - -DESCRIPTION - -Use this function to register your device driver on a parallel port -('port'). Once you have done that, you will be able to use -parport_claim and parport_release in order to use the port. - -The ('name') argument is the name of the device that appears in /proc -filesystem. The string must be valid for the whole lifetime of the -device (until parport_unregister_device is called). - -This function will register three callbacks into your driver: -'preempt', 'wakeup' and 'irq'. Each of these may be NULL in order to -indicate that you do not want a callback. - -When the 'preempt' function is called, it is because another driver -wishes to use the parallel port. The 'preempt' function should return -non-zero if the parallel port cannot be released yet -- if zero is -returned, the port is lost to another driver and the port must be -re-claimed before use. - -The 'wakeup' function is called once another driver has released the -port and no other driver has yet claimed it. You can claim the -parallel port from within the 'wakeup' function (in which case the -claim is guaranteed to succeed), or choose not to if you don't need it -now. - -If an interrupt occurs on the parallel port your driver has claimed, -the 'irq' function will be called. (Write something about shared -interrupts here.) - -The 'handle' is a pointer to driver-specific data, and is passed to -the callback functions. - -'flags' may be a bitwise combination of the following flags: - - Flag Meaning - PARPORT_DEV_EXCL The device cannot share the parallel port at all. - Use this only when absolutely necessary. - -The typedefs are not actually defined -- they are only shown in order -to make the function prototype more readable. - -The visible parts of the returned 'struct pardevice' are: - -struct pardevice { - struct parport *port; /* Associated port */ - void *private; /* Device driver's 'handle' */ - ... -}; - -RETURN VALUE - -A 'struct pardevice *': a handle to the registered parallel port -device that can be used for parport_claim, parport_release, etc. - -ERRORS - -A return value of NULL indicates that there was a problem registering -a device on that port. - -EXAMPLE - -static int preempt (void *handle) -{ - if (busy_right_now) - return 1; - - must_reclaim_port = 1; - return 0; -} - -static void wakeup (void *handle) -{ - struct toaster *private = handle; - struct pardevice *dev = private->dev; - if (!dev) return; /* avoid races */ - - if (want_port) - parport_claim (dev); -} - -static int toaster_detect (struct toaster *private, struct parport *port) -{ - private->dev = parport_register_device (port, "toaster", preempt, - wakeup, NULL, 0, - private); - if (!private->dev) - /* Couldn't register with parport. */ - return -EIO; - - must_reclaim_port = 0; - busy_right_now = 1; - parport_claim_or_block (private->dev); - ... - /* Don't need the port while the toaster warms up. */ - busy_right_now = 0; - ... - busy_right_now = 1; - if (must_reclaim_port) { - parport_claim_or_block (private->dev); - must_reclaim_port = 0; - } - ... -} - -SEE ALSO - -parport_unregister_device, parport_claim - -parport_unregister_device - finish using a port -------------------------- - -SYNPOPSIS - -#include <linux/parport.h> - -void parport_unregister_device (struct pardevice *dev); - -DESCRIPTION - -This function is the opposite of parport_register_device. After using -parport_unregister_device, 'dev' is no longer a valid device handle. - -You should not unregister a device that is currently claimed, although -if you do it will be released automatically. - -EXAMPLE - - ... - kfree (dev->private); /* before we lose the pointer */ - parport_unregister_device (dev); - ... - -SEE ALSO - -parport_unregister_driver - -parport_claim, parport_claim_or_block - claim the parallel port for a device -------------------------------------- - -SYNOPSIS - -#include <linux/parport.h> - -int parport_claim (struct pardevice *dev); -int parport_claim_or_block (struct pardevice *dev); - -DESCRIPTION - -These functions attempt to gain control of the parallel port on which -'dev' is registered. 'parport_claim' does not block, but -'parport_claim_or_block' may do. (Put something here about blocking -interruptibly or non-interruptibly.) - -You should not try to claim a port that you have already claimed. - -RETURN VALUE - -A return value of zero indicates that the port was successfully -claimed, and the caller now has possession of the parallel port. - -If 'parport_claim_or_block' blocks before returning successfully, the -return value is positive. - -ERRORS - - -EAGAIN The port is unavailable at the moment, but another attempt - to claim it may succeed. - -SEE ALSO - -parport_release - -parport_release - release the parallel port ---------------- - -SYNOPSIS - -#include <linux/parport.h> - -void parport_release (struct pardevice *dev); - -DESCRIPTION - -Once a parallel port device has been claimed, it can be released using -'parport_release'. It cannot fail, but you should not release a -device that you do not have possession of. - -EXAMPLE - -static size_t write (struct pardevice *dev, const void *buf, - size_t len) -{ - ... - written = dev->port->ops->write_ecp_data (dev->port, buf, - len); - parport_release (dev); - ... -} - - -SEE ALSO - -change_mode, parport_claim, parport_claim_or_block, parport_yield - -parport_yield, parport_yield_blocking - temporarily release a parallel port -------------------------------------- - -SYNOPSIS - -#include <linux/parport.h> - -int parport_yield (struct pardevice *dev) -int parport_yield_blocking (struct pardevice *dev); - -DESCRIPTION - -When a driver has control of a parallel port, it may allow another -driver to temporarily 'borrow' it. 'parport_yield' does not block; -'parport_yield_blocking' may do. - -RETURN VALUE - -A return value of zero indicates that the caller still owns the port -and the call did not block. - -A positive return value from 'parport_yield_blocking' indicates that -the caller still owns the port and the call blocked. - -A return value of -EAGAIN indicates that the caller no longer owns the -port, and it must be re-claimed before use. - -ERRORS - - -EAGAIN Ownership of the parallel port was given away. - -SEE ALSO - -parport_release - -parport_wait_peripheral - wait for status lines, up to 35ms ------------------------ - -SYNOPSIS - -#include <linux/parport.h> - -int parport_wait_peripheral (struct parport *port, - unsigned char mask, - unsigned char val); - -DESCRIPTION - -Wait for the status lines in mask to match the values in val. - -RETURN VALUE - - -EINTR a signal is pending - 0 the status lines in mask have values in val - 1 timed out while waiting (35ms elapsed) - -SEE ALSO - -parport_poll_peripheral - -parport_poll_peripheral - wait for status lines, in usec ------------------------ - -SYNOPSIS - -#include <linux/parport.h> - -int parport_poll_peripheral (struct parport *port, - unsigned char mask, - unsigned char val, - int usec); - -DESCRIPTION - -Wait for the status lines in mask to match the values in val. - -RETURN VALUE - - -EINTR a signal is pending - 0 the status lines in mask have values in val - 1 timed out while waiting (usec microseconds have elapsed) - -SEE ALSO - -parport_wait_peripheral - -parport_wait_event - wait for an event on a port ------------------- - -SYNOPSIS - -#include <linux/parport.h> - -int parport_wait_event (struct parport *port, signed long timeout) - -DESCRIPTION - -Wait for an event (e.g. interrupt) on a port. The timeout is in -jiffies. - -RETURN VALUE - - 0 success - <0 error (exit as soon as possible) - >0 timed out - -parport_negotiate - perform IEEE 1284 negotiation ------------------ - -SYNOPSIS - -#include <linux/parport.h> - -int parport_negotiate (struct parport *, int mode); - -DESCRIPTION - -Perform IEEE 1284 negotiation. - -RETURN VALUE - - 0 handshake OK; IEEE 1284 peripheral and mode available - -1 handshake failed; peripheral not compliant (or none present) - 1 handshake OK; IEEE 1284 peripheral present but mode not - available - -SEE ALSO - -parport_read, parport_write - -parport_read - read data from device ------------- - -SYNOPSIS - -#include <linux/parport.h> - -ssize_t parport_read (struct parport *, void *buf, size_t len); - -DESCRIPTION - -Read data from device in current IEEE 1284 transfer mode. This only -works for modes that support reverse data transfer. - -RETURN VALUE - -If negative, an error code; otherwise the number of bytes transferred. - -SEE ALSO - -parport_write, parport_negotiate - -parport_write - write data to device -------------- - -SYNOPSIS - -#include <linux/parport.h> - -ssize_t parport_write (struct parport *, const void *buf, size_t len); - -DESCRIPTION - -Write data to device in current IEEE 1284 transfer mode. This only -works for modes that support forward data transfer. - -RETURN VALUE - -If negative, an error code; otherwise the number of bytes transferred. - -SEE ALSO - -parport_read, parport_negotiate - -parport_open - register device for particular device number ------------- - -SYNOPSIS - -#include <linux/parport.h> - -struct pardevice *parport_open (int devnum, const char *name, - int (*pf) (void *), - void (*kf) (void *), - void (*irqf) (int, void *, - struct pt_regs *), - int flags, void *handle); - -DESCRIPTION - -This is like parport_register_device but takes a device number instead -of a pointer to a struct parport. - -RETURN VALUE - -See parport_register_device. If no device is associated with devnum, -NULL is returned. - -SEE ALSO - -parport_register_device - -parport_close - unregister device for particular device number -------------- - -SYNOPSIS - -#include <linux/parport.h> - -void parport_close (struct pardevice *dev); - -DESCRIPTION - -This is the equivalent of parport_unregister_device for parport_open. - -SEE ALSO - -parport_unregister_device, parport_open - -parport_device_id - obtain IEEE 1284 Device ID ------------------ - -SYNOPSIS - -#include <linux/parport.h> - -ssize_t parport_device_id (int devnum, char *buffer, size_t len); - -DESCRIPTION - -Obtains the IEEE 1284 Device ID associated with a given device. - -RETURN VALUE - -If negative, an error code; otherwise, the number of bytes of buffer -that contain the device ID. The format of the device ID is as -follows: - -[length][ID] - -The first two bytes indicate the inclusive length of the entire Device -ID, and are in big-endian order. The ID is a sequence of pairs of the -form: - -key:value; - -NOTES - -Many devices have ill-formed IEEE 1284 Device IDs. - -SEE ALSO - -parport_find_class, parport_find_device - -parport_device_coords - convert device number to device coordinates ------------------- - -SYNOPSIS - -#include <linux/parport.h> - -int parport_device_coords (int devnum, int *parport, int *mux, - int *daisy); - -DESCRIPTION - -Convert between device number (zero-based) and device coordinates -(port, multiplexor, daisy chain address). - -RETURN VALUE - -Zero on success, in which case the coordinates are (*parport, *mux, -*daisy). - -SEE ALSO - -parport_open, parport_device_id - -parport_find_class - find a device by its class ------------------- - -SYNOPSIS - -#include <linux/parport.h> - -typedef enum { - PARPORT_CLASS_LEGACY = 0, /* Non-IEEE1284 device */ - PARPORT_CLASS_PRINTER, - PARPORT_CLASS_MODEM, - PARPORT_CLASS_NET, - PARPORT_CLASS_HDC, /* Hard disk controller */ - PARPORT_CLASS_PCMCIA, - PARPORT_CLASS_MEDIA, /* Multimedia device */ - PARPORT_CLASS_FDC, /* Floppy disk controller */ - PARPORT_CLASS_PORTS, - PARPORT_CLASS_SCANNER, - PARPORT_CLASS_DIGCAM, - PARPORT_CLASS_OTHER, /* Anything else */ - PARPORT_CLASS_UNSPEC, /* No CLS field in ID */ - PARPORT_CLASS_SCSIADAPTER -} parport_device_class; - -int parport_find_class (parport_device_class cls, int from); - -DESCRIPTION - -Find a device by class. The search starts from device number from+1. - -RETURN VALUE - -The device number of the next device in that class, or -1 if no such -device exists. - -NOTES - -Example usage: - -int devnum = -1; -while ((devnum = parport_find_class (PARPORT_CLASS_DIGCAM, devnum)) != -1) { - struct pardevice *dev = parport_open (devnum, ...); - ... -} - -SEE ALSO - -parport_find_device, parport_open, parport_device_id - -parport_find_device - find a device by its class ------------------- - -SYNOPSIS - -#include <linux/parport.h> - -int parport_find_device (const char *mfg, const char *mdl, int from); - -DESCRIPTION - -Find a device by vendor and model. The search starts from device -number from+1. - -RETURN VALUE - -The device number of the next device matching the specifications, or --1 if no such device exists. - -NOTES - -Example usage: - -int devnum = -1; -while ((devnum = parport_find_device ("IOMEGA", "ZIP+", devnum)) != -1) { - struct pardevice *dev = parport_open (devnum, ...); - ... -} - -SEE ALSO - -parport_find_class, parport_open, parport_device_id - -parport_set_timeout - set the inactivity timeout -------------------- - -SYNOPSIS - -#include <linux/parport.h> - -long parport_set_timeout (struct pardevice *dev, long inactivity); - -DESCRIPTION - -Set the inactivity timeout, in jiffies, for a registered device. The -previous timeout is returned. - -RETURN VALUE - -The previous timeout, in jiffies. - -NOTES - -Some of the port->ops functions for a parport may take time, owing to -delays at the peripheral. After the peripheral has not responded for -'inactivity' jiffies, a timeout will occur and the blocking function -will return. - -A timeout of 0 jiffies is a special case: the function must do as much -as it can without blocking or leaving the hardware in an unknown -state. If port operations are performed from within an interrupt -handler, for instance, a timeout of 0 jiffies should be used. - -Once set for a registered device, the timeout will remain at the set -value until set again. - -SEE ALSO - -port->ops->xxx_read/write_yyy - -PORT FUNCTIONS --------------- - -The functions in the port->ops structure (struct parport_operations) -are provided by the low-level driver responsible for that port. - -port->ops->read_data - read the data register --------------------- - -SYNOPSIS - -#include <linux/parport.h> - -struct parport_operations { - ... - unsigned char (*read_data) (struct parport *port); - ... -}; - -DESCRIPTION - -If port->modes contains the PARPORT_MODE_TRISTATE flag and the -PARPORT_CONTROL_DIRECTION bit in the control register is set, this -returns the value on the data pins. If port->modes contains the -PARPORT_MODE_TRISTATE flag and the PARPORT_CONTROL_DIRECTION bit is -not set, the return value _may_ be the last value written to the data -register. Otherwise the return value is undefined. - -SEE ALSO - -write_data, read_status, write_control - -port->ops->write_data - write the data register ---------------------- - -SYNOPSIS - -#include <linux/parport.h> - -struct parport_operations { - ... - void (*write_data) (struct parport *port, unsigned char d); - ... -}; - -DESCRIPTION - -Writes to the data register. May have side-effects (a STROBE pulse, -for instance). - -SEE ALSO - -read_data, read_status, write_control - -port->ops->read_status - read the status register ----------------------- - -SYNOPSIS - -#include <linux/parport.h> - -struct parport_operations { - ... - unsigned char (*read_status) (struct parport *port); - ... -}; - -DESCRIPTION - -Reads from the status register. This is a bitmask: - -- PARPORT_STATUS_ERROR (printer fault, "nFault") -- PARPORT_STATUS_SELECT (on-line, "Select") -- PARPORT_STATUS_PAPEROUT (no paper, "PError") -- PARPORT_STATUS_ACK (handshake, "nAck") -- PARPORT_STATUS_BUSY (busy, "Busy") - -There may be other bits set. - -SEE ALSO - -read_data, write_data, write_control - -port->ops->read_control - read the control register ------------------------ - -SYNOPSIS - -#include <linux/parport.h> - -struct parport_operations { - ... - unsigned char (*read_control) (struct parport *port); - ... -}; - -DESCRIPTION - -Returns the last value written to the control register (either from -write_control or frob_control). No port access is performed. - -SEE ALSO - -read_data, write_data, read_status, write_control - -port->ops->write_control - write the control register ------------------------- - -SYNOPSIS - -#include <linux/parport.h> - -struct parport_operations { - ... - void (*write_control) (struct parport *port, unsigned char s); - ... -}; - -DESCRIPTION - -Writes to the control register. This is a bitmask: - _______ -- PARPORT_CONTROL_STROBE (nStrobe) - _______ -- PARPORT_CONTROL_AUTOFD (nAutoFd) - _____ -- PARPORT_CONTROL_INIT (nInit) - _________ -- PARPORT_CONTROL_SELECT (nSelectIn) - -SEE ALSO - -read_data, write_data, read_status, frob_control - -port->ops->frob_control - write control register bits ------------------------ - -SYNOPSIS - -#include <linux/parport.h> - -struct parport_operations { - ... - unsigned char (*frob_control) (struct parport *port, - unsigned char mask, - unsigned char val); - ... -}; - -DESCRIPTION - -This is equivalent to reading from the control register, masking out -the bits in mask, exclusive-or'ing with the bits in val, and writing -the result to the control register. - -As some ports don't allow reads from the control port, a software copy -of its contents is maintained, so frob_control is in fact only one -port access. - -SEE ALSO - -read_data, write_data, read_status, write_control - -port->ops->enable_irq - enable interrupt generation ---------------------- - -SYNOPSIS - -#include <linux/parport.h> - -struct parport_operations { - ... - void (*enable_irq) (struct parport *port); - ... -}; - -DESCRIPTION - -The parallel port hardware is instructed to generate interrupts at -appropriate moments, although those moments are -architecture-specific. For the PC architecture, interrupts are -commonly generated on the rising edge of nAck. - -SEE ALSO - -disable_irq - -port->ops->disable_irq - disable interrupt generation ----------------------- - -SYNOPSIS - -#include <linux/parport.h> - -struct parport_operations { - ... - void (*disable_irq) (struct parport *port); - ... -}; - -DESCRIPTION - -The parallel port hardware is instructed not to generate interrupts. -The interrupt itself is not masked. - -SEE ALSO - -enable_irq - -port->ops->data_forward - enable data drivers ------------------------ - -SYNOPSIS - -#include <linux/parport.h> - -struct parport_operations { - ... - void (*data_forward) (struct parport *port); - ... -}; - -DESCRIPTION - -Enables the data line drivers, for 8-bit host-to-peripheral -communications. - -SEE ALSO - -data_reverse - -port->ops->data_reverse - tristate the buffer ------------------------ - -SYNOPSIS - -#include <linux/parport.h> - -struct parport_operations { - ... - void (*data_reverse) (struct parport *port); - ... -}; - -DESCRIPTION - -Places the data bus in a high impedance state, if port->modes has the -PARPORT_MODE_TRISTATE bit set. - -SEE ALSO - -data_forward - -port->ops->epp_write_data - write EPP data -------------------------- - -SYNOPSIS - -#include <linux/parport.h> - -struct parport_operations { - ... - size_t (*epp_write_data) (struct parport *port, const void *buf, - size_t len, int flags); - ... -}; - -DESCRIPTION - -Writes data in EPP mode, and returns the number of bytes written. - -The 'flags' parameter may be one or more of the following, -bitwise-or'ed together: - -PARPORT_EPP_FAST Use fast transfers. Some chips provide 16-bit and - 32-bit registers. However, if a transfer - times out, the return value may be unreliable. - -SEE ALSO - -epp_read_data, epp_write_addr, epp_read_addr - -port->ops->epp_read_data - read EPP data ------------------------- - -SYNOPSIS - -#include <linux/parport.h> - -struct parport_operations { - ... - size_t (*epp_read_data) (struct parport *port, void *buf, - size_t len, int flags); - ... -}; - -DESCRIPTION - -Reads data in EPP mode, and returns the number of bytes read. - -The 'flags' parameter may be one or more of the following, -bitwise-or'ed together: - -PARPORT_EPP_FAST Use fast transfers. Some chips provide 16-bit and - 32-bit registers. However, if a transfer - times out, the return value may be unreliable. - -SEE ALSO - -epp_write_data, epp_write_addr, epp_read_addr - -port->ops->epp_write_addr - write EPP address -------------------------- - -SYNOPSIS - -#include <linux/parport.h> - -struct parport_operations { - ... - size_t (*epp_write_addr) (struct parport *port, - const void *buf, size_t len, int flags); - ... -}; - -DESCRIPTION - -Writes EPP addresses (8 bits each), and returns the number written. - -The 'flags' parameter may be one or more of the following, -bitwise-or'ed together: - -PARPORT_EPP_FAST Use fast transfers. Some chips provide 16-bit and - 32-bit registers. However, if a transfer - times out, the return value may be unreliable. - -(Does PARPORT_EPP_FAST make sense for this function?) - -SEE ALSO - -epp_write_data, epp_read_data, epp_read_addr - -port->ops->epp_read_addr - read EPP address ------------------------- - -SYNOPSIS - -#include <linux/parport.h> - -struct parport_operations { - ... - size_t (*epp_read_addr) (struct parport *port, void *buf, - size_t len, int flags); - ... -}; - -DESCRIPTION - -Reads EPP addresses (8 bits each), and returns the number read. - -The 'flags' parameter may be one or more of the following, -bitwise-or'ed together: - -PARPORT_EPP_FAST Use fast transfers. Some chips provide 16-bit and - 32-bit registers. However, if a transfer - times out, the return value may be unreliable. - -(Does PARPORT_EPP_FAST make sense for this function?) - -SEE ALSO - -epp_write_data, epp_read_data, epp_write_addr - -port->ops->ecp_write_data - write a block of ECP data -------------------------- - -SYNOPSIS - -#include <linux/parport.h> - -struct parport_operations { - ... - size_t (*ecp_write_data) (struct parport *port, - const void *buf, size_t len, int flags); - ... -}; - -DESCRIPTION - -Writes a block of ECP data. The 'flags' parameter is ignored. - -RETURN VALUE - -The number of bytes written. - -SEE ALSO - -ecp_read_data, ecp_write_addr - -port->ops->ecp_read_data - read a block of ECP data ------------------------- - -SYNOPSIS - -#include <linux/parport.h> - -struct parport_operations { - ... - size_t (*ecp_read_data) (struct parport *port, - void *buf, size_t len, int flags); - ... -}; - -DESCRIPTION - -Reads a block of ECP data. The 'flags' parameter is ignored. - -RETURN VALUE - -The number of bytes read. NB. There may be more unread data in a -FIFO. Is there a way of stunning the FIFO to prevent this? - -SEE ALSO - -ecp_write_block, ecp_write_addr - -port->ops->ecp_write_addr - write a block of ECP addresses -------------------------- - -SYNOPSIS - -#include <linux/parport.h> - -struct parport_operations { - ... - size_t (*ecp_write_addr) (struct parport *port, - const void *buf, size_t len, int flags); - ... -}; - -DESCRIPTION - -Writes a block of ECP addresses. The 'flags' parameter is ignored. - -RETURN VALUE - -The number of bytes written. - -NOTES - -This may use a FIFO, and if so shall not return until the FIFO is empty. - -SEE ALSO - -ecp_read_data, ecp_write_data - -port->ops->nibble_read_data - read a block of data in nibble mode ---------------------------- - -SYNOPSIS - -#include <linux/parport.h> - -struct parport_operations { - ... - size_t (*nibble_read_data) (struct parport *port, - void *buf, size_t len, int flags); - ... -}; - -DESCRIPTION - -Reads a block of data in nibble mode. The 'flags' parameter is ignored. - -RETURN VALUE - -The number of whole bytes read. - -SEE ALSO - -byte_read_data, compat_write_data - -port->ops->byte_read_data - read a block of data in byte mode -------------------------- - -SYNOPSIS - -#include <linux/parport.h> - -struct parport_operations { - ... - size_t (*byte_read_data) (struct parport *port, - void *buf, size_t len, int flags); - ... -}; - -DESCRIPTION - -Reads a block of data in byte mode. The 'flags' parameter is ignored. - -RETURN VALUE - -The number of bytes read. - -SEE ALSO - -nibble_read_data, compat_write_data - -port->ops->compat_write_data - write a block of data in compatibility mode ----------------------------- - -SYNOPSIS - -#include <linux/parport.h> - -struct parport_operations { - ... - size_t (*compat_write_data) (struct parport *port, - const void *buf, size_t len, int flags); - ... -}; - -DESCRIPTION - -Writes a block of data in compatibility mode. The 'flags' parameter -is ignored. - -RETURN VALUE - -The number of bytes written. - -SEE ALSO - -nibble_read_data, byte_read_data |