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的架构上工作的标准事情的 generic 函数。

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

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

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

对EPP和/或ECP传输的硬件辅助可能可用也可能不可用，如果可用，则可能使用也可能不使用。如果未使用硬件，则传输将由软件驱动。为了处理仅勉强支持IEEE 1284的外围设备，提供了低级驱动程序特定功能，用于更改“fudge factors”。

全局函数¶

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 包含驱动程序的文本名称，指向处理新端口的函数的指针，以及指向处理由于底层驱动程序卸载而消失的端口的函数的指针。端口只有在未使用时（即，没有设备注册在它们上）才会被分离。

给attach/detach的 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，并且PARPORT_MODE_DMA在 modes 中，则并不一定意味着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

该设备根本无法共享并行端口。仅在绝对必要时才使用它。

typedef实际上没有定义 -- 它们仅显示是为了使函数原型更易于阅读。

返回的 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);

描述¶

当驱动程序控制并行端口时，它可能允许另一个驱动程序临时 borrow 它。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_unregister_device 对应 parport_open 的等效项。

另请参阅¶

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

描述¶

设置注册设备的不活动超时（以 jiffies 为单位）。返回先前的超时时间。

返回值¶

先前的超时时间（以 jiffies 为单位）。

注意¶

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

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

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

另请参阅¶

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

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标志分配的内存）传递给底层驱动程序，以便利用它。