并行端口设备

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_driver

要使用的 struct parport_driver

描述

用于在模块初始化和退出时不执行任何特殊操作的并行端口驱动程序的辅助宏。这消除了许多样板代码。每个模块只能使用此宏一次，并且调用它会替换 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()）将最多 **len** 字节的 **buffer** 写入指定的端口。

调用方有责任确保 **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 结构的操作结构会被替换为包含返回错误或不执行任何操作的“空”操作的结构。

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

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

要赋予设备的设备编号

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

结构体 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 波形的表示形式，与下面的结构 pwm_state 不同。它比结构 pwm_state 更具表现力，因为它包含 duty_offset_ns，因此可以表示零以外的偏移量（.polarity = PWM_POLARITY_NORMAL）和周期 - 占空比（.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 中定义的参考值。一旦函数返回，您可以在调用 pwm_apply_might_sleep() 之前，根据您的需要调整 ->enabled 和 ->duty_cycle 字段。

->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 中的绝对占空比（以纳秒表示）转换为相对于周期的值。

例如，如果要获取以百分比表示的占空比，请调用

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

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

如果 duty_cycle 和/或 scale 不一致（scale == 0 或 duty_cycle > scale），则此函数返回 -EINVAL。

struct pwm_capture

PWM 捕获数据

定义:

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

成员

period

PWM 信号的周期（以纳秒为单位）

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}

匿名

nonatomic_lock

用于非原子芯片的互斥锁

atomic_lock

用于原子芯片的互斥锁

pwms

由框架分配的 PWM 设备数组

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() 确定的波形无法再实现。

成功返回 0；如果根据 PWM 舍入规则，没有与输入波形匹配的有效硬件配置，则返回 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

输出参数

描述

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

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() 失败并返回 1。 如果 exact = false，则获得 93.5 ns 的周期（即不大于请求值的最大周期）。 请注意，即使 exact = true，也可能/需要进行小于 1 的舍入。 在上面的示例中，请求 .period_length_ns = 94 且 exact = true，您会得到配置为 period = 93.5 ns 的硬件。

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

要应用的新状态

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

要应用的新状态

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 配置特别有用。

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

查找并请求 PWM 设备

参数

struct device *dev

PWM 使用者的设备

const char *con_id

使用者名称

描述

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

找到 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 芯片。