RapidIO 子系统指南¶

作者:: Matt Porter

简介¶

RapidIO 是一种高速交换结构互连，具有针对嵌入式市场的功能。RapidIO 提供对基于交换结构网络的内存映射 I/O 以及基于消息的事务的支持。RapidIO 具有类似于 PCI 总线标准的标准化发现机制，允许简单地检测网络中的设备。

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

已知错误和限制¶

错误¶

无。 ;)

限制¶

不支持 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: 从中获取设备 ID 的 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: RIO 主端口，用于绑定端口写入回调
void *context: 要传递到事件的特定于处理程序的上下文
int (*pwcback)(struct rio_mport *mport, void *context, union rio_pw_msg *msg, int step): 收到端口写入时执行的回调

描述

如果请求已满足，则返回 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: 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。

struct dma_chan *rio_request_dma(struct rio_dev *rdev)¶: 请求支持指定目标 RapidIO 设备的、支持 RapidIO 的 DMA 通道。

参数

struct rio_dev *rdev: 与 DMA 传输关联的 RIO 设备

描述

返回指向已分配的 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 数据传输方向（到设备或来自设备）
unsigned long flags: dmaengine 定义的标志

描述

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

返回

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

struct dma_async_tx_descriptor *rio_dma_prep_slave_sg(struct rio_dev *rdev, struct dma_chan *dchan, struct rio_dma_data *data, enum dma_transfer_direction direction, unsigned long flags)¶: DMAENGINE 定义的 device_prep_slave_sg 回调的 RapidIO 特定包装器。

参数

struct rio_dev *rdev: RIO 设备控制结构
struct dma_chan *dchan: 要配置的 DMA 通道
struct rio_dma_data *data: RIO 特定数据描述符
enum dma_transfer_direction direction: DMA 数据传输方向（到设备或来自设备）
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（没有错误）。

int rio_unregister_scan(int mport_id, struct rio_scan *scan_ops)¶: 从 mport 中删除枚举/发现方法

参数

int mport_id: 必须取消注册结构扫描例程的 mport 设备 ID（RIO_MPORT_ANY = 应用于所有使用指定 scan_ops 的 mport）
struct rio_scan *scan_ops: 枚举/发现操作结构

描述

删除分配给指定 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: Device model device
riores: 此设备拥有的 RIO 资源
pwcback: 此设备的端口写入回调函数
destid: 网络目标 ID（或交换机的相关 destid）
hopcount: 到此设备的跳数
prev: 连接到当前设备的上一个 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: Doorbell resource
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: 此主端口连接到的 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: 与主端口关联的设备结构
priv: 主端口私有数据
dma: 与主端口关联的 DMA 设备
nscan: RapidIO 网络枚举/发现操作
state: 主端口设备状态
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: Device object
enum_data: 特定于网络枚举器的私有数据
release: 特定于枚举器的释放回调

struct rio_mport_attr¶: RIO 主端口设备属性

定义:

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

成员

flags: 主端口设备功能标志
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: 查询主端口设备属性的回调。
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)¶: 返回下一个正在使用的目标ID

参数

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 寄存器。如果为 true，则返回 1，如果为 false，则返回 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: nrdev 在到 rdev 的路由上的端口号

描述

遵循到指定的 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 设备
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 交换机驱动程序现在实现了一个特定于硬件的错误处理程序，该处理程序会向端口发出软端口复位，以复位 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 规范 rev.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 规范 rev.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（全局或特定于端口）

struct rio_mport *rio_find_mport(int mport_id)¶: 按 ID 查找 RIO mport

参数

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

描述

给定一个 RIO mport 编号，所需的 mport 位于 mport 的全局列表中。如果找到 mport，则返回指向其数据结构的指针。如果未找到 mport，则返回 NULL。

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 位）
类型: 值参数的 C 类型
长度: 配置空间读取的长度（1、2、4 字节）

描述

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

RIO_LOP_WRITE¶

RIO_LOP_WRITE (size, type, len)

生成 rio_local_write_config_* 函数

参数

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

描述

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

RIO_OP_READ¶

RIO_OP_READ (size, type, len)

生成 rio_mport_read_config_* 函数

参数

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

描述

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

RIO_OP_WRITE¶

RIO_OP_WRITE (size, type, len)

生成 rio_mport_write_config_* 函数

参数

大小: 配置空间写入的大小（8、16、32 位）
类型: 值参数的 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 子系统指南¶

简介¶

已知错误和限制¶

错误¶

限制¶

RapidIO 驱动程序接口¶

函数¶

内部¶

结构¶

枚举和发现¶

驱动程序功能¶

设备模型支持¶

PPC32 支持¶

贡献者¶