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 willimmediately be notified of all ports that have already been detected,and of each new port as low-level drivers are loaded.

Astructparport_driver contains the textual name of your driver,a pointer to a function to handle new ports, and a pointer to afunction to handle ports going away due to a low-level driverunloading. Ports will only be detached if they are not being used(i.e. there are no devices registered on them).

The visible parts of thestructparport* argument given toattach/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 betouched.

Themodes member summarises the capabilities of the underlyinghardware. 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 areprobably writing directly to thehardware.
PARPORT_MODE_TRISTATE	The data drivers may be turned off.This allows the data lines to be usedfor reverse (peripheral to host)transfers.
PARPORT_MODE_COMPAT	The hardware can assist withcompatibility-mode (printer)transfers, i.e. compat_write_block.
PARPORT_MODE_EPP	The hardware can assist with EPPtransfers.
PARPORT_MODE_ECP	The hardware can assist with ECPtransfers.
PARPORT_MODE_DMA	The hardware can use DMA, so you mightwant to pass ISA DMA-able memory(i.e. memory allocated using theGFP_DMA flag with kmalloc) to thelow-level driver in order to takeadvantage of it.

There may be other flags inmodes as well.

The contents ofmodes is advisory only. For example, if thehardware is capable of DMA, and PARPORT_MODE_DMA is inmodes, itdoesn’t necessarily mean that DMA will always be used when possible.Similarly, hardware that is capable of assisting ECP transfers won’tnecessarily 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

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 ofports going away. Registered devices belonging to that driver are NOTunregistered: 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

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 thestructparport*next element of thestructparport* that is returned. Ifnextis NULL, there are no more parallel ports in the list. The number ofports in the list will not exceed PARPORT_MAX.

RETURN VALUE¶

Astructparport* 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 parallelports 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 beused instead.

SEE ALSO¶

parport_register_driver, parport_unregister_driver

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 useparport_claim and parport_release in order to use the port.

The (name) argument is the name of the device that appears in /procfilesystem. The string must be valid for the whole lifetime of thedevice (until parport_unregister_device is called).

This function will register three callbacks into your driver:preempt,wakeup andirq. Each of these may be NULL in order toindicate that you do not want a callback.

When thepreempt function is called, it is because another driverwishes to use the parallel port. Thepreempt function should returnnon-zero if the parallel port cannot be released yet -- if zero isreturned, the port is lost to another driver and the port must bere-claimed before use.

Thewakeup function is called once another driver has released theport and no other driver has yet claimed it. You can claim theparallel port from within thewakeup function (in which case theclaim is guaranteed to succeed), or choose not to if you don’t need itnow.

If an interrupt occurs on the parallel port your driver has claimed,theirq function will be called. (Write something about sharedinterrupts here.)

Thehandle is a pointer to driver-specific data, and is passed tothe 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 orderto make the function prototype more readable.

The visible parts of the returnedstructpardevice are:

struct pardevice {        struct parport *port;   /* Associated port */        void *private;          /* Device driver's 'handle' */        ...};

RETURN VALUE¶

Astructpardevice*: a handle to the registered parallel portdevice that can be used for parport_claim, parport_release, etc.

ERRORS¶

A return value of NULL indicates that there was a problem registeringa 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

DESCRIPTION¶

This function is the opposite of parport_register_device. After usingparport_unregister_device,dev is no longer a valid device handle.

You should not unregister a device that is currently claimed, althoughif 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

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 whichdev is registered.parport_claim does not block, butparport_claim_or_block may do. (Put something here about blockinginterruptibly 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 successfullyclaimed, and the caller now has possession of the parallel port.

Ifparport_claim_or_block blocks before returning successfully, thereturn value is positive.

ERRORS¶

SEE ALSO¶

parport_release

SYNOPSIS¶

#include <linux/parport.h>void parport_release (struct pardevice *dev);

DESCRIPTION¶

Once a parallel port device has been claimed, it can be released usingparport_release. It cannot fail, but you should not release adevice 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

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 anotherdriver to temporarilyborrow 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 portand the call did not block.

A positive return value fromparport_yield_blocking indicates thatthe caller still owns the port and the call blocked.

A return value of -EAGAIN indicates that the caller no longer owns theport, and it must be re-claimed before use.

ERRORS¶

SEE ALSO¶

parport_release

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¶

SEE ALSO¶

parport_poll_peripheral

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¶

SEE ALSO¶

parport_wait_peripheral

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 injiffies.

RETURN VALUE¶

SYNOPSIS¶

#include <linux/parport.h>int parport_negotiate (struct parport *, int mode);

DESCRIPTION¶

Perform IEEE 1284 negotiation.

RETURN VALUE¶

SEE ALSO¶

parport_read, parport_write

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 onlyworks 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

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 onlyworks 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

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 insteadof a pointer to astructparport.

RETURN VALUE¶

See parport_register_device. If no device is associated with devnum,NULL is returned.

SEE ALSO¶

parport_register_device

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

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 bufferthat contain the device ID. The format of the device ID is asfollows:

[length][ID]

The first two bytes indicate the inclusive length of the entire DeviceID, and are in big-endian order. The ID is a sequence of pairs of theform:

key:value;

NOTES¶

Many devices have ill-formed IEEE 1284 Device IDs.

SEE ALSO¶

parport_find_class, parport_find_device

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

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 suchdevice 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

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 devicenumber 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

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. Theprevious timeout is returned.

RETURN VALUE¶

The previous timeout, in jiffies.

NOTES¶

Some of the port->ops functions for a parport may take time, owing todelays at the peripheral. After the peripheral has not responded forinactivity jiffies, a timeout will occur and the blocking functionwill return.

A timeout of 0 jiffies is a special case: the function must do as muchas it can without blocking or leaving the hardware in an unknownstate. If port operations are performed from within an interrupthandler, for instance, a timeout of 0 jiffies should be used.

Once set for a registered device, the timeout will remain at the setvalue until set again.

SEE ALSO¶

port->ops->xxx_read/write_yyy

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 thePARPORT_CONTROL_DIRECTION bit in the control register is set, thisreturns the value on the data pins. If port->modes contains thePARPORT_MODE_TRISTATE flag and the PARPORT_CONTROL_DIRECTION bit isnot set, the return value _may_ be the last value written to the dataregister. Otherwise the return value is undefined.

SEE ALSO¶

write_data, read_status, write_control

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

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

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 fromwrite_control or frob_control). No port access is performed.

SEE ALSO¶

read_data, write_data, read_status, write_control

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

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 outthe bits in mask, exclusive-or’ing with the bits in val, and writingthe result to the control register.

As some ports don’t allow reads from the control port, a software copyof its contents is maintained, so frob_control is in fact only oneport access.

SEE ALSO¶

read_data, write_data, read_status, write_control

SYNOPSIS¶

#include <linux/parport.h>struct parport_operations {        ...        void (*enable_irq) (struct parport *port);        ...};

DESCRIPTION¶

The parallel port hardware is instructed to generate interrupts atappropriate moments, although those moments arearchitecture-specific. For the PC architecture, interrupts arecommonly generated on the rising edge of nAck.

SEE ALSO¶

disable_irq

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

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-peripheralcommunications.

SEE ALSO¶

data_reverse

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 thePARPORT_MODE_TRISTATE bit set.

SEE ALSO¶

data_forward

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.

Theflags parameter may be one or more of the following,bitwise-or’ed together:

SEE ALSO¶

epp_read_data, epp_write_addr, epp_read_addr

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.

Theflags parameter may be one or more of the following,bitwise-or’ed together:

SEE ALSO¶

epp_write_data, epp_write_addr, epp_read_addr

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.

Theflags parameter may be one or more of the following,bitwise-or’ed together:

(Does PARPORT_EPP_FAST make sense for this function?)

SEE ALSO¶

epp_write_data, epp_read_data, epp_read_addr

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.

Theflags parameter may be one or more of the following,bitwise-or’ed together:

(Does PARPORT_EPP_FAST make sense for this function?)

SEE ALSO¶

epp_write_data, epp_read_data, epp_write_addr

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. Theflags parameter is ignored.

RETURN VALUE¶

The number of bytes written.

SEE ALSO¶

ecp_read_data, ecp_write_addr

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. Theflags parameter is ignored.

RETURN VALUE¶

The number of bytes read. NB. There may be more unread data in aFIFO. Is there a way of stunning the FIFO to prevent this?

SEE ALSO¶

ecp_write_block, ecp_write_addr

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. Theflags 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

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. Theflags parameter is ignored.

RETURN VALUE¶

The number of whole bytes read.

SEE ALSO¶

byte_read_data, compat_write_data

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. Theflags parameter is ignored.

RETURN VALUE¶

The number of bytes read.

SEE ALSO¶

nibble_read_data, compat_write_data

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. Theflags parameteris ignored.

RETURN VALUE¶

The number of bytes written.

SEE ALSO¶

nibble_read_data, byte_read_data