PARPORT接口文档

时间戳:

<2000-02-24 13:30:20 twaugh>

这里描述了以下函数

全局函数：

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

端口函数（可以被底层驱动程序覆盖）

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

其他：

port->ops->nibble_read_data port->ops->byte_read_data port->ops->compat_write_data

parport子系统包括parport（核心端口共享代码）和各种实际执行端口访问的底层驱动程序。每个底层驱动程序处理一种特定类型的端口（PC、Amiga等等）。

parport到设备驱动程序作者的接口可以分解为全局函数和端口函数。

全局函数主要用于设备驱动程序和parport子系统之间的通信：获取可用端口列表，声明对端口的独占使用等等。它们还包括用于执行任何支持IEEE 1284的架构上都可以工作的标准事情的通用函数。

端口函数由底层驱动程序提供，尽管核心parport模块为某些例程提供了通用默认值。端口函数可以分为三组：SPP、EPP和ECP。

SPP（标准并行端口）函数修改所谓的SPP寄存器：数据、状态和控制。硬件可能实际上没有完全那样的寄存器，但是PC有，并且此接口是模仿常见的PC实现而构建的。其他底层驱动程序可能能够模拟大多数功能。

EPP（增强并行端口）函数用于在IEEE 1284 EPP模式下进行读写，ECP（扩展功能端口）函数用于IEEE 1284 ECP模式。（BECP怎么样？有人关心吗？）

可能或可能没有可用的EPP和/或ECP传输的硬件辅助，如果可用，则可能或可能不使用它。如果未使用硬件，则传输将是软件驱动的。为了应对仅勉强支持IEEE 1284的外围设备，提供了一个特定的底层驱动程序函数，用于更改“微调因子”。

全局函数

parport_register_driver - 向parport注册设备驱动程序

概要

#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);

描述

为了在检测到并行端口时收到通知，应调用parport_register_driver。当加载底层驱动程序时，您的驱动程序将立即收到所有已检测到的端口以及每个新端口的通知。

struct parport_driver包含您的驱动程序的文本名称，指向处理新端口的函数的指针，以及指向处理由于底层驱动程序卸载而消失的端口的函数的指针。仅当端口未使用时才会分离端口（即，没有在其上注册任何设备）。

提供给附加/分离的struct parport *参数的可见部分是

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;
        ...
};

该结构还有其他成员，但不应触摸。

modes成员总结了底层硬件的功能。它由可以按位或组合在一起的标志组成

PARPORT_MODE_PCSPP	IBM PC寄存器可用，即，对数据、控制和状态寄存器起作用的函数可能会直接写入硬件。
PARPORT_MODE_TRISTATE	数据驱动程序可以关闭。这允许数据线用于反向（外围设备到主机）传输。
PARPORT_MODE_COMPAT	硬件可以辅助兼容模式（打印机）传输，即compat_write_block。
PARPORT_MODE_EPP	硬件可以辅助EPP传输。
PARPORT_MODE_ECP	硬件可以辅助ECP传输。
PARPORT_MODE_DMA	硬件可以使用DMA，因此您可能希望将ISA DMA内存（即使用kmalloc的GFP_DMA标志分配的内存）传递给底层驱动程序，以便利用它。

modes中可能还有其他标志。

modes的内容仅供参考。例如，如果硬件能够进行DMA，并且modes中包含PARPORT_MODE_DMA，则并不一定意味着在可能的情况下始终使用DMA。类似地，能够辅助ECP传输的硬件不一定会使用。

返回值

成功时为零，否则为错误代码。

错误

无。（它会失败吗？为什么要返回int？）

示例

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;
        }
        ...
}

参见

parport_unregister_driver, parport_register_device, parport_enumerate

parport_unregister_driver - 告诉parport忘记此驱动程序

概要

#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);

描述

这告诉parport不要通知设备驱动程序新端口或端口消失。不取消注册属于该驱动程序的已注册设备：必须对每个设备使用parport_unregister_device。

示例

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]);
        ...
}

参见

parport_register_driver, parport_enumerate

parport_enumerate - 检索并行端口列表（已弃用）

概要

#include <linux/parport.h>

struct parport *parport_enumerate (void);

描述

检索此机器的第一个有效并行端口列表。可以使用返回的struct parport *的struct parport *next元素找到后续的并行端口。如果next为NULL，则列表中没有更多的并行端口。列表中的端口数不会超过PARPORT_MAX。

返回值

一个struct parport *，描述了机器的有效并行端口；如果没有，则为NULL。

错误

此函数可以返回NULL，以表示没有可用的并行端口。

示例

int detect_device (void)
{
        struct parport *port;

        for (port = parport_enumerate ();
        port != NULL;
        port = port->next) {
                /* Try to detect a device on the port... */
                ...
        }
        }

        ...
}

注释

parport_enumerate 已被弃用；应改用 parport_register_driver。

另请参阅

parport_register_driver, parport_unregister_driver

parport_register_device - 注册以使用端口

概要

#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);

描述

使用此函数在并行端口 (port) 上注册您的设备驱动程序。完成此操作后，您将能够使用 parport_claim 和 parport_release 来使用该端口。

(name) 参数是设备在 /proc 文件系统中显示的名称。该字符串必须在设备的整个生命周期内有效（直到调用 parport_unregister_device）。

此函数将在您的驱动程序中注册三个回调：preempt，wakeup 和 irq。这些中的每一个都可以为NULL，以指示您不需要回调。

调用 preempt 函数的原因是另一个驱动程序希望使用并行端口。如果并行端口尚无法释放，则 preempt 函数应返回非零值；如果返回零，则该端口将丢失给另一个驱动程序，并且必须在使用之前重新声明该端口。

一旦另一个驱动程序释放了该端口，并且没有其他驱动程序声明该端口，就会调用 wakeup 函数。您可以从 wakeup 函数中声明并行端口（在这种情况下，保证声明成功），或者如果您现在不需要它，则可以选择不声明。

如果您的驱动程序已声明的并行端口上发生中断，则将调用 irq 函数。（在此处编写有关共享中断的内容。）

handle 是指向特定于驱动程序的数据的指针，并传递给回调函数。

flags 可以是以下标志的按位组合

标志	含义
PARPORT_DEV_EXCL	设备完全不能共享并行端口。仅在绝对必要时才使用此项。

typedefs 实际上没有定义，它们仅显示出来是为了使函数原型更具可读性。

返回的 struct pardevice 的可见部分是

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

返回值

一个 struct pardevice *：已注册的并行端口设备的句柄，可用于 parport_claim、parport_release 等。

错误

返回值为 NULL 表示在该端口上注册设备时出现问题。

示例

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;
        }
        ...
}

另请参阅

parport_unregister_device, parport_claim

parport_unregister_device - 完成端口使用

概要

#include <linux/parport.h>

void parport_unregister_device (struct pardevice *dev);

描述

此函数与 parport_register_device 相反。使用 parport_unregister_device 之后，dev 不再是有效的设备句柄。

您不应该注销当前声明的设备，尽管如果您这样做，它将自动释放。

示例

...
kfree (dev->private); /* before we lose the pointer */
parport_unregister_device (dev);
...

另请参阅

parport_unregister_driver

parport_claim, parport_claim_or_block - 为设备声明并行端口

概要

#include <linux/parport.h>

int parport_claim (struct pardevice *dev);
int parport_claim_or_block (struct pardevice *dev);

描述

这些函数尝试获取 dev 注册所在的并行端口的控制权。parport_claim 不会阻塞，但 parport_claim_or_block 可能会阻塞。（在此处放置一些关于可中断或不可中断阻塞的内容。）

您不应尝试声明您已经声明的端口。

返回值

返回值为零表示端口已成功声明，并且调用者现在拥有并行端口。

如果 parport_claim_or_block 在成功返回之前阻塞，则返回值为正数。

错误

-EAGAIN

该端口目前不可用，但再次尝试声明它可能会成功。

另请参阅

parport_release

parport_release - 释放并行端口

概要

#include <linux/parport.h>

void parport_release (struct pardevice *dev);

描述

一旦声明了并行端口设备，就可以使用 parport_release 释放它。它不会失败，但是您不应该释放您没有拥有的设备。

示例

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);
        ...
}

另请参阅

change_mode, parport_claim, parport_claim_or_block, parport_yield

parport_yield, parport_yield_blocking - 临时释放并行端口

概要

#include <linux/parport.h>

int parport_yield (struct pardevice *dev)
int parport_yield_blocking (struct pardevice *dev);

描述

当驱动程序控制并行端口时，它可能允许另一个驱动程序临时借用它。parport_yield 不会阻塞；parport_yield_blocking 可能会阻塞。

返回值

返回值为零表示调用者仍拥有该端口，并且调用未阻塞。

来自 parport_yield_blocking 的正返回值表示调用者仍拥有该端口，并且调用已阻塞。

返回值为 -EAGAIN 表示调用者不再拥有该端口，并且必须在使用前重新声明它。

错误

-EAGAIN

已放弃并行端口的所有权。

另请参阅

parport_release

parport_wait_peripheral - 等待状态线，最多 35 毫秒

概要

#include <linux/parport.h>

int parport_wait_peripheral (struct parport *port,
                             unsigned char mask,
                             unsigned char val);

描述

等待掩码中的状态线与 val 中的值匹配。

返回值

-EINTR	信号挂起
0	掩码中的状态线具有 val 中的值
1	等待超时（经过 35 毫秒）

另请参阅

parport_poll_peripheral

parport_poll_peripheral - 等待状态线，以微秒为单位

概要

#include <linux/parport.h>

int parport_poll_peripheral (struct parport *port,
                             unsigned char mask,
                             unsigned char val,
                             int usec);

描述

等待掩码中的状态线与 val 中的值匹配。

返回值

-EINTR	信号挂起
0	掩码中的状态线具有 val 中的值
1	等待超时（经过 usec 微秒）

另请参阅

parport_wait_peripheral

parport_wait_event - 等待端口上的事件

概要

#include <linux/parport.h>

int parport_wait_event (struct parport *port, signed long timeout)

描述

等待端口上的事件（例如，中断）。超时时间以节拍数（jiffies）为单位。

返回值

0	成功
<0	错误（尽快退出）
>0	超时

parport_negotiate - 执行 IEEE 1284 协商

概要

#include <linux/parport.h>

int parport_negotiate (struct parport *, int mode);

描述

执行 IEEE 1284 协商。

返回值

0	握手成功；IEEE 1284 外围设备和模式可用
-1	握手失败；外围设备不兼容（或不存在）
1	握手成功；存在 IEEE 1284 外围设备，但模式不可用

另请参阅

parport_read, parport_write

parport_read - 从设备读取数据

概要

#include <linux/parport.h>

ssize_t parport_read (struct parport *, void *buf, size_t len);

描述

以当前的 IEEE 1284 传输模式从设备读取数据。这仅适用于支持反向数据传输的模式。

返回值

如果为负数，则表示错误代码；否则表示传输的字节数。

另请参阅

parport_write, parport_negotiate

parport_write - 将数据写入设备

概要

#include <linux/parport.h>

ssize_t parport_write (struct parport *, const void *buf, size_t len);

描述

以当前 IEEE 1284 传输模式将数据写入设备。这仅适用于支持前向数据传输的模式。

返回值

如果为负数，则表示错误代码；否则表示传输的字节数。

另请参阅

parport_read, parport_negotiate

parport_open - 为特定设备编号注册设备

概要

#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);

描述

这类似于 parport_register_device，但它采用设备编号而不是指向 struct parport 的指针。

返回值

请参阅 parport_register_device。如果 devnum 没有关联设备，则返回 NULL。

另请参阅

parport_register_device

parport_close - 取消注册特定设备编号的设备

概要

#include <linux/parport.h>

void parport_close (struct pardevice *dev);

描述

这对于 parport_open 相当于 parport_unregister_device。

另请参阅

parport_unregister_device, parport_open

parport_device_id - 获取 IEEE 1284 设备 ID

概要

#include <linux/parport.h>

ssize_t parport_device_id (int devnum, char *buffer, size_t len);

描述

获取与给定设备关联的 IEEE 1284 设备 ID。

返回值

如果为负数，则表示错误代码；否则表示包含设备 ID 的缓冲区字节数。设备 ID 的格式如下

[length][ID]

前两个字节表示整个设备 ID 的包含长度，并且以大端序排列。ID 是一系列以下形式的对

key:value;

注释

许多设备的 IEEE 1284 设备 ID 格式不正确。

另请参阅

parport_find_class, parport_find_device

parport_device_coords - 将设备编号转换为设备坐标

概要

#include <linux/parport.h>

int parport_device_coords (int devnum, int *parport, int *mux,
                           int *daisy);

描述

在设备编号（从零开始）和设备坐标（端口、多路复用器、菊花链地址）之间转换。

返回值

成功时返回零，在这种情况下，坐标为（*parport， *mux， *daisy）。

另请参阅

parport_open, parport_device_id

parport_find_class - 按类别查找设备

概要

#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);

描述

按类别查找设备。搜索从设备编号 from+1 开始。

返回值

该类别中下一个设备的设备编号，如果不存在这样的设备，则返回 -1。

注释

用法示例

int devnum = -1;
while ((devnum = parport_find_class (PARPORT_CLASS_DIGCAM, devnum)) != -1) {
        struct pardevice *dev = parport_open (devnum, ...);
        ...
}

另请参阅

parport_find_device, parport_open, parport_device_id

parport_find_device - 按类别查找设备

概要

#include <linux/parport.h>

int parport_find_device (const char *mfg, const char *mdl, int from);

描述

按供应商和型号查找设备。搜索从设备编号 from+1 开始。

返回值

下一个与规范匹配的设备的设备编号，如果不存在这样的设备，则返回 -1。

注释

用法示例

int devnum = -1;
while ((devnum = parport_find_device ("IOMEGA", "ZIP+", devnum)) != -1) {
        struct pardevice *dev = parport_open (devnum, ...);
        ...
}

另请参阅

parport_find_class, parport_open, parport_device_id

parport_set_timeout - 设置不活动超时

概要

#include <linux/parport.h>

long parport_set_timeout (struct pardevice *dev, long inactivity);

描述

为已注册的设备设置不活动超时（以节拍数表示）。返回之前的超时时间。

返回值

之前的超时时间（以节拍数表示）。

注释

由于外围设备的延迟，parport 的某些 port->ops 函数可能需要时间。在外围设备在 inactivity 个节拍数内没有响应后，将发生超时，并且阻塞函数将返回。

0 个节拍数的超时是一种特殊情况：该函数必须在不阻塞或将硬件置于未知状态的情况下尽可能多地执行操作。例如，如果在中断处理程序中执行端口操作，则应使用 0 个节拍数的超时。

为注册设备设置超时后，超时将保持在设置的值，直到再次设置。

另请参阅

port->ops->xxx_read/write_yyy

端口函数

port->ops 结构（struct parport_operations）中的函数由负责该端口的底层驱动程序提供。

port->ops->read_data - 读取数据寄存器

概要

#include <linux/parport.h>

struct parport_operations {
        ...
        unsigned char (*read_data) (struct parport *port);
        ...
};

描述

如果 port->modes 包含 PARPORT_MODE_TRISTATE 标志，并且控制寄存器中的 PARPORT_CONTROL_DIRECTION 位已设置，则此函数返回数据引脚上的值。如果 port->modes 包含 PARPORT_MODE_TRISTATE 标志，并且 PARPORT_CONTROL_DIRECTION 位未设置，则返回值 _可能_ 是上次写入数据寄存器的值。否则，返回值未定义。

另请参阅

write_data, read_status, write_control

port->ops->write_data - 写入数据寄存器

概要

#include <linux/parport.h>

struct parport_operations {
        ...
        void (*write_data) (struct parport *port, unsigned char d);
        ...
};

描述

写入数据寄存器。可能具有副作用（例如，STROBE 脉冲）。

另请参阅

read_data, read_status, write_control

port->ops->read_status - 读取状态寄存器

概要

#include <linux/parport.h>

struct parport_operations {
        ...
        unsigned char (*read_status) (struct parport *port);
        ...
};

描述

从状态寄存器读取。这是一个位掩码

• PARPORT_STATUS_ERROR （打印机故障，“nFault”）

• PARPORT_STATUS_SELECT（在线，“Select”）

• PARPORT_STATUS_PAPEROUT（无纸，“PError”）

• PARPORT_STATUS_ACK（握手，“nAck”）

• PARPORT_STATUS_BUSY（忙，“Busy”）

可能设置了其他位。

另请参阅

read_data, write_data, write_control

port->ops->read_control - 读取控制寄存器

概要

#include <linux/parport.h>

struct parport_operations {
        ...
        unsigned char (*read_control) (struct parport *port);
        ...
};

描述

返回上次写入控制寄存器的值（来自 write_control 或 frob_control）。不执行端口访问。

另请参阅

read_data, write_data, read_status, write_control

port->ops->write_control - 写入控制寄存器

概要

#include <linux/parport.h>

struct parport_operations {
        ...
        void (*write_control) (struct parport *port, unsigned char s);
        ...
};

描述

写入控制寄存器。这是一个位掩码

                          _______
- PARPORT_CONTROL_STROBE (nStrobe)
                          _______
- PARPORT_CONTROL_AUTOFD (nAutoFd)
                        _____
- PARPORT_CONTROL_INIT (nInit)
                          _________
- PARPORT_CONTROL_SELECT (nSelectIn)

另请参阅

read_data, write_data, read_status, frob_control

port->ops->frob_control - 写入控制寄存器位

概要

#include <linux/parport.h>

struct parport_operations {
        ...
        unsigned char (*frob_control) (struct parport *port,
                                unsigned char mask,
                                unsigned char val);
        ...
};

描述

这等效于从控制寄存器读取，屏蔽 mask 中的位，与 val 中的位进行异或运算，然后将结果写入控制寄存器。

由于某些端口不允许从控制端口读取，因此维护了其内容的软件副本，因此 frob_control 实际上只有一个端口访问。

另请参阅

read_data, write_data, read_status, write_control

port->ops->enable_irq - 启用中断生成

概要

#include <linux/parport.h>

struct parport_operations {
        ...
        void (*enable_irq) (struct parport *port);
        ...
};

描述

指示并行端口硬件在适当的时刻生成中断，尽管这些时刻是特定于体系结构的。对于 PC 体系结构，中断通常在 nAck 的上升沿生成。

另请参阅

disable_irq

port->ops->disable_irq - 禁用中断生成

概要

#include <linux/parport.h>

struct parport_operations {
        ...
        void (*disable_irq) (struct parport *port);
        ...
};

描述

指示并行端口硬件不生成中断。中断本身并未被屏蔽。

另请参阅

enable_irq

port->ops->data_forward - 启用数据驱动器

概要

#include <linux/parport.h>

struct parport_operations {
        ...
        void (*data_forward) (struct parport *port);
        ...
};

描述

启用数据线驱动器，用于 8 位主机到外设的通信。

另请参阅

data_reverse

port->ops->data_reverse - 将缓冲区置于三态

概要

#include <linux/parport.h>

struct parport_operations {
        ...
        void (*data_reverse) (struct parport *port);
        ...
};

描述

如果 port->modes 设置了 PARPORT_MODE_TRISTATE 位，则将数据总线置于高阻抗状态。

另请参阅

data_forward

port->ops->epp_write_data - 写入 EPP 数据

概要

#include <linux/parport.h>

struct parport_operations {
        ...
        size_t (*epp_write_data) (struct parport *port, const void *buf,
                                size_t len, int flags);
        ...
};

描述

以 EPP 模式写入数据，并返回写入的字节数。

flags 参数可以是以下一个或多个值的按位或组合

PARPORT_EPP_FAST

使用快速传输。某些芯片提供 16 位和 32 位寄存器。但是，如果传输超时，返回值可能不可靠。

另请参阅

epp_read_data, epp_write_addr, epp_read_addr

port->ops->epp_read_data - 读取 EPP 数据

概要

#include <linux/parport.h>

struct parport_operations {
        ...
        size_t (*epp_read_data) (struct parport *port, void *buf,
                                size_t len, int flags);
        ...
};

描述

以 EPP 模式读取数据，并返回读取的字节数。

flags 参数可以是以下一个或多个值的按位或组合

PARPORT_EPP_FAST

使用快速传输。某些芯片提供 16 位和 32 位寄存器。但是，如果传输超时，返回值可能不可靠。

另请参阅

epp_write_data, epp_write_addr, epp_read_addr

port->ops->epp_write_addr - 写入 EPP 地址

概要

#include <linux/parport.h>

struct parport_operations {
        ...
        size_t (*epp_write_addr) (struct parport *port,
                                const void *buf, size_t len, int flags);
        ...
};

描述

写入 EPP 地址（每个 8 位），并返回写入的地址数。

flags 参数可以是以下一个或多个值的按位或组合

PARPORT_EPP_FAST

使用快速传输。某些芯片提供 16 位和 32 位寄存器。但是，如果传输超时，返回值可能不可靠。

（PARPORT_EPP_FAST 对此函数有意义吗？）

另请参阅

epp_write_data, epp_read_data, epp_read_addr

port->ops->epp_read_addr - 读取 EPP 地址

概要

#include <linux/parport.h>

struct parport_operations {
        ...
        size_t (*epp_read_addr) (struct parport *port, void *buf,
                                size_t len, int flags);
        ...
};

描述

读取 EPP 地址（每个 8 位），并返回读取的地址数。

flags 参数可以是以下一个或多个值的按位或组合

PARPORT_EPP_FAST

使用快速传输。某些芯片提供 16 位和 32 位寄存器。但是，如果传输超时，返回值可能不可靠。

（PARPORT_EPP_FAST 对此函数有意义吗？）

另请参阅

epp_write_data, epp_read_data, epp_write_addr

port->ops->ecp_write_data - 写入 ECP 数据块

概要

#include <linux/parport.h>

struct parport_operations {
        ...
        size_t (*ecp_write_data) (struct parport *port,
                                const void *buf, size_t len, int flags);
        ...
};

描述

写入 ECP 数据块。flags 参数被忽略。

返回值

写入的字节数。

另请参阅

ecp_read_data, ecp_write_addr

port->ops->ecp_read_data - 读取 ECP 数据块

概要

#include <linux/parport.h>

struct parport_operations {
        ...
        size_t (*ecp_read_data) (struct parport *port,
                                void *buf, size_t len, int flags);
        ...
};

描述

读取 ECP 数据块。flags 参数被忽略。

返回值

读取的字节数。注意：FIFO 中可能还有更多未读取的数据。是否有办法停止 FIFO 以防止这种情况？

另请参阅

ecp_write_block, ecp_write_addr

port->ops->ecp_write_addr - 写入 ECP 地址块

概要

#include <linux/parport.h>

struct parport_operations {
        ...
        size_t (*ecp_write_addr) (struct parport *port,
                                const void *buf, size_t len, int flags);
        ...
};

描述

写入 ECP 地址块。flags 参数被忽略。

返回值

写入的字节数。

注释

这可能会使用 FIFO，如果使用，则在 FIFO 为空之前不会返回。

另请参阅

ecp_read_data, ecp_write_data

port->ops->nibble_read_data - 以半字节模式读取数据块

概要

#include <linux/parport.h>

struct parport_operations {
        ...
        size_t (*nibble_read_data) (struct parport *port,
                                void *buf, size_t len, int flags);
        ...
};

描述

以半字节模式读取数据块。flags 参数被忽略。

返回值

读取的完整字节数。

另请参阅

byte_read_data, compat_write_data

port->ops->byte_read_data - 以字节模式读取数据块

概要

#include <linux/parport.h>

struct parport_operations {
        ...
        size_t (*byte_read_data) (struct parport *port,
                                void *buf, size_t len, int flags);
        ...
};

描述

以字节模式读取数据块。flags 参数被忽略。

返回值

读取的字节数。

另请参阅

nibble_read_data, compat_write_data

port->ops->compat_write_data - 以兼容模式写入数据块

概要

#include <linux/parport.h>

struct parport_operations {
        ...
        size_t (*compat_write_data) (struct parport *port,
                                const void *buf, size_t len, int flags);
        ...
};

描述

以兼容模式写入数据块。flags 参数被忽略。

返回值

写入的字节数。

另请参阅

nibble_read_data, byte_read_data