1472 lines
32 KiB
Plaintext
1472 lines
32 KiB
Plaintext
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
|