RapidIO 子系统指南¶

作者:: Matt Porter

简介¶

RapidIO 是一种高速交换结构互连，其特性面向嵌入式市场。 RapidIO 提供对基于交换结构网络的内存映射 I/O 和基于消息的事务的支持。 RapidIO 具有标准化的发现机制，与 PCI 总线标准非常相似，可以简单地检测网络中的设备。

本文档为希望在新架构上支持 RapidIO、编写新驱动程序或了解子系统内部结构的开发人员提供。

已知 Bug 和限制¶

Bug¶

无。 ;)

限制¶

不支持对 RapidIO 内存区域的访问/管理
不支持多主机枚举

RapidIO 驱动接口¶

驱动程序提供了一组调用，以便与子系统交互，以收集设备信息、请求/映射内存区域资源以及管理邮箱/门铃。

函数¶

int rio_local_read_config_32(struct rio_mport *port, u32 offset, u32 *data)¶: 从本地配置空间读取 32 位

参数

struct rio_mport *port: 主端口
u32 offset: 到本地配置空间的偏移量
u32 * data: 指向要读取的数据的指针

描述

从本地设备的配置空间内指定的偏移量读取 32 位数据。

int rio_local_write_config_32(struct rio_mport *port, u32 offset, u32 data)¶: 将 32 位写入本地配置空间

参数

struct rio_mport *port: 主端口
u32 offset: 到本地配置空间的偏移量
u32 data: 要写入的数据

描述

将 32 位数据写入到本地设备的配置空间内指定的偏移量。

int rio_local_read_config_16(struct rio_mport *port, u32 offset, u16 *data)¶: 从本地配置空间读取 16 位

参数

struct rio_mport *port: 主端口
u32 offset: 到本地配置空间的偏移量
u16 * data: 指向要读取的数据的指针

描述

从本地设备的配置空间内指定的偏移量读取 16 位数据。

int rio_local_write_config_16(struct rio_mport *port, u32 offset, u16 data)¶: 将 16 位写入本地配置空间

参数

struct rio_mport *port: 主端口
u32 offset: 到本地配置空间的偏移量
u16 data: 要写入的数据

描述

将 16 位数据写入到本地设备的配置空间内指定的偏移量。

int rio_local_read_config_8(struct rio_mport *port, u32 offset, u8 *data)¶: 从本地配置空间读取 8 位

参数

struct rio_mport *port: 主端口
u32 offset: 到本地配置空间的偏移量
u8 * data: 指向要读取的数据的指针

描述

从本地设备的配置空间内指定的偏移量读取 8 位数据。

int rio_local_write_config_8(struct rio_mport *port, u32 offset, u8 data)¶: 将 8 位写入本地配置空间

参数

struct rio_mport *port: 主端口
u32 offset: 到本地配置空间的偏移量
u8 data: 要写入的数据

描述

将 8 位数据写入到本地设备的配置空间内指定的偏移量。

int rio_read_config_32(struct rio_dev *rdev, u32 offset, u32 *data)¶: 从配置空间读取 32 位

参数

struct rio_dev *rdev: RIO 设备
u32 offset: 到设备配置空间的偏移量
u32 * data: 指向要读取的数据的指针

描述

从 RIO 设备的配置空间内指定的偏移量读取 32 位数据。

int rio_write_config_32(struct rio_dev *rdev, u32 offset, u32 data)¶: 将 32 位写入配置空间

参数

struct rio_dev *rdev: RIO 设备
u32 offset: 到设备配置空间的偏移量
u32 data: 要写入的数据

描述

将 32 位数据写入到 RIO 设备的配置空间内指定的偏移量。

int rio_read_config_16(struct rio_dev *rdev, u32 offset, u16 *data)¶: 从配置空间读取 16 位

参数

struct rio_dev *rdev: RIO 设备
u32 offset: 到设备配置空间的偏移量
u16 * data: 指向要读取的数据的指针

描述

从 RIO 设备的配置空间内指定的偏移量读取 16 位数据。

int rio_write_config_16(struct rio_dev *rdev, u32 offset, u16 data)¶: 将 16 位写入配置空间

参数

struct rio_dev *rdev: RIO 设备
u32 offset: 到设备配置空间的偏移量
u16 data: 要写入的数据

描述

将 16 位数据写入到 RIO 设备的配置空间内指定的偏移量。

int rio_read_config_8(struct rio_dev *rdev, u32 offset, u8 *data)¶: 从配置空间读取 8 位

参数

struct rio_dev *rdev: RIO 设备
u32 offset: 到设备配置空间的偏移量
u8 * data: 指向要读取的数据的指针

描述

从 RIO 设备的配置空间内指定的偏移量读取 8 位数据。

int rio_write_config_8(struct rio_dev *rdev, u32 offset, u8 data)¶: 将 8 位写入配置空间

参数

struct rio_dev *rdev: RIO 设备
u32 offset: 到设备配置空间的偏移量
u8 data: 要写入的数据

描述

将 8 位数据写入到 RIO 设备的配置空间内指定的偏移量。

int rio_send_doorbell(struct rio_dev *rdev, u16 data)¶: 向设备发送门铃消息

参数

struct rio_dev *rdev: RIO 设备
u16 data: 门铃消息数据

描述

向 RIO 设备发送门铃消息。门铃消息具有由 data 参数提供的 16 位信息字段。

void rio_init_mbox_res(struct resource *res, int start, int end)¶: 初始化 RIO 邮箱资源

参数

struct resource *res: 资源结构
int start: 邮箱范围的开始
int end: 邮箱范围的结束

描述

此函数用于初始化资源字段以用作邮箱资源。它使用 start 和 end 参数初始化一系列邮箱。

void rio_init_dbell_res(struct resource *res, u16 start, u16 end)¶: 初始化 RIO 门铃资源

参数

struct resource *res: 资源结构
u16 start: 门铃范围的开始
u16 end: 门铃范围的结束

描述

此函数用于初始化资源字段以用作门铃资源。它使用 start 和 end 参数初始化一系列门铃消息。

RIO_DEVICE¶

RIO_DEVICE (dev, ven)

用于描述特定 RIO 设备的宏

参数

dev: 16 位 RIO 设备 ID
ven: 16 位 RIO 供应商 ID

描述

此宏用于创建与特定设备匹配的 struct rio_device_id。组件供应商和组件设备字段将设置为 RIO_ANY_ID。

int rio_add_outb_message(struct rio_mport *mport, struct rio_dev *rdev, int mbox, void *buffer, size_t len)¶: 将 RIO 消息添加到出站邮箱队列

参数

struct rio_mport *mport: 包含出站队列的 RIO 主端口
struct rio_dev *rdev: 要将消息发送到的 RIO 设备
int mbox: 出站邮箱队列
void *buffer: 指向消息缓冲区的指针
size_t len: 消息缓冲区的长度

描述

将 RIO 消息缓冲区添加到出站邮箱队列以进行传输。成功时返回 0。

int rio_add_inb_buffer(struct rio_mport *mport, int mbox, void *buffer)¶: 将缓冲区添加到入站邮箱队列

参数

struct rio_mport *mport: 包含入站邮箱的主端口
int mbox: 入站邮箱号码
void *buffer: 指向消息缓冲区的指针

描述

将缓冲区添加到入站邮箱队列以进行接收。成功时返回 0。

void *rio_get_inb_message(struct rio_mport *mport, int mbox)¶: 从入站邮箱队列获取 RIO 消息

参数

struct rio_mport *mport: 包含入站邮箱的主端口
int mbox: 入站邮箱号码

描述

从入站邮箱队列获取 RIO 消息。成功时返回 0。

const char *rio_name(struct rio_dev *rdev)¶: 获取唯一的 RIO 设备标识符

参数

struct rio_dev *rdev: RIO 设备

描述

获取唯一的 RIO 设备标识符。返回设备标识符字符串。

void *rio_get_drvdata(struct rio_dev *rdev)¶: 获取 RIO 驱动程序特定数据

参数

struct rio_dev *rdev: RIO 设备

描述

获取 RIO 驱动程序特定数据。返回指向驱动程序特定数据的指针。

void rio_set_drvdata(struct rio_dev *rdev, void *data)¶: 设置 RIO 驱动程序特定数据

参数

struct rio_dev *rdev: RIO 设备
void *data: 指向驱动程序特定数据的指针

描述

设置 RIO 驱动程序特定数据。设备结构的驱动程序数据指针设置为 data 参数。

struct rio_dev *rio_dev_get(struct rio_dev *rdev)¶: 递增 RIO 设备结构的引用计数

参数

struct rio_dev *rdev: 正在被引用的 RIO 设备

描述

对设备的每个实时引用都应该被引用计数。

RIO 设备的驱动程序通常应在其 probe() 方法中记录此类引用（当它们绑定到设备时），并在其 disconnect() 方法中通过调用 rio_dev_put() 来释放它们。

void rio_dev_put(struct rio_dev *rdev)¶: 释放对 RIO 设备结构的使用

参数

struct rio_dev *rdev: 正在断开连接的 RIO 设备

描述

当设备的用户使用完设备后，必须调用此函数。当设备的最后一个用户调用此函数时，设备的内存将被释放。

int rio_register_driver(struct rio_driver *rdrv)¶: 注册新的 RIO 驱动程序

参数

struct rio_driver *rdrv

要注册的 RIO 驱动程序结构

将 struct rio_driver 添加到已注册驱动程序列表中。错误时返回负值，否则返回 0。如果未发生错误，即使在注册期间没有声明任何设备，驱动程序仍保持注册状态。

void rio_unregister_driver(struct rio_driver *rdrv)¶: 注销 RIO 驱动程序

参数

struct rio_driver *rdrv

要注销的 RIO 驱动程序结构

从已注册的 RIO 驱动程序列表中删除 struct rio_driver，使其有机会通过为它负责的每个设备调用其 remove() 函数来进行清理，并将这些设备标记为无驱动程序。

u16 rio_local_get_device_id(struct rio_mport *port)¶: 获取端口的基本/扩展设备 ID

参数

struct rio_mport *port: 从中获取 deviceid 的 RIO 主端口

描述

从实现主端口的本地设备读取基本/扩展设备 ID。返回 8/16 位设备 ID。

int rio_query_mport(struct rio_mport *port, struct rio_mport_attr *mport_attr)¶: 查询 mport 设备属性

参数

struct rio_mport *port: 要查询的 mport 设备
struct rio_mport_attr *mport_attr: mport 属性数据结构

描述

通过指向属性数据结构的指针返回指定 mport 的属性。

struct rio_net *rio_alloc_net(struct rio_mport *mport)¶: 分配并初始化新的 RIO 网络数据结构

参数

struct rio_mport *mport: 与 RIO 网络关联的主端口

描述

分配 RIO 网络结构，初始化每个网络的列表头，并将关联的主端口添加到关联的主端口的网络列表。成功时返回 RIO 网络指针，失败时返回 NULL。

void rio_local_set_device_id(struct rio_mport *port, u16 did)¶: 设置端口的基本/扩展设备 ID

参数

struct rio_mport *port: RIO 主端口
u16 did: 要写入的设备 ID 值

描述

从设备写入基本/扩展设备 ID。

int rio_add_device(struct rio_dev *rdev)¶: 将 RIO 设备添加到设备模型

参数

struct rio_dev *rdev: RIO 设备

描述

将 RIO 设备添加到全局设备列表，并将 RIO 设备添加到 RIO 设备列表。为 RIO 设备创建通用 sysfs 节点。

int rio_request_inb_mbox(struct rio_mport *mport, void *dev_id, int mbox, int entries, void (*minb)(struct rio_mport *mport, void *dev_id, int mbox, int slot))¶: 请求入站邮箱服务

参数

struct rio_mport *mport: 从中分配邮箱资源的 RIO 主端口
void *dev_id: 设备特定的指针，用于传递事件
int mbox: 要声明的邮箱号码
int entries: 入站邮箱队列中的条目数
void (*minb) (struct rio_mport * mport, void *dev_id, int mbox, int slot): 收到入站消息时要执行的回调

描述

请求入站邮箱资源的所有权，并将回调函数绑定到该资源。成功时返回 0。

int rio_release_inb_mbox(struct rio_mport *mport, int mbox)¶: 释放入站邮箱消息服务

参数

struct rio_mport *mport: 从中释放邮箱资源的 RIO 主端口
int mbox: 要释放的邮箱号码

描述

释放入站邮箱资源的所有权。如果请求已得到满足，则返回 0。

int rio_request_outb_mbox(struct rio_mport *mport, void *dev_id, int mbox, int entries, void (*moutb)(struct rio_mport *mport, void *dev_id, int mbox, int slot))¶: 请求出站邮箱服务

参数

struct rio_mport *mport: 从中分配邮箱资源的 RIO 主端口
void *dev_id: 设备特定的指针，用于传递事件
int mbox: 要声明的邮箱号码
int entries: 出站邮箱队列中的条目数
void (*moutb) (struct rio_mport * mport, void *dev_id, int mbox, int slot): 发送出站消息时要执行的回调

描述

请求出站邮箱资源的所有权，并将回调函数绑定到该资源。成功时返回 0。

int rio_release_outb_mbox(struct rio_mport *mport, int mbox)¶: 释放出站邮箱消息服务

参数

struct rio_mport *mport: 从中释放邮箱资源的 RIO 主端口
int mbox: 要释放的邮箱号码

描述

释放入站邮箱资源的所有权。如果请求已得到满足，则返回 0。

int rio_request_inb_dbell(struct rio_mport *mport, void *dev_id, u16 start, u16 end, void (*dinb)(struct rio_mport *mport, void *dev_id, u16 src, u16 dst, u16 info))¶: 请求入站门铃消息服务

参数

struct rio_mport *mport: 从中分配门铃资源的 RIO 主端口
void *dev_id: 设备特定的指针，用于传递事件
u16 start: 门铃信息范围起点
u16 end: 门铃信息范围终点
void (*dinb) (struct rio_mport * mport, void *dev_id, u16 src, u16 dst, u16 info): 接收到门铃时执行的回调函数

描述

请求入站门铃资源的所有权，并将回调函数绑定到该资源。如果请求已满足，则返回 0。

int rio_release_inb_dbell(struct rio_mport *mport, u16 start, u16 end)¶: 释放入站门铃消息服务

参数

struct rio_mport *mport: 从中释放门铃资源的 RIO 主端口
u16 start: 门铃信息范围起点
u16 end: 门铃信息范围终点

描述

释放入站门铃资源的所有权，并从门铃事件列表中删除回调。如果请求已满足，则返回 0。

struct resource *rio_request_outb_dbell(struct rio_dev *rdev, u16 start, u16 end)¶: 请求出站门铃消息范围

参数

struct rio_dev *rdev: 从中分配门铃资源的 RIO 设备
u16 start: 门铃消息范围起始值
u16 end: 门铃消息范围结束值

描述

请求门铃消息范围的所有权。如果请求已满足，则返回资源；否则，返回 NULL。

int rio_release_outb_dbell(struct rio_dev *rdev, struct resource *res)¶: 释放出站门铃消息范围

参数

struct rio_dev *rdev: 从中释放门铃资源的 RIO 设备
struct resource *res: 要释放的门铃资源

描述

释放门铃消息范围的所有权。如果请求已满足，则返回 0。

int rio_add_mport_pw_handler(struct rio_mport *mport, void *context, int (*pwcback)(struct rio_mport *mport, void *context, union rio_pw_msg *msg, int step))¶: 将端口写入消息处理程序添加到 mport 特定 pw 处理程序的列表中

参数

struct rio_mport *mport: 绑定 portwrite 回调的 RIO 主端口
void *context: 要在事件中传递的处理程序特定上下文
int (*pwcback)(struct rio_mport *mport, void *context, union rio_pw_msg *msg, int step): 接收到 portwrite 时执行的回调函数

描述

如果请求已满足，则返回 0。

int rio_del_mport_pw_handler(struct rio_mport *mport, void *context, int (*pwcback)(struct rio_mport *mport, void *context, union rio_pw_msg *msg, int step))¶: 从 mport 特定 pw 处理程序的列表中删除端口写入消息处理程序

参数

struct rio_mport *mport: 绑定 portwrite 回调的 RIO 主端口
void *context: 要传递到事件的已注册处理程序特定上下文
int (*pwcback)(struct rio_mport *mport, void *context, union rio_pw_msg *msg, int step): 已注册回调函数

描述

如果请求已满足，则返回 0。

int rio_request_inb_pwrite(struct rio_dev *rdev, int (*pwcback)(struct rio_dev *rdev, union rio_pw_msg *msg, int step))¶: 请求特定 RapidIO 设备的入站端口写入消息服务

参数

struct rio_dev *rdev: 要向其注册入站端口写入回调例程的 RIO 设备
int (*pwcback)(struct rio_dev *rdev, union rio_pw_msg *msg, int step): 接收到端口写入时执行的回调例程

描述

将端口写入回调函数绑定到 RapidIO 设备。如果请求已满足，则返回 0。

int rio_release_inb_pwrite(struct rio_dev *rdev)¶: 释放与特定 RapidIO 设备关联的入站端口写入消息服务

参数

struct rio_dev *rdev: 已注册入站端口写入回调的 RIO 设备

描述

从 rio_dev 结构中删除回调。如果请求已满足，则返回 0。

void rio_pw_enable(struct rio_mport *mport, int enable)¶: 启用/禁用主端口的端口写入处理

参数

struct rio_mport *mport: 与端口写入处理关联的主端口
int enable: 1=启用，0=禁用

int rio_map_inb_region(struct rio_mport *mport, dma_addr_t local, u64 rbase, u32 size, u32 rflags)¶

映射入站内存区域。

参数

struct rio_mport *mport: 主端口。
dma_addr_t local: 要映射的内存区域的物理地址
u64 rbase: 分配给此窗口的 RIO 基地址
u32 size: 内存区域的大小
u32 rflags: 映射标志。

返回

0 -- 成功。

描述

此函数将创建从 RIO 空间到本地内存的映射。

void rio_unmap_inb_region(struct rio_mport *mport, dma_addr_t lstart)¶

取消映射入站内存区域

参数

struct rio_mport *mport: 主端口
dma_addr_t lstart: 要取消映射的内存区域的物理地址

int rio_map_outb_region(struct rio_mport *mport, u16 destid, u64 rbase, u32 size, u32 rflags, dma_addr_t *local)¶

映射出站内存区域。

参数

struct rio_mport *mport: 主端口。
u16 destid: 窗口指向的目标 ID
u64 rbase: 窗口转换到的 RIO 基地址
u32 size: 内存区域的大小
u32 rflags: 映射标志。
dma_addr_t *local: 映射的内存区域的物理地址

返回

0 -- 成功。

描述

此函数将创建从 RIO 空间到本地内存的映射。

void rio_unmap_outb_region(struct rio_mport *mport, u16 destid, u64 rstart)¶

取消映射入站内存区域

参数

struct rio_mport *mport: 主端口
u16 destid: 映射指向的目标 ID
u64 rstart: 窗口转换到的 RIO 基地址

u32 rio_mport_get_physefb(struct rio_mport *port, int local, u16 destid, u8 hopcount, u32 *rmap)¶: 辅助函数，返回物理层扩展特性块的寄存器偏移量。

参数

struct rio_mport *port: 发出事务的主端口
int local: 指示本地主端口或远程设备访问
u16 destid: 设备的目标 ID
u8 hopcount: 到设备的中转站数
u32 *rmap: 用于存储寄存器映射类型信息的指针位置

struct rio_dev *rio_get_comptag(u32 comp_tag, struct rio_dev *from)¶: 开始或继续按组件标记搜索 RIO 设备

参数

u32 comp_tag: 要匹配的 RIO 组件标记
struct rio_dev *from: 搜索中找到的先前的 RIO 设备，对于新搜索，为 NULL

描述

迭代已知的 RIO 设备列表。如果找到具有匹配 comp_tag 的 RIO 设备，则返回指向其设备结构的指针。否则，返回 NULL。通过将 NULL 传递给 from 参数来启动新搜索。否则，如果 from 不为 NULL，则从全局列表中的下一个设备继续搜索。

int rio_set_port_lockout(struct rio_dev *rdev, u32 pnum, int lock)¶: 为交换机端口设置/清除 LOCKOUT 位 (RIO EM 1.3)。

参数

struct rio_dev *rdev: 指向 RIO 设备控制结构的指针
u32 pnum: 要设置 LOCKOUT 位的交换机端口号
int lock: 操作：设置 (=1) 或清除 (=0)

int rio_enable_rx_tx_port(struct rio_mport *port, int local, u16 destid, u8 hopcount, u8 port_num)¶: 启用给定端口的输入接收器和输出发送器

参数

struct rio_mport *port: 与 RIO 网络关联的主端口
int local: local=1 选择本地端口，否则访问的是远端设备
u16 destid: 要检查主机位的设备的目标 ID
u8 hopcount: 到达目标的跳数
u8 port_num: 要在远端设备上启用的端口（交换机上的端口号）

描述

从通用控制命令和状态寄存器 (EXT_PTR+0x3C) 返回 0 或 1

int rio_mport_chk_dev_access(struct rio_mport *mport, u16 destid, u8 hopcount)¶: 验证对指定设备的访问。

参数

struct rio_mport *mport: 用于发送事务的主端口
u16 destid: 网络中的设备目标 ID
u8 hopcount: 进入网络的跳数

int rio_inb_pwrite_handler(struct rio_mport *mport, union rio_pw_msg *pw_msg)¶: 入站端口写入消息处理程序

参数

struct rio_mport *mport: 与端口写入关联的 mport 设备
union rio_pw_msg *pw_msg: 指向入站端口写入消息的指针

描述

处理入站端口写入消息。如果请求已满足，则返回 0。

u32 rio_mport_get_efb(struct rio_mport *port, int local, u16 destid, u8 hopcount, u32 from)¶: 获取指向下一个扩展功能块的指针

参数

struct rio_mport *port: 发出事务的主端口
int local: 指示本地主端口或远程设备访问
u16 destid: 设备的目标 ID
u8 hopcount: 到设备的中转站数
u32 from: 当前扩展功能块头的偏移量（如果为 0，则从 ExtFeaturePtr 开始）

u32 rio_mport_get_feature(struct rio_mport *port, int local, u16 destid, u8 hopcount, int ftr)¶: 查询设备的扩展功能

参数

struct rio_mport * port: 发出事务的主端口
int local: 指示本地主端口或远程设备访问
u16 destid: 设备的目标 ID
u8 hopcount: 到设备的中转站数
int ftr: 扩展功能代码

描述

判断设备是否支持给定的 RapidIO 功能。返回请求的扩展功能块在设备的 RIO 配置空间中的偏移量，或者如果设备不支持该功能，则返回 0。

int rio_lock_device(struct rio_mport *port, u16 destid, u8 hopcount, int wait_ms)¶: 获取指定设备的主机设备锁

参数

struct rio_mport *port: 用于发送事务的主端口
u16 destid: 设备/交换机的目标 ID
u8 hopcount: 到达交换机的跳数
int wait_ms: 最大等待时间，单位为毫秒（0 = 无超时）

描述

尝试获取指定主机设备的锁。如果设备锁已获取，则返回 0，如果超时到期，则返回 EINVAL。

int rio_unlock_device(struct rio_mport *port, u16 destid, u8 hopcount)¶: 释放指定设备的主机设备锁

参数

struct rio_mport *port: 用于发送事务的主端口
u16 destid: 设备/交换机的目标 ID
u8 hopcount: 到达交换机的跳数

描述

如果设备锁已释放，则返回 0；如果失败，则返回 EINVAL。

int rio_route_add_entry(struct rio_dev *rdev, u16 table, u16 route_destid, u8 route_port, int lock)¶: 向交换机路由表中添加路由条目

参数

struct rio_dev *rdev: RIO 设备
u16 table: 路由表 ID
u16 route_destid: 要路由的目标 ID
u8 route_port: 要路由的端口号
int lock: 在交换机设备标志上应用硬件锁（1=锁定，0=未锁定）

描述

如果可用，则调用特定于交换机的 add_entry() 方法，以将路由条目添加到交换机路由表中。否则，使用 RapidIO 规范定义的标准 RT 更新方法。如果交换机具有每个端口的路由表，则可以使用 table 参数选择特定的路由表，或者可以通过在 table 中传递 RIO_GLOBAL_TABLE 来使用标准（或全局）表。

成功时返回 0，失败时返回 -EINVAL。

int rio_route_get_entry(struct rio_dev *rdev, u16 table, u16 route_destid, u8 *route_port, int lock)¶: 从交换机路由表中读取条目

参数

struct rio_dev *rdev: RIO 设备
u16 table: 路由表 ID
u16 route_destid: 要路由的目标 ID
u8 *route_port: 指向要读取的端口号的指针
int lock: 在交换机设备标志上应用硬件锁（1=锁定，0=未锁定）

描述

如果可用，则调用特定于交换机的 get_entry() 方法，以从交换机路由表中获取路由条目。否则，使用 RapidIO 规范定义的标准 RT 读取方法。如果交换机具有每个端口的路由表，则可以使用 table 参数选择特定的路由表，或者可以通过在 table 中传递 RIO_GLOBAL_TABLE 来使用标准（或全局）表。

成功时返回 0，失败时返回 -EINVAL。

int rio_route_clr_table(struct rio_dev *rdev, u16 table, int lock)¶: 清除交换机路由表

参数

struct rio_dev *rdev: RIO 设备
u16 table: 路由表 ID
int lock: 在交换机设备标志上应用硬件锁（1=锁定，0=未锁定）

描述

如果可用，则调用特定于交换机的 clr_table() 方法来清除交换机路由表。否则，使用 RapidIO 规范定义的标准 RT 写入方法。如果交换机具有每个端口的路由表，则可以使用 table 参数选择特定的路由表，或者可以通过在 table 中传递 RIO_GLOBAL_TABLE 来使用标准（或全局）表。

成功时返回 0，失败时返回 -EINVAL。

struct dma_chan *rio_request_mport_dma(struct rio_mport *mport)¶: 请求与指定的本地 RapidIO mport 设备关联的、支持 RapidIO 的 DMA 通道。

参数

struct rio_mport *mport: 用于执行 DMA 数据传输的 RIO mport

描述

返回指向已分配 DMA 通道的指针，如果失败，则返回 NULL。

void rio_release_dma(struct dma_chan *dchan)¶: 释放指定的 DMA 通道

参数

struct dma_chan *dchan: 要释放的 DMA 通道

struct dma_async_tx_descriptor *rio_dma_prep_xfer(struct dma_chan *dchan, u16 destid, struct rio_dma_data *data, enum dma_transfer_direction direction, unsigned long flags)¶: 用于 DMAENGINE 定义的 device_prep_slave_sg 回调的 RapidIO 特定包装器。

参数

struct dma_chan *dchan: 要配置的 DMA 通道
u16 destid: 目标 RapidIO 设备目标 ID
struct rio_dma_data *data: RIO 特定数据描述符
enum dma_transfer_direction direction: DMA 数据传输方向（TO 或 FROM 设备）
unsigned long flags: dmaengine 定义的标志

描述

初始化支持 RapidIO 的 DMA 通道，用于指定的数据传输。使用 DMA 通道私有扩展来传递与远程目标 RIO 设备相关的信息。

返回

如果成功，则返回指向 DMA 事务描述符的指针，: 如果失败，则返回错误值指针或 NULL。

int rio_register_scan(int mport_id, struct rio_scan *scan_ops)¶: 枚举/发现方法注册接口

参数

int mport_id: 要为其设置结构扫描例程的 mport 设备 ID (RIO_MPORT_ANY = 为所有可用的 mport 设置)
struct rio_scan *scan_ops: 枚举/发现操作结构

描述

使用 RapidIO 子系统注册枚举/发现操作，并将其附加到指定的 mport 设备（如果指定了 RIO_MPORT_ANY，则附加到所有可用的 mport）。

如果 mport 已经附加了一个枚举器，则返回错误。对于 RIO_MPORT_ANY，跳过具有有效扫描例程的 mport（无错误）。

内部¶

本章包含 RapidIO 子系统的自动生成的文档。

结构体¶

struct rio_switch¶: RIO 交换机信息

定义:

struct rio_switch {
    struct list_head node;
    u8 *route_table;
    u32 port_ok;
    struct rio_switch_ops *ops;
    spinlock_t lock;
    struct rio_dev *nextdev[];
};

成员

node: 全局交换机列表中的节点
route_table: 交换机路由表的副本
port_ok: 每个端口的状态（每个端口一位） - OK=1 或 UNINIT=0
ops: 指向交换机特定操作的指针
lock: 用于序列化操作更新的锁
nextdev: 指向下一个附加设备的每个端口指针的数组

struct rio_switch_ops¶: 每个交换机的操作

定义:

struct rio_switch_ops {
    struct module *owner;
    int (*add_entry) (struct rio_mport *mport, u16 destid, u8 hopcount, u16 table, u16 route_destid, u8 route_port);
    int (*get_entry) (struct rio_mport *mport, u16 destid, u8 hopcount, u16 table, u16 route_destid, u8 *route_port);
    int (*clr_table) (struct rio_mport *mport, u16 destid, u8 hopcount, u16 table);
    int (*set_domain) (struct rio_mport *mport, u16 destid, u8 hopcount, u8 sw_domain);
    int (*get_domain) (struct rio_mport *mport, u16 destid, u8 hopcount, u8 *sw_domain);
    int (*em_init) (struct rio_dev *dev);
    int (*em_handle) (struct rio_dev *dev, u8 swport);
};

成员

owner: 此结构的模块所有者
add_entry: 用于交换机特定路由添加函数的回调
get_entry: 用于交换机特定路由获取函数的回调
clr_table: 用于交换机特定清除路由表函数的回调
set_domain: 用于交换机特定域设置函数的回调
get_domain: 用于交换机特定域获取函数的回调
em_init: 用于交换机特定错误管理初始化函数的回调
em_handle: 用于交换机特定错误管理处理程序函数的回调

描述

定义初始化/控制特定 RIO 交换机设备所需的操作。

struct rio_dev¶: RIO 设备信息

定义:

struct rio_dev {
    struct list_head global_list;
    struct list_head net_list;
    struct rio_net *net;
    bool do_enum;
    u16 did;
    u16 vid;
    u32 device_rev;
    u16 asm_did;
    u16 asm_vid;
    u16 asm_rev;
    u16 efptr;
    u32 pef;
    u32 swpinfo;
    u32 src_ops;
    u32 dst_ops;
    u32 comp_tag;
    u32 phys_efptr;
    u32 phys_rmap;
    u32 em_efptr;
    u64 dma_mask;
    struct rio_driver *driver;
    struct device dev;
    struct resource riores[RIO_MAX_DEV_RESOURCES];
    int (*pwcback) (struct rio_dev *rdev, union rio_pw_msg *msg, int step);
    u16 destid;
    u8 hopcount;
    struct rio_dev *prev;
    atomic_t state;
    struct rio_switch rswitch[];
};

成员

global_list: 所有 RIO 设备列表中的节点
net_list: 网络中 RIO 设备列表中的节点
net: 此设备所属的网络
do_enum: 枚举标志
did: 设备 ID
vid: 供应商 ID
device_rev: 设备修订版
asm_did: 程序集设备 ID
asm_vid: 程序集供应商 ID
asm_rev: 程序集修订版
efptr: 扩展功能指针
pef: 处理元件功能
swpinfo: 交换机端口信息
src_ops: 源操作功能
dst_ops: 目标操作功能
comp_tag: RIO 组件标记
phys_efptr: RIO 设备扩展功能指针
phys_rmap: LP-Serial 寄存器映射类型（1 或 2）
em_efptr: RIO 错误管理功能指针
dma_mask: 此设备实现的 RIO 地址的位掩码
driver: 声明此设备的驱动程序
dev: 设备模型设备
riores: RIO 资源，此设备拥有
pwcback: 此设备的端口写入回调函数
destid: 网络目标 ID（或交换机的关联 destid）
hopcount: 到此设备的跳数
prev: 连接到当前 RIO 设备的上一个 RIO 设备
state: 设备状态
rswitch: struct rio_switch (如果对该设备有效)

struct rio_msg¶: RIO 消息事件

定义:

struct rio_msg {
    struct resource *res;
    void (*mcback) (struct rio_mport * mport, void *dev_id, int mbox, int slot);
};

成员

res: 邮箱资源
mcback: 消息事件回调

struct rio_dbell¶: RIO 门铃事件

定义:

struct rio_dbell {
    struct list_head node;
    struct resource *res;
    void (*dinb) (struct rio_mport *mport, void *dev_id, u16 src, u16 dst, u16 info);
    void *dev_id;
};

成员

node: 门铃事件列表中的节点
res: 门铃资源
dinb: 门铃事件回调
dev_id: 设备特定的指针，用于传递事件

struct rio_mport¶: RIO 主端口信息

定义:

struct rio_mport {
    struct list_head dbells;
    struct list_head pwrites;
    struct list_head node;
    struct list_head nnode;
    struct rio_net *net;
    struct mutex lock;
    struct resource iores;
    struct resource riores[RIO_MAX_MPORT_RESOURCES];
    struct rio_msg inb_msg[RIO_MAX_MBOX];
    struct rio_msg outb_msg[RIO_MAX_MBOX];
    int host_deviceid;
    struct rio_ops *ops;
    unsigned char id;
    unsigned char index;
    unsigned int sys_size;
    u32 phys_efptr;
    u32 phys_rmap;
    unsigned char name[RIO_MAX_MPORT_NAME];
    struct device dev;
    void *priv;
#ifdef CONFIG_RAPIDIO_DMA_ENGINE;
    struct dma_device       dma;
#endif;
    struct rio_scan *nscan;
    atomic_t state;
    unsigned int pwe_refcnt;
};

成员

dbells: 门铃事件列表
pwrites: 端口写入事件列表
node: 全局主端口列表中的节点
nnode: 网络主端口列表中的节点
net: 此 mport 连接到的 RIO 网络
lock: 用于同步列表操作的锁
iores: 此主端口接口拥有的 I/O 内存资源
riores: 此主端口接口拥有的 RIO 资源
inb_msg: RIO 入站消息事件描述符
outb_msg: RIO 出站消息事件描述符
host_deviceid: 与此主端口关联的主机设备 ID
ops: 配置空间功能
id: 端口 ID，在所有端口中都是唯一的
index: 端口索引，在相同类型的所有端口接口中都是唯一的
sys_size: RapidIO 通用传输系统大小
phys_efptr: RIO 端口扩展功能指针
phys_rmap: LP-Serial EFB 寄存器映射类型（1 或 2）。
name: 端口名称字符串
dev: 与 mport 关联的设备结构
priv: 主端口私有数据
dma: 与 mport 关联的 DMA 设备
nscan: RapidIO 网络枚举/发现操作
state: mport 设备状态
pwe_refcnt: 端口写入使能引用计数器，用于跟踪使能/禁用请求

struct rio_net¶: RIO 网络信息

定义:

struct rio_net {
    struct list_head node;
    struct list_head devices;
    struct list_head switches;
    struct list_head mports;
    struct rio_mport *hport;
    unsigned char id;
    struct device dev;
    void *enum_data;
    void (*release)(struct rio_net *net);
};

成员

node: RIO 网络全局列表中的节点
devices: 此网络中的设备列表
switches: 此网络中的交换机列表
mports: 访问此网络的主端口列表
hport: 用于访问此网络的默认端口
id: RIO 网络 ID
dev: 设备对象
enum_data: 特定于网络枚举器的私有数据
release: 枚举器特定的释放回调

struct rio_mport_attr¶: RIO mport 设备属性

定义:

struct rio_mport_attr {
    int flags;
    int link_speed;
    int link_width;
    int dma_max_sge;
    int dma_max_size;
    int dma_align;
};

成员

flags: mport 设备能力标志
link_speed: SRIO 链接速度值（由 RapidIO 规范定义）
link_width: SRIO 链接宽度值（由 RapidIO 规范定义）
dma_max_sge: DMA 通道可以处理的 SG 列表条目的数量
dma_max_size: 单个 DMA 传输（SG 条目）中的最大字节数
dma_align: DMA 操作的对齐偏移量（与其他 DMA 操作一样）

struct rio_ops¶: 底层 RIO 配置空间操作

定义:

struct rio_ops {
    int (*lcread) (struct rio_mport *mport, int index, u32 offset, int len, u32 *data);
    int (*lcwrite) (struct rio_mport *mport, int index, u32 offset, int len, u32 data);
    int (*cread) (struct rio_mport *mport, int index, u16 destid, u8 hopcount, u32 offset, int len, u32 *data);
    int (*cwrite) (struct rio_mport *mport, int index, u16 destid, u8 hopcount, u32 offset, int len, u32 data);
    int (*dsend) (struct rio_mport *mport, int index, u16 destid, u16 data);
    int (*pwenable) (struct rio_mport *mport, int enable);
    int (*open_outb_mbox)(struct rio_mport *mport, void *dev_id, int mbox, int entries);
    void (*close_outb_mbox)(struct rio_mport *mport, int mbox);
    int (*open_inb_mbox)(struct rio_mport *mport, void *dev_id, int mbox, int entries);
    void (*close_inb_mbox)(struct rio_mport *mport, int mbox);
    int (*add_outb_message)(struct rio_mport *mport, struct rio_dev *rdev, int mbox, void *buffer, size_t len);
    int (*add_inb_buffer)(struct rio_mport *mport, int mbox, void *buf);
    void *(*get_inb_message)(struct rio_mport *mport, int mbox);
    int (*map_inb)(struct rio_mport *mport, dma_addr_t lstart, u64 rstart, u64 size, u32 flags);
    void (*unmap_inb)(struct rio_mport *mport, dma_addr_t lstart);
    int (*query_mport)(struct rio_mport *mport, struct rio_mport_attr *attr);
    int (*map_outb)(struct rio_mport *mport, u16 destid, u64 rstart, u32 size, u32 flags, dma_addr_t *laddr);
    void (*unmap_outb)(struct rio_mport *mport, u16 destid, u64 rstart);
};

成员

lcread: 执行配置空间的本地（主端口）读取的回调。
lcwrite: 执行配置空间的本地（主端口）写入的回调。
cread: 执行配置空间的网络读取的回调。
cwrite: 执行配置空间的网络写入的回调。
dsend: 发送门铃消息的回调。
pwenable: 启用/禁用端口写入消息处理的回调。
open_outb_mbox: 初始化出站邮箱的回调。
close_outb_mbox: 关闭出站邮箱的回调。
open_inb_mbox: 初始化入站邮箱的回调。
close_inb_mbox: 关闭入站邮箱的回调。
add_outb_message: 将消息添加到出站邮箱队列的回调。
add_inb_buffer: 将缓冲区添加到入站邮箱队列的回调。
get_inb_message: 从入站邮箱队列获取消息的回调。
map_inb: 将 RapidIO 地址区域映射到本地内存空间的回调。
unmap_inb: 取消映射使用 map_inb() 映射的 RapidIO 地址区域的回调。
query_mport: 查询 mport 设备属性的回调。
map_outb: 将出站地址区域映射到本地内存空间的回调。
unmap_outb: 取消映射出站 RapidIO 地址区域的回调。

struct rio_driver¶: RIO 驱动程序信息

定义:

struct rio_driver {
    struct list_head node;
    char *name;
    const struct rio_device_id *id_table;
    int (*probe) (struct rio_dev * dev, const struct rio_device_id * id);
    void (*remove) (struct rio_dev * dev);
    void (*shutdown)(struct rio_dev *dev);
    int (*suspend) (struct rio_dev * dev, u32 state);
    int (*resume) (struct rio_dev * dev);
    int (*enable_wake) (struct rio_dev * dev, u32 state, int enable);
    struct device_driver driver;
};

成员

node: 驱动程序列表中的节点
name: RIO 驱动程序名称
id_table: 要与此驱动程序关联的 RIO 设备 ID
probe: RIO 设备已插入
remove: RIO 设备已移除
shutdown: 关闭通知回调
suspend: RIO 设备已挂起
resume: RIO 设备已唤醒
enable_wake: RIO 设备启用唤醒事件
driver: LDM 驱动程序结构

描述

提供有关 RIO 设备驱动程序的信息，用于插入/移除和电源管理。

struct rio_scan¶: RIO 枚举和发现操作

定义:

struct rio_scan {
    struct module *owner;
    int (*enumerate)(struct rio_mport *mport, u32 flags);
    int (*discover)(struct rio_mport *mport, u32 flags);
};

成员

owner: 此结构的模块所有者
enumerate: 执行 RapidIO 结构枚举的回调。
discover: 执行 RapidIO 结构发现的回调。

struct rio_scan_node¶: 列表节点，用于向 RapidIO 内核注册 RapidIO 枚举和发现方法。

定义:

struct rio_scan_node {
    int mport_id;
    struct list_head node;
    struct rio_scan *ops;
};

成员

mport_id: 此枚举器服务的 mport（网络）的 ID
node: 注册枚举器的全局列表中的节点
ops: RIO 枚举和发现操作

枚举和发现¶

u16 rio_destid_alloc(struct rio_net *net)¶: 为给定网络分配下一个可用的 destID

参数

struct rio_net *net: RIO 网络

描述

返回指定 RIO 网络的下一个可用设备目标 ID。将分配的 ID 标记为正在使用。如果没有可用的新 destID，则返回 RIO_INVALID_DESTID。

int rio_destid_reserve(struct rio_net *net, u16 destid)¶: 保留指定 destID

参数

struct rio_net *net: RIO 网络
u16 destid: 要保留的 destID

描述

尝试保留指定的 destID。如果成功，则返回 0。

void rio_destid_free(struct rio_net *net, u16 destid)¶: 释放先前分配的 destID

参数

struct rio_net *net: RIO 网络
u16 destid: 要释放的 destID

描述

使指定的 destID 可供使用。

u16 rio_destid_first(struct rio_net *net)¶: 返回正在使用的第一个 destID

参数

struct rio_net *net: RIO 网络

u16 rio_destid_next(struct rio_net *net, u16 from)¶: 返回正在使用的下一个 destID

参数

struct rio_net *net: RIO 网络
u16 from: 搜索将从其继续的目标 ID

u16 rio_get_device_id(struct rio_mport *port, u16 destid, u8 hopcount)¶: 获取设备的基本/扩展设备 ID

参数

struct rio_mport *port: RIO 主端口
u16 destid: 设备的目标 ID
u8 hopcount: 到设备的跳数

描述

从设备读取基本/扩展设备 ID。返回 8/16 位设备 ID。

void rio_set_device_id(struct rio_mport *port, u16 destid, u8 hopcount, u16 did)¶: 设置设备的基本/扩展设备 ID

参数

struct rio_mport *port: RIO 主端口
u16 destid: 设备的目标 ID
u8 hopcount: 到设备的跳数
u16 did: 要写入的设备 ID 值

描述

从设备写入基本/扩展设备 ID。

int rio_clear_locks(struct rio_net *net)¶: 释放所有主机锁并指示枚举完成

参数

struct rio_net *net: 要在其上运行的 RIO 网络

描述

使用枚举完成标志标记每个设备上的组件标记 CSR。完成后，它将释放每个设备上的主机锁。成功时返回 0，失败时返回 -EINVAL。

int rio_enum_host(struct rio_mport *port)¶: 设置主机锁并初始化主机目标 ID

参数

struct rio_mport *port: 发出事务的主端口

描述

使用主机设备 ID 值设置本地主机主端口锁和目标 ID 寄存器。主机设备 ID 值由平台提供。成功时返回 0，失败时返回 -1。

int rio_device_has_destid(struct rio_mport *port, int src_ops, int dst_ops)¶: 测试设备是否包含目标 ID 寄存器

参数

struct rio_mport *port: 发出事务的主端口
int src_ops: RIO 设备源操作
int dst_ops: RIO 设备目标操作

描述

检查提供的 src_ops 和 dst_ops 是否具有必要的事务能力，这些能力指示设备是否将实现目标 ID 寄存器。如果为真，则返回 1，如果为假，则返回 0。

void rio_release_dev(struct device *dev)¶: 释放 RIO 设备结构

参数

struct device *dev: 与 RIO 设备结构关联的 LDM 设备

描述

获取与 RIO 设备结构关联的 RIO 设备结构。 RIO 设备结构将被释放。

int rio_is_switch(struct rio_dev *rdev)¶: 测试 RIO 设备是否具有交换机功能

参数

struct rio_dev *rdev: RIO 设备

描述

获取 RIO 设备处理元素功能寄存器的内容并测试交换机功能。如果设备是交换机，则返回 1，如果不是交换机，则返回 0。 RIO 设备结构将被释放。

struct rio_dev *rio_setup_device(struct rio_net *net, struct rio_mport *port, u16 destid, u8 hopcount, int do_enum)¶: 分配并设置 RIO 设备

参数

struct rio_net *net: RIO 网络
struct rio_mport *port: 用于发送事务的主端口
u16 destid: 当前目标 ID
u8 hopcount: 当前跳数
int do_enum: 枚举/发现模式标志

描述

分配 RIO 设备并根据配置空间内容配置字段。如果设备具有目标 ID 寄存器，则在枚举模式下分配目标 ID，或在发现模式下从配置空间读取目标 ID。如果设备具有交换机功能，则会分配交换机并进行适当配置。成功时返回指向 RIO 设备的指针，失败时返回 NULL。

int rio_sport_is_active(struct rio_dev *rdev, int sp)¶: 测试交换端口是否处于活动连接状态。

参数

struct rio_dev *rdev: RapidIO设备对象
int sp: 交换端口号

描述

读取特定交换端口的端口错误状态CSR，以确定该端口是否具有活动链接。如果端口处于活动状态，则返回 RIO_PORT_N_ERR_STS_PORT_OK，如果端口处于非活动状态，则返回 0。

u16 rio_get_host_deviceid_lock(struct rio_mport *port, u8 hopcount)¶: 读取设备上的主机设备ID锁定CSR

参数

struct rio_mport *port: 用于发送事务的主端口
u8 hopcount: 到设备的跳数

描述

用于枚举期间读取RIO设备上的主机设备ID锁定CSR。返回锁定寄存器的值。

int rio_enum_peer(struct rio_net *net, struct rio_mport *port, u8 hopcount, struct rio_dev *prev, int prev_port)¶: 通过主端口递归枚举RIO网络

参数

struct rio_net *net: 正在枚举的RIO网络
struct rio_mport *port: 用于发送事务的主端口
u8 hopcount: 进入网络的跳数
struct rio_dev *prev: 连接到枚举对象的先前RIO设备
int prev_port: 先前RIO设备上的端口

描述

递归枚举RIO网络。事务通过传入的 **port** 中的主端口发送。

int rio_enum_complete(struct rio_mport *port)¶: 测试网络的枚举是否完成

参数

struct rio_mport *port: 用于发送事务的主端口

描述

测试PGCCSR发现位是否为非零值（枚举完成标志）。如果枚举完成，则返回 1，如果枚举未完成，则返回 0。

int rio_disc_peer(struct rio_net *net, struct rio_mport *port, u16 destid, u8 hopcount, struct rio_dev *prev, int prev_port)¶: 通过主端口递归发现RIO网络

参数

struct rio_net *net: 正在发现的RIO网络
struct rio_mport *port: 用于发送事务的主端口
u16 destid: 网络中的当前目标ID
u8 hopcount: 进入网络的跳数
struct rio_dev *prev: 先前的rio_dev
int prev_port: 先前的端口号

描述

递归发现RIO网络。事务通过传入的 **port** 中的主端口发送。

int rio_mport_is_active(struct rio_mport *port)¶: 测试主端口链路是否处于活动状态

参数

struct rio_mport *port: 要测试的主端口

描述

读取主端口的端口错误状态CSR，以确定该端口是否具有活动链接。如果主端口处于活动状态，则返回 RIO_PORT_N_ERR_STS_PORT_OK，如果主端口处于非活动状态，则返回 0。

void rio_update_route_tables(struct rio_net *net)¶: 更新交换机中的路由表

参数

struct rio_net *net: 要运行更新的RIO网络

描述

对于每个枚举的设备，请确保系统中的每个交换机都具有正确的路由条目。为在第一次枚举过程中交换机未知设备添加路由。

void rio_init_em(struct rio_dev *rdev)¶: 初始化RIO错误管理（对于交换机）

参数

struct rio_dev *rdev: RIO 设备

描述

对于每个枚举的交换机，调用设备特定的错误管理初始化例程（如果由交换机驱动程序提供）。

int rio_enum_mport(struct rio_mport *mport, u32 flags)¶: 通过主端口启动枚举

参数

struct rio_mport *mport: 用于发送事务的主端口
u32 flags: 枚举控制标志

描述

启动枚举过程。如果有人已经枚举了我们的主端口设备，则放弃。如果没有且我们有一个活动的链接，则启动递归对等枚举。如果枚举成功，则返回 0，如果枚举失败，则返回 -EBUSY。

void rio_build_route_tables(struct rio_net *net)¶: 从交换机路由条目生成路由表

参数

struct rio_net *net: 要在其上运行路由表扫描的RIO网络

描述

对于每个交换机设备，通过从交换机复制现有路由条目来生成路由表。

int rio_disc_mport(struct rio_mport *mport, u32 flags)¶: 通过主端口启动发现

参数

struct rio_mport *mport: 用于发送事务的主端口
u32 flags: 发现控制标志

描述

启动发现过程。如果我们有一个活动的链接，则等待枚举完成的信号（如果允许等待）。当枚举完成发出信号时，启动递归对等发现。如果发现成功，则返回 0，如果失败，则返回 -EBUSY。

int rio_basic_attach(void)¶

参数

void: 无参数

描述

当此枚举/发现方法作为模块加载时，此函数会为所有可用的RapidIO mport设备注册其特定的枚举和发现例程。“scan”命令行参数控制模块自动启动RapidIO枚举/发现的能力。

成功返回0，如果无法注册则返回-EIO。

此枚举/发现方法无法卸载，因此不提供匹配的cleanup_module例程。

驱动程序功能¶

int rio_setup_inb_dbell(struct rio_mport *mport, void *dev_id, struct resource *res, void (*dinb)(struct rio_mport *mport, void *dev_id, u16 src, u16 dst, u16 info))¶: 绑定入站门铃回调

参数

struct rio_mport *mport: 要绑定门铃回调的RIO主端口
void *dev_id: 设备特定的指针，用于传递事件
struct resource *res: 门铃消息资源
void (*dinb) (struct rio_mport * mport, void *dev_id, u16 src, u16 dst, u16 info): 接收到门铃时执行的回调函数

描述

将门铃资源/回调对添加到端口的门铃事件列表中。如果请求已满足，则返回0。

int rio_chk_dev_route(struct rio_dev *rdev, struct rio_dev **nrdev, int *npnum)¶: 验证到指定设备的路由。

参数

struct rio_dev *rdev: RIO设备未能响应
struct rio_dev **nrdev: 到rdev的路由上的最后一个活动设备
int *npnum: 到rdev的路由上nrdev的端口号

描述

遵循到指定RIO设备的路由，以确定路由上最后一个可用设备（以及相应的RIO端口）。

int rio_chk_dev_access(struct rio_dev *rdev)¶: 验证对指定设备的访问。

参数

struct rio_dev *rdev: 指向 RIO 设备控制结构的指针

int rio_get_input_status(struct rio_dev *rdev, int pnum, u32 *lnkresp)¶: 发送链接请求/输入状态控制符号，并返回链接响应（如果请求）。

参数

struct rio_dev *rdev: RIO devive发出输入状态命令
int pnum: 设备端口号以发出命令
u32 *lnkresp: 来自链接伙伴的响应

int rio_clr_err_stopped(struct rio_dev *rdev, u32 pnum, u32 err_status)¶: 清除端口错误停止状态。

参数

struct rio_dev *rdev: 指向 RIO 设备控制结构的指针
u32 pnum: 要清除错误的交换机端口号
u32 err_status: 端口错误状态（如果0从设备读取寄存器）

描述

TODO：当前，此例程与为idt_gen3 RapidIO交换机设备指定的恢复过程不兼容。必须对其进行审查以实现与所有可用设备兼容的通用恢复过程。 IDT gen3交换机驱动程序现在实现HW特定的错误处理程序，该处理程序向端口发出软端口重置以重置ERR_STOP位和ackID。

int rio_std_route_add_entry(struct rio_mport *mport, u16 destid, u8 hopcount, u16 table, u16 route_destid, u8 route_port)¶: 使用RIO规范修订版1.3中定义的标准寄存器添加交换机路由表条目

参数

struct rio_mport *mport: 发出事务的主端口
u16 destid: 设备的目标 ID
u8 hopcount: 到设备的中转站数
u16 table: 路由表ID（全局或端口特定）
u16 route_destid: RT中的destID条目
u8 route_port: 指定destID的目标端口

int rio_std_route_get_entry(struct rio_mport *mport, u16 destid, u8 hopcount, u16 table, u16 route_destid, u8 *route_port)¶: 读取与使用RIO规范修订版1.3中定义的标准寄存器指定的destID关联的交换机路由表条目（端口号）

参数

struct rio_mport *mport: 发出事务的主端口
u16 destid: 设备的目标 ID
u8 hopcount: 到设备的中转站数
u16 table: 路由表ID（全局或端口特定）
u16 route_destid: RT中的destID条目
u8 *route_port: 指定destID的返回目标端口

int rio_std_route_clr_table(struct rio_mport *mport, u16 destid, u8 hopcount, u16 table)¶: 使用 RIO 规范 rev.1.3 中定义的标准寄存器清除交换机路由表。

参数

struct rio_mport *mport: 发出事务的主端口
u16 destid: 设备的目标 ID
u8 hopcount: 到设备的中转站数
u16 table: 路由表ID（全局或端口特定）

int rio_mport_scan(int mport_id)¶: 在指定的 mport 上执行枚举/发现

参数

int mport_id: mport 设备的编号 (ID)

RIO_LOP_READ¶

RIO_LOP_READ (size, type, len)

生成 rio_local_read_config_* 函数

参数

大小: 配置空间读取的大小（8、16、32 位）
类型: value 参数的 C 类型
长度: 配置空间读取的长度（1、2、4 字节）

描述

生成用于访问本地设备上配置空间寄存器的 rio_local_read_config_* 函数。

RIO_LOP_WRITE¶

RIO_LOP_WRITE (size, type, len)

生成 rio_local_write_config_* 函数

参数

大小: 配置空间写入的大小（8、16、32 位）
类型: value 参数的 C 类型
长度: 配置空间写入的长度（1、2、4 字节）

描述

生成用于访问本地设备上配置空间寄存器的 rio_local_write_config_* 函数。

RIO_OP_READ¶

RIO_OP_READ (size, type, len)

生成 rio_mport_read_config_* 函数

参数

大小: 配置空间读取的大小（8、16、32 位）
类型: value 参数的 C 类型
长度: 配置空间读取的长度（1、2、4 字节）

描述

生成用于访问本地设备上配置空间寄存器的 rio_mport_read_config_* 函数。

RIO_OP_WRITE¶

RIO_OP_WRITE (size, type, len)

生成 rio_mport_write_config_* 函数

参数

大小: 配置空间写入的大小（8、16、32 位）
类型: value 参数的 C 类型
长度: 配置空间写入的长度（1、2、4 字节）

描述

生成用于访问本地设备上配置空间寄存器的 rio_mport_write_config_* 函数。

设备模型支持¶

const struct rio_device_id *rio_match_device(const struct rio_device_id *id, const struct rio_dev *rdev)¶: 判断 RIO 设备是否具有匹配的 RIO 设备 ID 结构体

参数

const struct rio_device_id *id

要匹配的 RIO 设备 ID 结构体

const struct rio_dev *rdev

要匹配的 RIO 设备结构体

从驱动程序探测和总线匹配中使用，以检查 RIO 设备是否匹配 RIO 驱动程序提供的设备 ID 结构体。如果存在匹配项，则返回匹配的 struct rio_device_id，如果没有匹配项，则返回 NULL。

int rio_device_probe(struct device *dev)¶: 判断 RIO 设备结构体是否具有匹配的 RIO 设备 ID 结构体

参数

struct device *dev: 要匹配的 RIO 设备结构体

描述

当 drv 声明 rio_dev 时，返回 0 并设置 rio_dev->driver，否则返回错误

void rio_device_remove(struct device *dev)¶: 从系统中移除 RIO 设备

参数

struct device *dev: 要匹配的 RIO 设备结构体

描述

从系统中移除 RIO 设备。如果它有关联的驱动程序，则运行驱动程序的 remove() 方法。然后更新引用计数。

int rio_match_bus(struct device *dev, const struct device_driver *drv)¶: 判断 RIO 设备结构体是否具有匹配的 RIO 驱动程序设备 ID 结构体

参数

struct device *dev

要匹配的标准设备结构体

const struct device_driver *drv

包含要匹配的 ID 的标准驱动程序结构体

由驱动程序使用，以检查系统中存在的 RIO 设备是否在其支持的设备列表中。如果存在匹配的 struct rio_device_id，则返回 1，如果没有匹配项，则返回 0。

int rio_bus_init(void)¶: 向设备模型注册 RapidIO 总线

参数

void: 无参数

描述

向 Linux 设备模型注册 RIO mport 设备类和 RIO 总线类型。

PPC32 支持¶

int fsl_local_config_read(struct rio_mport *mport, int index, u32 offset, int len, u32 *data)¶: 生成 MPC85xx 本地配置空间读取

参数

struct rio_mport *mport: RapidIO 主端口信息
int index: RapdiIO 接口的 ID
u32 offset: 配置空间的偏移量
int len: 维护事务的长度（以字节为单位）
u32 *data: 要读取到的值

描述

生成 MPC85xx 本地配置空间读取。成功时返回 0，失败时返回 -EINVAL。

int fsl_local_config_write(struct rio_mport *mport, int index, u32 offset, int len, u32 data)¶: 生成 MPC85xx 本地配置空间写入

参数

struct rio_mport *mport: RapidIO 主端口信息
int index: RapdiIO 接口的 ID
u32 offset: 配置空间的偏移量
int len: 维护事务的长度（以字节为单位）
u32 data: 要写入的值

描述

生成 MPC85xx 本地配置空间写入。成功时返回 0，失败时返回 -EINVAL。

int fsl_rio_config_read(struct rio_mport *mport, int index, u16 destid, u8 hopcount, u32 offset, int len, u32 *val)¶: 生成 MPC85xx 读取维护事务

参数

struct rio_mport *mport: RapidIO 主端口信息
int index: RapdiIO 接口的 ID
u16 destid: 事务的目标 ID
u8 hopcount: 到目标设备的跳数
u32 offset: 配置空间的偏移量
int len: 维护事务的长度（以字节为单位）
u32 *val: 要读取到的位置

描述

生成 MPC85xx 读取维护事务。成功时返回 0，失败时返回 -EINVAL。

int fsl_rio_config_write(struct rio_mport *mport, int index, u16 destid, u8 hopcount, u32 offset, int len, u32 val)¶: 生成 MPC85xx 写入维护事务

参数

struct rio_mport *mport: RapidIO 主端口信息
int index: RapdiIO 接口的 ID
u16 destid: 事务的目标 ID
u8 hopcount: 到目标设备的跳数
u32 offset: 配置空间的偏移量
int len: 维护事务的长度（以字节为单位）
u32 val: 要写入的值

描述

生成 MPC85xx 写入维护事务。成功时返回 0，失败时返回 -EINVAL。

int fsl_rio_setup(struct platform_device *dev)¶: 设置 Freescale PowerPC RapidIO 接口

参数

struct platform_device *dev: platform_device 指针

描述

初始化 MPC85xx RapidIO 硬件接口，使用系统特定的信息配置主端口，并将主端口注册到 RapidIO 子系统。

鸣谢¶

以下人员直接或间接地为 RapidIO 子系统做出了贡献

以下人员为本文档做出了贡献

Matt Portermporter@kernel.crashing.org

Linux 内核

目录

本页

RapidIO 子系统指南¶

简介¶

已知 Bug 和限制¶

Bug¶

限制¶

RapidIO 驱动接口¶

函数¶

内部¶

结构体¶

枚举和发现¶

驱动程序功能¶

设备模型支持¶

PPC32 支持¶

鸣谢¶