Skip to content

L
linux
Commit be9d0411 authored by Mauro Carvalho Chehab's avatar Mauro Carvalho Chehab Committed by Jonathan Corbet
Browse files
Options

parport-lowlevel.txt: standardize document format 

Each text file under Documentation follows a different
format. This one uses a man-page like approach.

Change its representation to be closer to the adopted standard,
using ReST markups for it to be parseable by Sphinx:

- Mark titles;
- Mark literals and literal blocks;
- Adjust identation.

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