并行端口设备

parport_register_driver

parport_register_driver (driver)

注册并行端口设备驱动程序

参数

driver

描述驱动程序的结构

并行端口设备驱动程序可以调用此函数，以便接收有关系统中找到的端口以及不再可用的端口的通知。

driver 结构由调用者分配，并且在调用 parport_unregister_driver() 之后才能解除分配。

如果使用非设备模型：驱动程序的 attach() 函数可能会阻塞。attach() 函数获得的端口在回调期间有效，但如果驱动程序想要复制指针，则必须调用 parport_get_port()。对该端口调用 parport_register_device() 将为您执行此操作。

驱动程序的 detach() 函数可能会阻塞。detach() 函数获得的端口在回调期间有效，但如果驱动程序想要复制指针，则必须调用 parport_get_port()。

成功时返回 0。非设备模型将始终成功。但新设备模型可能会失败，并将返回错误代码。

module_parport_driver

module_parport_driver (__parport_driver)

用于注册模块化 parport 驱动程序的辅助宏

参数

__parport_driver

要使用的 struct parport_driver

说明

用于 parport 驱动程序的辅助宏，这些驱动程序在模块初始化和退出时不做任何特殊处理。这消除了大量样板代码。每个模块只能使用此宏一次，并且调用它会替换 module_init() 和 module_exit()。

int parport_yield(struct pardevice *dev)

暂时放弃并行端口

参数

struct pardevice *dev

并行端口上的设备

说明

如果这样做对其他驱动程序有帮助，则此函数会放弃端口。之后，它尝试使用 parport_claim() 重新声明端口，并且返回值与 parport_claim() 的返回值相同。如果失败，则端口保持未声明状态，并且驱动程序有责任重新声明端口。

parport_yield() 和 parport_yield_blocking() 函数用于标记驱动程序中的点，其他驱动程序可以在这些点声明端口并使用其设备。放弃端口类似于释放端口并重新声明端口，但效率更高，因为如果没有其他设备需要该端口，则不会采取任何操作。事实上，即使有其他设备在等待，但当前设备仍在“时间片”内，也不会执行任何操作。默认时间片为半秒，但可以通过 /proc 接口进行调整。

int parport_yield_blocking(struct pardevice *dev)

暂时放弃并行端口

参数

struct pardevice *dev

并行端口上的设备

说明

如果这样做对其他驱动程序有帮助，则此函数会放弃端口。之后，它尝试使用 parport_claim_or_block() 重新声明端口，并且返回值与 parport_claim_or_block() 的返回值相同。

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

等待并行端口上的事件

参数

struct parport *port

要等待的端口

signed long timeout

等待时间（以节拍为单位）

此函数最多等待 timeout 节拍，以等待并行端口上发生中断。如果端口超时设置为零，则立即返回。

如果在超时时间段过去之前发生中断，则此函数立即返回零。如果超时，则返回一。小于零的错误代码表示错误（很可能是挂起的信号），调用代码应尽快完成正在执行的操作。

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

等待状态行在 35 毫秒内更改

参数

struct parport *port

要监视的端口

unsigned char mask

要监视的状态行

unsigned char result

所选状态行的所需值

此函数等待，直到屏蔽的状态行具有所需的值，或直到经过 35 毫秒（请参阅 IEEE 1284-1994 第 24 至 25 页，了解为什么特别硬编码此值）。mask 和 result 参数是位掩码，位由 parport.h 中的常量定义：PARPORT_STATUS_BUSY，依此类推。

为了预测外围设备的快速响应，该端口开始时会快速轮询。此快速轮询时间是可配置的（使用 /proc），默认为 500 微秒。如果此端口的超时（请参阅 parport_set_timeout()）为零，则快速轮询时间为 35 毫秒，并且此函数不调用 schedule()。

如果此端口的超时为非零，则在快速轮询失败后，它会使用 parport_wait_event() 等待最多 10 毫秒，并在发生中断时唤醒。

int parport_negotiate(struct parport *port, int mode)

协商 IEEE 1284 模式

参数

struct parport *port

要使用的端口

int mode

要协商到的模式

使用此函数协商到特定的 IEEE 1284 传输模式。mode 参数应为 parport.h 中以 IEEE1284_MODE_xxx 开头的常量之一。

如果外围设备已接受协商到指定的模式，则返回值为 0；如果外围设备不符合 IEEE 1284 标准（或不存在），则返回值为 -1；如果外围设备已拒绝协商，则返回值为 1。

ssize_t parport_write(struct parport *port, const void *buffer, size_t len)

将数据块写入并行端口

参数

struct parport *port

要写入的端口

const void *buffer

数据缓冲区（在内核空间中）

size_t len

要传输的数据字节数

这将使用最近协商到的 IEEE 1284 传输模式（使用 parport_negotiate()）将 buffer 的最多 len 个字节写入指定的端口，只要该模式支持正向传输（主机到外围设备）。

调用方有责任确保 buffer 的前 len 个字节有效。

此函数返回传输的字节数（如果为零或正数），否则返回错误代码。

ssize_t parport_read(struct parport *port, void *buffer, size_t len)

从并行端口读取数据块

参数

struct parport *port

要读取的端口

void *buffer

数据缓冲区（在内核空间中）

size_t len

要传输的数据字节数

这将使用最近协商到的 IEEE 1284 传输模式（使用 parport_negotiate()）将最多 len 个字节的 buffer 读取到指定的端口，只要该模式支持反向传输（外围设备到主机）。

调用方有责任确保 buffer 的前 len 个字节可用于写入。

此函数返回传输的字节数（如果为零或正数），否则返回错误代码。

long parport_set_timeout(struct pardevice *dev, long inactivity)

设置设备的不活动超时

参数

struct pardevice *dev

端口上的设备

long inactivity

不活动超时（以节拍为单位）

这将设置端口上特定设备的不活动超时。这会影响诸如 parport_wait_peripheral() 之类的函数。特殊值 0 表示在处理此设备时不调用 schedule()。

返回值是先前的不活动超时。

此设备的 parport_wait_event() 的任何调用方都会被唤醒。

int __parport_register_driver(struct parport_driver *drv, struct module *owner, const char *mod_name)

注册并行端口设备驱动程序

参数

struct parport_driver *drv

描述驱动程序的结构

struct module *owner

drv 的所有者模块

const char *mod_name

模块名称字符串

并行端口设备驱动程序可以调用此函数，以便接收有关系统中找到的端口以及不再可用的端口的通知。

如果 devmodel 为 true，则新设备模型用于注册。

drv 结构由调用者分配，并且在调用 parport_unregister_driver() 之后才能解除分配。

如果使用非设备模型：驱动程序的 attach() 函数可能会阻塞。attach() 函数获得的端口在回调期间有效，但如果驱动程序想要复制指针，则必须调用 parport_get_port()。对该端口调用 parport_register_device() 将为您执行此操作。

驱动程序的 detach() 函数可能会阻塞。detach() 函数获得的端口在回调期间有效，但如果驱动程序想要复制指针，则必须调用 parport_get_port()。

成功时返回 0。非设备模型将始终成功。但新设备模型可能会失败，并将返回错误代码。

void parport_unregister_driver(struct parport_driver *drv)

注销并行端口设备驱动程序

参数

struct parport_driver *drv

描述提供给 parport_register_driver() 的驱动程序的结构

当并行端口设备驱动程序使用 parport_register_driver() 注册自身时，即将卸载时，应调用此函数。

当它返回时，将不再调用驱动程序的 attach() 例程，并且对于调用 attach() 的每个端口，都将调用 detach() 例程。

保证在函数返回时，驱动程序的所有 attach() 和 detach() 调用都已完成。

struct parport *parport_get_port(struct parport *port)

增加端口的引用计数

参数

struct parport *port

端口

这确保了 struct parport 指针保持有效，直到调用匹配的 parport_put_port()。

void parport_put_port(struct parport *port)

减少端口的引用计数

参数

struct parport *port

端口

对于每次调用 parport_get_port()，一旦不再需要该端口，就应调用此函数一次。当引用计数达到零（端口不再使用）时，将调用 free_port。

struct parport *parport_register_port(unsigned long base, int irq, int dma, struct parport_operations *ops)

注册并行端口

参数

unsigned long base

基本 I/O 地址

int irq

IRQ 行

int dma

DMA 通道

struct parport_operations *ops

指向端口驱动程序的端口操作结构的指针

当并行端口（底层）驱动程序找到应提供给并行端口设备驱动程序的端口时，它应调用 parport_register_port()。base、irq 和 dma 参数是为了方便端口驱动程序，对于没有意义的端口，无需将其设置为任何特殊内容。可以通过调整返回并表示端口的 parport 结构的相关成员来更改它们。但是，在调用 parport_announce_port 之后，不应篡改它们。

如果系统中有已使用 parport_register_driver() 注册自身的并行端口设备驱动程序，则此时不会告知它们有关端口的信息；这是由 parport_announce_port() 完成的。

ops 结构由调用者分配，并且在调用 parport_remove_port() 之前不得解除分配。

如果没有内存来分配新的 parport 结构，则此函数将返回 NULL。

void parport_announce_port(struct parport *port)

告知设备驱动程序有关并行端口的信息

参数

struct parport *port

要宣告的并行端口

在端口驱动程序使用 parport_register_port 注册并行端口并执行任何必要的初始化或调整后，应调用 parport_announce_port()，以便通知已调用 parport_register_driver() 的所有设备驱动程序。它们的 attach() 函数将被调用，并将 port 作为参数。

void parport_remove_port(struct parport *port)

注销并行端口

参数

struct parport *port

要注销的并行端口

当强制卸载并行端口驱动程序或并行端口变得无法访问时，端口驱动程序必须调用此函数，以便处理仍想使用它的设备驱动程序。

与该端口关联的 parport 结构的其操作结构被替换为包含返回错误或只是不执行任何操作的“null”操作的结构。

已使用 parport_register_driver() 注册自身的任何驱动程序都会收到通知，告知该端口不再可访问，方法是使用 port 作为参数调用其 detach() 例程。

struct pardevice *parport_register_dev_model(struct parport *port, const char *name, const struct pardev_cb *par_dev_cb, int id)

在并行端口上注册设备

参数

struct parport *port

设备连接到的端口

const char *name

用于引用设备的名称

const struct pardev_cb *par_dev_cb

包含回调的结构

int id

要提供给设备的设备编号

此函数由并行端口设备驱动程序调用，声明设备已连接到端口，并告知系统需要知道的所有信息。

struct pardev_cb 包含指向回调的指针。当此设备驱动程序已声明对端口的访问权限但另一个设备驱动程序想要使用它时，会调用抢占回调函数 preempt。它会给出 private 作为其参数，并且如果它愿意代表系统将端口释放给另一个驱动程序，则应返回零。如果它想保持对端口的控制，则应返回非零，并且不会采取任何操作。驱动程序最好在抢占回调拒绝抢占尝试后尽快尝试释放端口。请注意，如果抢占回调乐于进行抢占，则无需释放端口；它是自动完成的。此函数可能不会阻塞，因为它可能从中断上下文中调用。如果设备驱动程序不支持抢占，则 preempt 可以为 NULL。

唤醒（“kick”）回调函数 wakeup 在端口可用于声明独占访问权限时调用；也就是说，保证可以从唤醒回调函数内部调用 parport_claim()。如果驱动程序想要声明端口，则应这样做；否则，它无需采取任何操作。此函数可能不会阻塞，因为它可能从中断上下文中调用。如果设备驱动程序不希望被明确邀请以这种方式声明端口，则 wakeup 可以为 NULL。

中断处理程序 irq_func 在并行端口收到中断时调用。请注意，如果设备驱动程序想要使用中断，则应使用 parport_enable_irq()，并且还可以检查表示端口的 parport 结构的 irq 成员。

并行端口（底层）驱动程序是已调用 request_irq() 并且首先调用其中断处理程序的驱动程序。此处理程序执行硬件需要执行的任何操作来确认中断（对于 PC 样式端口，无需执行任何特殊操作）。然后，它会告知 IEEE 1284 代码有关中断的信息，这可能涉及根据当前的 IEEE 1284 阶段对 IEEE 1284 事件做出反应。在此之后，它会调用 irq_func。不用说，irq_func 将从中断上下文中调用，并且可能不会阻塞。

PARPORT_DEV_EXCL 标志用于防止端口共享，因此仅应在与其他设备驱动程序共享端口是不可能且会导致错误行为时使用。谨慎使用它！通常，flags 将为零。

此函数返回指向表示端口上设备的结构的指针，或者如果内存不足以分配该结构的空间，则返回 NULL。

void parport_unregister_device(struct pardevice *dev)

注销并行端口上的设备

参数

struct pardevice *dev

指向表示设备的结构的指针

这将撤消 parport_register_device() 的效果。

struct parport *parport_find_number(int number)

按编号查找并行端口

参数

int number

并行端口号

这将返回具有指定编号的并行端口，如果没有，则返回 NULL。

已经完成了隐式的 parport_get_port()；要丢弃对 parport_find_number() 提供的端口的引用，请使用 parport_put_port()。

struct parport *parport_find_base(unsigned long base)

按基地址查找并行端口

参数

unsigned long base

基本 I/O 地址

这将返回具有指定基地址的并行端口，如果没有，则返回 NULL。

已经完成了隐式的 parport_get_port()；要丢弃对 parport_find_base() 提供的端口的引用，请使用 parport_put_port()。

int parport_claim(struct pardevice *dev)

声明对并行端口设备的访问权限

参数

struct pardevice *dev

指向表示端口上设备的结构的指针

此函数不会阻塞，因此可以从中断上下文中使用。如果 parport_claim() 成功声明了对端口的访问权限，则返回零，并且该端口可供使用。如果端口正在被另一个驱动程序使用，并且该驱动程序不愿意放弃对端口的控制，则可能会失败（返回非零）。

int parport_claim_or_block(struct pardevice *dev)

声明对并行端口设备的访问权限

参数

struct pardevice *dev

指向表示端口上设备的结构的指针

此行为类似于 parport_claim()，但如果需要等待端口空闲，则会阻塞。返回值 1 表示它已休眠；0 表示它已成功，无需休眠。负错误代码表示失败。

void parport_release(struct pardevice *dev)

放弃对并行端口设备的访问权限

参数

struct pardevice *dev

指向表示并行端口设备的结构的指针

此函数不会失败，但不应在未声明端口的情况下调用。同样，如果端口已声明，则不应尝试再次声明它。

struct pardevice *parport_open(int devnum, const char *name)

按规范设备编号查找设备

参数

int devnum

规范设备编号

const char *name

与设备关联的名称

这个函数类似于 parport_register_device()，不同之处在于它通过设备编号而不是连接到的端口来定位设备。

除了 devnum 之外的所有参数都与 parport_register_device() 相同。返回值与 parport_register_device() 相同。

void parport_close(struct pardevice *dev)

关闭使用 parport_open() 打开的设备

参数

struct pardevice *dev

要关闭的设备

这相当于 parport_open() 之于 parport_unregister_device() 之于 parport_register_device()。

16x50 UART 驱动

struct uart_8250_port *serial8250_get_port(int line)

检索 struct uart_8250_port

参数

int line

串口线号

说明

此函数检索特定线路的 struct uart_8250_port。此结构必须不能用于执行无法以其他方式访问的 8250 或串行核心操作。它唯一的目的是使结构可用于运行时 PM 回调，以进行上下文挂起/恢复。这里做出的锁定假设是没有，因为如果对端口执行任何操作，则不应调用运行时 PM 挂起/恢复回调。

void serial8250_suspend_port(int line)

挂起一个串口

参数

int line

串口线号

挂起一个串口。

void serial8250_resume_port(int line)

恢复一个串口

参数

int line

串口线号

恢复一个串口。

int serial8250_register_8250_port(const struct uart_8250_port *up)

注册一个串口

参数

const struct uart_8250_port *up

串口模板

配置请求指定的串口。如果端口存在且正在使用，则首先挂断并注销它。

然后探测该端口，并在必要时自动检测 IRQ。如果此操作失败，则返回一个错误。

成功后，该端口即可使用，并返回行号。

void serial8250_unregister_port(int line)

在运行时删除一个 16x50 串口

参数

int line

串口线号

删除一个串口。不得从中断上下文中调用此方法。我们将端口交还给我们的控制。

有关相关 API，请参见 底层串行 API。

脉冲宽度调制 (PWM)

脉冲宽度调制是一种主要用于控制提供给电气设备的功率的调制技术。

PWM 框架为 PWM 信号的提供者和使用者提供了一个抽象。提供一个或多个 PWM 信号的控制器被注册为 struct pwm_chip。提供者应将此结构嵌入到驱动程序特定的结构中。此结构包含描述特定芯片的字段。

一个芯片公开一个或多个 PWM 信号源，每个信号源都公开为 struct pwm_device。可以对 PWM 设备执行操作，以控制信号的周期、占空比、极性和活动状态。

请注意，PWM 设备是独占资源：它们一次只能被一个使用者使用。

enum pwm_polarity

PWM 信号的极性

常量

PWM_POLARITY_NORMAL

在占空比期间为高电平信号，在脉冲周期的剩余时间内为低电平信号

PWM_POLARITY_INVERSED

在占空比期间为低电平信号，在脉冲周期的剩余时间内为高电平信号

struct pwm_args

依赖于板的 PWM 参数

定义:

struct pwm_args {
    u64 period;
    enum pwm_polarity polarity;
};

成员

period

参考周期

polarity

参考极性

说明

此结构描述了附加到 PWM 设备的依赖于板的参数。这些参数通常从 PWM 查找表或设备树中检索。

不要将此与 PWM 状态混淆：PWM 参数表示用户希望在此 PWM 设备上使用的初始配置，而不是当前的 PWM 硬件状态。

struct pwm_waveform

PWM 波形的描述

定义:

struct pwm_waveform {
    u64 period_length_ns;
    u64 duty_length_ns;
    u64 duty_offset_ns;
};

成员

period_length_ns

PWM 周期

duty_length_ns

PWM 占空比

duty_offset_ns

上升沿相对于周期起点的偏移

说明

这是 PWM 波形的表示形式，是下面 struct pwm_state 的替代方案。它比 struct pwm_state 更具表现力，因为它包含 duty_offset_ns，因此可以表示零以外的偏移量（使用 .polarity = PWM_POLARITY_NORMAL）和 period - duty_cycle（.polarity = PWM_POLARITY_INVERSED）。

请注意，没有明确的布尔值用于启用。 “禁用”的 PWM 由 .period_length_ns = 0 表示。请进一步注意，“禁用”的 PWM 的行为是未定义的。根据硬件的功能，它可能会驱动活动或非活动级别，变为高阻抗，甚至继续切换。

所有三个成员的单位均为纳秒。

struct pwm_device

PWM 通道对象

定义:

struct pwm_device {
    const char *label;
    unsigned long flags;
    unsigned int hwpwm;
    struct pwm_chip *chip;
    struct pwm_args args;
    struct pwm_state state;
    struct pwm_state last;
};

成员

label

PWM 设备的名称

flags

与 PWM 设备关联的标志

hwpwm

PWM 设备的每个芯片的相对索引

chip

提供此 PWM 设备的 PWM 芯片

args

PWM 参数

state

上次应用的状态

last

上次实现的状态（用于 PWM_DEBUG）

void pwm_get_state(const struct pwm_device *pwm, struct pwm_state *state)

检索当前 PWM 状态

参数

const struct pwm_device *pwm

PWM 设备

struct pwm_state *state

用于填充当前 PWM 状态的状态

说明

返回的 PWM 状态表示先前调用 pwm_apply_might_sleep() 应用的状态。驱动程序可能需要在将其编程到硬件之前稍微调整该状态。如果从未调用 pwm_apply_might_sleep()，则此函数返回当前的硬件状态（如果支持）或默认设置。

void pwm_init_state(const struct pwm_device *pwm, struct pwm_state *state)

准备一个新状态，以便使用 pwm_apply_might_sleep() 应用

参数

const struct pwm_device *pwm

PWM 设备

struct pwm_state *state

使用准备好的 PWM 状态填充的状态

说明

此函数准备一个状态，该状态稍后可以进行调整，并使用 pwm_apply_might_sleep() 应用到 PWM 设备。这是一个方便的函数，它首先检索当前的 PWM 状态，然后使用 pwm->args 中定义的参考值替换周期和极性字段。该函数返回后，您可以根据需要调整 ->enabled 和 ->duty_cycle 字段，然后再调用 pwm_apply_might_sleep()。

->duty_cycle 最初设置为零，以避免当前 ->duty_cycle 值超过 pwm_args->period 值的情况，如果用户在不首先调整 ->duty_cycle 的情况下调用 pwm_apply_might_sleep()，这将触发一个错误。

unsigned int pwm_get_relative_duty_cycle(const struct pwm_state *state, unsigned int scale)

获取相对占空比值

参数

const struct pwm_state *state

从中提取占空比的 PWM 状态

unsigned int scale

相对占空比的目标比例

说明

此函数将存储在 state 中的绝对占空比（以纳秒表示）转换为相对于周期的值。

例如，如果您想获得以百分比表示的 duty_cycle，请调用

pwm_get_state(pwm, state); duty = pwm_get_relative_duty_cycle(state, 100);

返回

乘以 scale 的四舍五入的相对占空比

int pwm_set_relative_duty_cycle(struct pwm_state *state, unsigned int duty_cycle, unsigned int scale)

设置相对占空比值

参数

struct pwm_state *state

要填充的 PWM 状态

unsigned int duty_cycle

相对占空比值

unsigned int scale

表示 duty_cycle 的比例

说明

此函数将相对占空比转换为绝对占空比（以纳秒表示），并将结果放入 state->duty_cycle 中。

例如，如果您想配置 50% 的占空比，请调用

pwm_init_state(pwm, state); pwm_set_relative_duty_cycle(state, 50, 100); pwm_apply_might_sleep(pwm, state);

返回

成功时返回 0，如果 duty_cycle 和/或 scale 不一致，则返回 -EINVAL（scale == 0 或 duty_cycle > scale）

struct pwm_capture

PWM 捕获数据

定义:

struct pwm_capture {
    unsigned int period;
    unsigned int duty_cycle;
};

成员

period

period

duty_cycle

PWM 信号的占空比（以纳秒为单位）

struct pwm_ops

PWM 控制器操作

定义:

struct pwm_ops {
    int (*request)(struct pwm_chip *chip, struct pwm_device *pwm);
    void (*free)(struct pwm_chip *chip, struct pwm_device *pwm);
    int (*capture)(struct pwm_chip *chip, struct pwm_device *pwm, struct pwm_capture *result, unsigned long timeout);
    size_t sizeof_wfhw;
    int (*round_waveform_tohw)(struct pwm_chip *chip, struct pwm_device *pwm, const struct pwm_waveform *wf, void *wfhw);
    int (*round_waveform_fromhw)(struct pwm_chip *chip, struct pwm_device *pwm, const void *wfhw, struct pwm_waveform *wf);
    int (*read_waveform)(struct pwm_chip *chip, struct pwm_device *pwm, void *wfhw);
    int (*write_waveform)(struct pwm_chip *chip, struct pwm_device *pwm, const void *wfhw);
    int (*apply)(struct pwm_chip *chip, struct pwm_device *pwm, const struct pwm_state *state);
    int (*get_state)(struct pwm_chip *chip, struct pwm_device *pwm, struct pwm_state *state);
};

成员

request

用于请求 PWM 的可选钩子

free

用于释放 PWM 的可选钩子

capture

捕获和报告 PWM 信号

sizeof_wfhw

驱动程序特定波形表示的大小（以字节为单位）

round_waveform_tohw

将 struct pwm_waveform 转换为驱动程序特定表示形式

round_waveform_fromhw

将驱动程序特定的波形表示形式转换为 struct pwm_waveform

read_waveform

从硬件读取驱动程序特定的波形表示形式

write_waveform

将驱动程序特定的波形表示形式写入硬件

apply

原子地应用新的 PWM 配置

get_state

获取当前 PWM 状态。

struct pwm_chip

抽象 PWM 控制器

定义:

struct pwm_chip {
    struct device dev;
    const struct pwm_ops *ops;
    struct module *owner;
    unsigned int id;
    unsigned int npwm;
    struct pwm_device * (*of_xlate)(struct pwm_chip *chip, const struct of_phandle_args *args);
    bool atomic;
    bool uses_pwmchip_alloc;
    bool operational;
    union {
        struct mutex nonatomic_lock;
        spinlock_t atomic_lock;
    };
    struct pwm_device pwms[] ;
};

成员

dev

提供 PWM 的设备

ops

此 PWM 控制器的回调

owner

提供此芯片的模块

id

此 PWM 芯片的唯一编号

npwm

此芯片控制的 PWM 数量

of_xlate

给定设备树 PWM 说明符，请求 PWM 设备

atomic

驱动程序的 ->apply() 是否可以在原子上下文中调用

uses_pwmchip_alloc

如果使用 pwmchip_allow 分配此芯片，则发出信号

operational

如果芯片可以使用（或已注销），则发出信号

{unnamed_union}

anonymous

nonatomic_lock

用于非原子芯片的互斥锁

atomic_lock

用于原子芯片的互斥锁

pwms

框架分配的 PWM 设备数组

bool pwmchip_supports_waveform(struct pwm_chip *chip)

检查给定芯片是否支持波形回调

参数

struct pwm_chip *chip

要测试的 pwm_chip

返回

当且仅当 PWM 芯片支持 pwm_set_waveform_might_sleep() 和 pwm_round_waveform_might_sleep() 等波形函数时，才为 true

int pwm_config(struct pwm_device *pwm, int duty_ns, int period_ns)

更改 PWM 设备配置

参数

struct pwm_device *pwm

PWM 设备

int duty_ns

“导通”时间（以纳秒为单位）

int period_ns

一个周期的持续时间（以纳秒为单位）

返回

成功时返回 0，失败时返回负错误代码。

int pwm_enable(struct pwm_device *pwm)

启动 PWM 输出切换

参数

struct pwm_device *pwm

PWM 设备

返回

成功时返回 0，失败时返回负错误代码。

void pwm_disable(struct pwm_device *pwm)

停止 PWM 输出切换

参数

struct pwm_device *pwm

PWM 设备

bool pwm_might_sleep(struct pwm_device *pwm)

是否支持 pwm_apply_atomic()？

参数

struct pwm_device *pwm

PWM 设备

返回

如果可以从原子上下文中调用 pwm_apply_atomic()，则为 false。

int pwm_round_waveform_might_sleep(struct pwm_device *pwm, struct pwm_waveform *wf)

查询硬件功能。不能在原子上下文中使用。

参数

struct pwm_device *pwm

PWM 设备

struct pwm_waveform *wf

要舍入的波形和输出参数

说明

通常，给定的波形无法由硬件精确实现，例如，因为硬件仅支持粗略的周期分辨率或没有 duty_offset。 如果现在将 wf 传递给 pwm_set_waveform_might_sleep()，此函数将返回实际实现的波形。

但是请注意，当您调用它时，世界不会停止旋转，因此在执行

pwm_round_waveform_might_sleep(mypwm, &wf);
pwm_set_waveform_might_sleep(mypwm, &wf, true);

后者可能会失败，例如，因为输入时钟在两次调用之间改变了速率，并且无法再实现由 pwm_round_waveform_might_sleep() 确定的波形。

通常，wf 中传递的所有值都向下舍入到最接近的可能值（按 period_length_ns、duty_length_ns 然后是 duty_offset_ns 的顺序）。 只有在不可能的情况下，值才会增长。 有关更正式的描述，请参见 pwm_set_waveform_might_sleep() 的文档。

返回

成功时返回 0，如果至少一个值必须向上舍入，则返回 1，否则返回负 errno。

上下文

可能睡眠。

int pwm_get_waveform_might_sleep(struct pwm_device *pwm, struct pwm_waveform *wf)

查询有关当前配置的硬件。 不能在原子上下文中使用。

参数

struct pwm_device *pwm

PWM 设备

struct pwm_waveform *wf

输出参数

说明

在 wf 中存储 PWM 的当前配置。 请注意，这等效于 pwm_get_state_hw()（而不是 pwm_get_state()）用于 pwm_waveform。

返回

成功时返回 0 或负 errno

上下文

可能睡眠。

int pwm_set_waveform_might_sleep(struct pwm_device *pwm, const struct pwm_waveform *wf, bool exact)

应用新波形。 不能在原子上下文中使用。

参数

struct pwm_device *pwm

PWM 设备

const struct pwm_waveform *wf

要应用的波形

bool exact

如果为 true，则不允许舍入

说明

通常，无法精确地实现请求的波形，例如，因为您请求 .period_length_ns = 100 ns，但是硬件只能设置 8.5 ns 的倍数的周期。 对于该硬件，传递 exact = true 会导致 pwm_set_waveform_might_sleep() 失败并返回 -EDOM。 如果 exact = false，则周期为 93.5 ns（即，不大于请求值的最大周期）。 请注意，即使使用 exact = true，也可能/需要小于 1 ns 的某些舍入。 在以上示例中，请求 .period_length_ns = 94 且 exact = true，则硬件配置的周期 = 93.5 ns。

令 C 为给定 PWM 设备的可能硬件配置的集合，由元组 (p, d, o) 组成，其中 p 是周期长度，d 是占空比长度，o 是占空比偏移量。

实现以下算法来为给定请求 (p', d', o') 选择硬件设置 (p, d, o) ∈ C，其中 exact = false

p = max( { ṗ | ∃ ḋ, ȯ : (ṗ, ḋ, ȯ) ∈ C ∧ ṗ ≤ p' } ∪ { min({ ṗ | ∃ ḋ, ȯ : (ṗ, ḋ, ȯ) ∈ C }) })
d = max( { ḋ | ∃ ȯ : (p, ḋ, ȯ) ∈ C ∧ ḋ ≤ d' } ∪ { min({ ḋ | ∃ ȯ : (p, ḋ, ȯ) ∈ C }) })
o = max( { ȯ | (p, d, ȯ) ∈ C ∧ ȯ ≤ o' } ∪ { min({ ȯ | (p, d, ȯ) ∈ C }) })

用文字描述：选择的周期长度是不大于请求的周期长度的最大可能周期长度，如果不存在，则选择最小的周期长度。 选择的占空比长度是与选择的周期长度兼容且不大于请求的占空比长度的最大可能占空比长度。 同样，如果不存在这样的值，则选择与选择的周期兼容的最小占空比长度。 之后，以相同的方式选择与选择的周期和占空比长度兼容的占空比偏移量。

返回

成功时返回 0，如果由于确切的波形不可能而导致设置失败，则返回 -EDOM（如果 exact 为 true），否则返回不同的负 errno 表示失败。

上下文

可能睡眠。

int pwm_apply_might_sleep(struct pwm_device *pwm, const struct pwm_state *state)

原子地将新状态应用于 PWM 设备。 不能在原子上下文中使用。

参数

struct pwm_device *pwm

PWM 设备

const struct pwm_state *state

要应用的新状态

返回

成功时返回 0，否则返回负 errno

上下文

可能睡眠。

int pwm_apply_atomic(struct pwm_device *pwm, const struct pwm_state *state)

从原子上下文将新状态应用于 PWM 设备。 并非所有 PWM 设备都支持此功能，请使用 pwm_might_sleep() 进行检查。

参数

struct pwm_device *pwm

PWM 设备

const struct pwm_state *state

要应用的新状态

返回

成功时返回 0，否则返回负 errno

上下文

任何

int pwm_get_state_hw(struct pwm_device *pwm, struct pwm_state *state)

从硬件获取当前 PWM 状态

参数

struct pwm_device *pwm

PWM 设备

struct pwm_state *state

用于填充当前 PWM 状态的状态

说明

与 pwm_get_state() 类似，但是从硬件而不是请求的状态读取当前 PWM 状态。

返回

成功时返回 0，失败时返回负错误代码。

上下文

可能睡眠。

int pwm_adjust_config(struct pwm_device *pwm)

将当前 PWM 配置调整为 PWM 参数

参数

struct pwm_device *pwm

PWM 设备

说明

此函数将把 PWM 配置调整为由 DT 或 PWM 查找表提供的 PWM 参数。 这对于将引导加载程序配置调整为 Linux 配置特别有用。

返回

成功时返回 0，失败时返回负错误代码。

上下文

可能睡眠。

struct pwm_device *pwm_get(struct device *dev, const char *con_id)

查找并请求 PWM 设备

参数

struct device *dev

PWM 使用者的设备

const char *con_id

使用者名称

说明

首先尝试使用 DT 进行查找。 如果设备不是从设备树实例化的，则通过板设置代码提供的表查找 PWM 芯片和相对索引（请参见 pwm_add_table()）。

找到 PWM 芯片后，将请求指定的 PWM 设备并准备好使用。

返回

指向请求的 PWM 设备的指针，如果失败，则为 ERR_PTR()-编码的错误代码。

void pwm_put(struct pwm_device *pwm)

释放 PWM 设备

参数

struct pwm_device *pwm

PWM 设备

struct pwm_device *devm_pwm_get(struct device *dev, const char *con_id)

资源托管的 pwm_get()

参数

struct device *dev

PWM 使用者的设备

const char *con_id

使用者名称

说明

此函数的作用类似于 pwm_get()，但是获取的 PWM 设备将在驱动程序分离时自动释放。

返回

指向请求的 PWM 设备的指针，如果失败，则为 ERR_PTR()-编码的错误代码。

struct pwm_device *devm_fwnode_pwm_get(struct device *dev, struct fwnode_handle *fwnode, const char *con_id)

从固件节点请求资源托管的 PWM

参数

struct device *dev

PWM 使用者的设备

struct fwnode_handle *fwnode

从中获取 PWM 的固件节点

const char *con_id

使用者名称

说明

返回从固件节点解析的 PWM 设备。 有关详细说明，请参见 of_pwm_get() 和 acpi_pwm_get()。

返回

指向请求的 PWM 设备的指针，如果失败，则为 ERR_PTR()-编码的错误代码。

int __pwmchip_add(struct pwm_chip *chip, struct module *owner)

注册新的 PWM 芯片

参数

struct pwm_chip *chip

要添加的 PWM 芯片

struct module *owner

对提供芯片的模块的引用。

说明

注册一个新的 PWM 芯片。 owner 应该是 THIS_MODULE，请使用 pwmchip_add 包装器来正确地执行此操作。

返回

成功时返回 0，失败时返回负错误代码。

void pwmchip_remove(struct pwm_chip *chip)

移除 PWM 芯片

参数

struct pwm_chip *chip

要移除的 PWM 芯片

说明

移除 PWM 芯片。