Rpmsg与Virtio介绍

Rpmsg与Virtio介绍
一、Rpmsg的介绍
- 1、rpmsg_core.c的详细介绍
- - 1.1 rpmsg_bus结构体
  - 1.2 rpmsg_dev_match()函数
  - 1.3 rpmsg_dev_probe()函数
  - 1.4 rpmsg_register_device () 函数的介绍
  - 1.5 __register_rpmsg_driver() 函数的介绍
  - 1.6 rpmsg_create_ept、rpmsg_send、rpmsg_trysend、rpmsg_poll
- 2、rpmsg_char.c的详细介绍
- - 2.1 rpmsg_chrdev_driver结构体
  - 2.2 rpmsg_chrdev_probe()函数
  - 2.3 rpmsg_chrdev_remove()函数
二、virtio_rpmsg_bus.c 的详细介绍
- 1、virtio_ipc_driver 结构体的介绍
- 2、rpmsg_probe()函数的介绍
- 3、__rpmsg_create_ept()介绍
- 4、 virtio_endpoint_ops结构体介绍
- 5、rpmsg_ns_cb() 函数的介绍
- 6、rpmsg_create_channel() 函数的介绍
- 7、virtio_rpmsg_ops() 结构体的介绍
三、Virtio的介绍
- 1、virtio.c 的介绍
- - 1.1 virtio_bus结构体的介绍
  - 1.2 register_virtio_driver() 函数的介绍
  - 1.3 register_virtio_device() 函数的介绍
  - 1.4 virtio_dev_probe 函数的介绍
  - 1.5 virtio_dev_match 函数的介绍
- 2、virtio_input.c的介绍
- - 2.1 virtio_input_driver结构体介绍
四、virtio_device、virtio_driver、virtio_bus、rpmsg_device、rpmsg_drivver、rpmsg_bus如何如何联系且运作起来
- 1、联系的建立
- 2、运作

一、Rpmsg的介绍

源码所在路径：drivers\rpmsg\

KconfigMakefileqcom_glink_native.cqcom_glink_native.hqcom_glink_rpm.cqcom_glink_smem.cqcom_smd.crpmsg_char.crpmsg_core.crpmsg_internal.hvirtio_rpmsg_bus.c

结合官方所提供的rpmsg framwork框架图，我们可知：

Rpmsg的整体框架是Rpmsg Bus、Rpmsg Device与Rpmsg Driver所构成，即Linux中的Bus模型；

Rpmsg Bus：由rpmsg_core.c文件所构建，负责

bus的构建；
Driver-device的match；
device的probe与remove；
uevent机制；

static struct bus_type rpmsg_bus = {.name        = "rpmsg",.match     = rpmsg_dev_match,.dev_groups  = rpmsg_dev_groups,.uevent     = rpmsg_uevent,.probe      = rpmsg_dev_probe,.remove  = rpmsg_dev_remove,
};

Rpmsg Driver：由rpmsg_char.c所register（上图中还有两个文件，不在该章节进行介绍），负责：
1. register char driver；
2. Remove char driver；
3. 该driver name 为 rpmsg_chrdev；
```
static struct rpmsg_driver rpmsg_chrdev_driver = {.probe = rpmsg_chrdev_probe,.remove = rpmsg_chrdev_remove,.drv = {.name = "rpmsg_chrdev",},
};
```
Rpmsg Device：该层一开始是只有Virtio框架所构成的，后面添加了Glink与SMD架构（主要为高通所用），故主要介绍Virtio框架，通过上图可知其主要由virtio_rpmsg_bus.c 文件所维护：
1. 该文件比较特殊，其是Virtio BUS与Rpmsg Bus的连接层，该文件中定义了virtio driver;
```
static struct virtio_driver virtio_ipc_driver = {.feature_table  = features,.feature_table_size = ARRAY_SIZE(features),.driver.name    = KBUILD_MODNAME,.driver.owner = THIS_MODULE,.id_table    = id_table,.probe      = rpmsg_probe,.remove      = rpmsg_remove,
};
```
该virtio driver会向Rpmsg Bus register rpmsg device，这样一来Rpmsg Bus与Virtio Bus就通过该rpmsg device联系起来了。

1、rpmsg_core.c的详细介绍

1.1 rpmsg_bus结构体

结构体定义如下，可以看到该bus的名为rpmsg：

static struct bus_type rpmsg_bus = {.name       = "rpmsg",.match     = rpmsg_dev_match,.dev_groups  = rpmsg_dev_groups,.uevent     = rpmsg_uevent,.probe      = rpmsg_dev_probe,.remove  = rpmsg_dev_remove,
};

该结构体会在rpmsg_init()中调用bus_register函数：

完成bus_type_private的初始化、创建并注册的这条总线需要的目录，该目录为rpmsg；
在rpmsg目录下创建/device /driver 目录；
初始化这条总线上的设备链表：struct klist klist_devices;
初始化这条总线上的驱动链表：struct klist klist_drivers;

static int __init rpmsg_init(void)
{int ret;ret = bus_register(&rpmsg_bus);if (ret)pr_err("failed to register rpmsg bus: %d\n", ret);return ret;
}

而该rpmsg_init函数会在注册进postcore_initcall，这样当kernel起来时就会调用根据initcall的顺序调用到rpmsg_init，进而注册Rpmsg Bus，为其准备所需要的资源。

postcore_initcall(rpmsg_init);

1.2 rpmsg_dev_match()函数

问：在Bus中，如何调入到Rpmsg Bus的match函数呢

答：当有driver/device register是会触发Bus中的bus_add_driver/bus_add_device继而触发Bus–>match/probe函数。

在该match函数中，匹配顺序如下：

static int rpmsg_dev_match(struct device *dev, struct device_driver *drv)
{struct rpmsg_device *rpdev = to_rpmsg_device(dev);struct rpmsg_driver *rpdrv = to_rpmsg_driver(drv);const struct rpmsg_device_id *ids = rpdrv->id_table;unsigned int i;/* 针对特殊情况,dev中的driver_override被设置,则只匹配和driver_override名字相同的驱动程序 */if (rpdev->driver_override)return !strcmp(rpdev->driver_override, drv->name);/* 后根据dev->id.mane与driver id_table中每个name进行匹配 */if (ids)for (i = 0; ids[i].name[0]; i++)if (rpmsg_id_match(rpdev, &ids[i]))return 1;/* 最后以设备树进行匹配 */return of_driver_match_device(dev, drv);
}

1.3 rpmsg_dev_probe()函数

当Rpmsg Bus->match()成功后，则Bus会调用Rpmsg Bus->probe对driver与device进行bind

/** when an rpmsg driver is probed with a channel, we seamlessly create* it an endpoint, binding its rx callback to a unique local rpmsg* address.** if we need to, we also announce about this channel to the remote* processor (needed in case the driver is exposing an rpmsg service).*/
static int rpmsg_dev_probe(struct device *dev)
{struct rpmsg_device *rpdev = to_rpmsg_device(dev);struct rpmsg_driver *rpdrv = to_rpmsg_driver(rpdev->dev.driver);struct rpmsg_channel_info chinfo = {};struct rpmsg_endpoint *ept = NULL;int err;/* 电源管理相关 */err = dev_pm_domain_attach(dev, true);if (err)goto out;/* driver->callback存在会进行调用，但是rpmsg_char.c中的driver->callback == NULL* 此处可以客制化自己的driver*/if (rpdrv->callback) {/* 以device->id.name作为rpsmg_channel->name* channel的src为device->src*/strncpy(chinfo.name, rpdev->id.name, RPMSG_NAME_SIZE);chinfo.src = rpdev->src;chinfo.dst = RPMSG_ADDR_ANY;/* 会以回调的形式调用device->ops->create_ept，该ept->cb(rx_cb) =rpdrv->callback */ept = rpmsg_create_ept(rpdev, rpdrv->callback, NULL, chinfo);if (!ept) {dev_err(dev, "failed to create endpoint\n");err = -ENOMEM;goto out;}/* 把创建的ept和addr存储到device中 */rpdev->ept = ept;rpdev->src = ept->addr;}/* 调用driver->probe ==   rpmsg_chrdev_probe */err = rpdrv->probe(rpdev);if (err) {dev_err(dev, "%s: failed: %d\n", __func__, err);if (ept)rpmsg_destroy_ept(ept);goto out;}/* 调用device->ops->announce_create == virtio_rpmsg_announce_create */if (ept && rpdev->ops->announce_create)err = rpdev->ops->announce_create(rpdev);
out:return err;
}

1.4 rpmsg_register_device () 函数的介绍

int rpmsg_register_device(struct rpmsg_device *rpdev)
{struct device *dev = &rpdev->dev;int ret;dev_set_name(&rpdev->dev, "%s.%s.%d.%d", dev_name(dev->parent),rpdev->id.name, rpdev->src, rpdev->dst);rpdev->dev.bus = &rpmsg_bus;ret = device_register(&rpdev->dev);if (ret) {dev_err(dev, "device_register failed: %d\n", ret);put_device(&rpdev->dev);}return ret;
}
EXPORT_SYMBOL(rpmsg_register_device);

1.5 __register_rpmsg_driver() 函数的介绍

int __register_rpmsg_driver(struct rpmsg_driver *rpdrv, struct module *owner)
{rpdrv->drv.bus = &rpmsg_bus;rpdrv->drv.owner = owner;return driver_register(&rpdrv->drv);
}
EXPORT_SYMBOL(__register_rpmsg_driver);C

1.6 rpmsg_create_ept、rpmsg_send、rpmsg_trysend、rpmsg_poll

从函数实体可以看到，这些operation都是以回调的方式调用，所以进行客制化的实现；

struct rpmsg_endpoint *rpmsg_create_ept(struct rpmsg_device *rpdev,rpmsg_rx_cb_t cb, void *priv,struct rpmsg_channel_info chinfo)
{if (WARN_ON(!rpdev))return NULL;return rpdev->ops->create_ept(rpdev, cb, priv, chinfo);
}
EXPORT_SYMBOL(rpmsg_create_ept);/*** rpmsg_destroy_ept() - destroy an existing rpmsg endpoint* @ept: endpoing to destroy** Should be used by drivers to destroy an rpmsg endpoint previously* created with rpmsg_create_ept(). As with other types of "free" NULL* is a valid parameter.*/
void rpmsg_destroy_ept(struct rpmsg_endpoint *ept)
{if (ept)ept->ops->destroy_ept(ept);
}
EXPORT_SYMBOL(rpmsg_destroy_ept);/*** rpmsg_send() - send a message across to the remote processor* @ept: the rpmsg endpoint* @data: payload of message* @len: length of payload** This function sends @data of length @len on the @ept endpoint.* The message will be sent to the remote processor which the @ept* endpoint belongs to, using @ept's address and its associated rpmsg* device destination addresses.* In case there are no TX buffers available, the function will block until* one becomes available, or a timeout of 15 seconds elapses. When the latter* happens, -ERESTARTSYS is returned.** Can only be called from process context (for now).** Returns 0 on success and an appropriate error value on failure.*/
int rpmsg_send(struct rpmsg_endpoint *ept, void *data, int len)
{if (WARN_ON(!ept))return -EINVAL;if (!ept->ops->send)return -ENXIO;return ept->ops->send(ept, data, len);
}
EXPORT_SYMBOL(rpmsg_send);/*** rpmsg_sendto() - send a message across to the remote processor, specify dst* @ept: the rpmsg endpoint* @data: payload of message* @len: length of payload* @dst: destination address** This function sends @data of length @len to the remote @dst address.* The message will be sent to the remote processor which the @ept* endpoint belongs to, using @ept's address as source.* In case there are no TX buffers available, the function will block until* one becomes available, or a timeout of 15 seconds elapses. When the latter* happens, -ERESTARTSYS is returned.** Can only be called from process context (for now).** Returns 0 on success and an appropriate error value on failure.*/
int rpmsg_sendto(struct rpmsg_endpoint *ept, void *data, int len, u32 dst)
{if (WARN_ON(!ept))return -EINVAL;if (!ept->ops->sendto)return -ENXIO;return ept->ops->sendto(ept, data, len, dst);
}
EXPORT_SYMBOL(rpmsg_sendto);/*** rpmsg_send_offchannel() - send a message using explicit src/dst addresses* @ept: the rpmsg endpoint* @src: source address* @dst: destination address* @data: payload of message* @len: length of payload** This function sends @data of length @len to the remote @dst address,* and uses @src as the source address.* The message will be sent to the remote processor which the @ept* endpoint belongs to.* In case there are no TX buffers available, the function will block until* one becomes available, or a timeout of 15 seconds elapses. When the latter* happens, -ERESTARTSYS is returned.** Can only be called from process context (for now).** Returns 0 on success and an appropriate error value on failure.*/
int rpmsg_send_offchannel(struct rpmsg_endpoint *ept, u32 src, u32 dst,void *data, int len)
{if (WARN_ON(!ept))return -EINVAL;if (!ept->ops->send_offchannel)return -ENXIO;return ept->ops->send_offchannel(ept, src, dst, data, len);
}
EXPORT_SYMBOL(rpmsg_send_offchannel);/*** rpmsg_send() - send a message across to the remote processor* @ept: the rpmsg endpoint* @data: payload of message* @len: length of payload** This function sends @data of length @len on the @ept endpoint.* The message will be sent to the remote processor which the @ept* endpoint belongs to, using @ept's address as source and its associated* rpdev's address as destination.* In case there are no TX buffers available, the function will immediately* return -ENOMEM without waiting until one becomes available.** Can only be called from process context (for now).** Returns 0 on success and an appropriate error value on failure.*/
int rpmsg_trysend(struct rpmsg_endpoint *ept, void *data, int len)
{if (WARN_ON(!ept))return -EINVAL;if (!ept->ops->trysend)return -ENXIO;return ept->ops->trysend(ept, data, len);
}
EXPORT_SYMBOL(rpmsg_trysend);/*** rpmsg_sendto() - send a message across to the remote processor, specify dst* @ept: the rpmsg endpoint* @data: payload of message* @len: length of payload* @dst: destination address** This function sends @data of length @len to the remote @dst address.* The message will be sent to the remote processor which the @ept* endpoint belongs to, using @ept's address as source.* In case there are no TX buffers available, the function will immediately* return -ENOMEM without waiting until one becomes available.** Can only be called from process context (for now).** Returns 0 on success and an appropriate error value on failure.*/
int rpmsg_trysendto(struct rpmsg_endpoint *ept, void *data, int len, u32 dst)
{if (WARN_ON(!ept))return -EINVAL;if (!ept->ops->trysendto)return -ENXIO;return ept->ops->trysendto(ept, data, len, dst);
}
EXPORT_SYMBOL(rpmsg_trysendto);/*** rpmsg_poll() - poll the endpoint's send buffers* @ept:    the rpmsg endpoint* @filp: file for poll_wait()* @wait:   poll_table for poll_wait()** Returns mask representing the current state of the endpoint's send buffers*/
__poll_t rpmsg_poll(struct rpmsg_endpoint *ept, struct file *filp,poll_table *wait)
{if (WARN_ON(!ept))return 0;if (!ept->ops->poll)return 0;return ept->ops->poll(ept, filp, wait);
}
EXPORT_SYMBOL(rpmsg_poll);/*** rpmsg_send_offchannel() - send a message using explicit src/dst addresses* @ept: the rpmsg endpoint* @src: source address* @dst: destination address* @data: payload of message* @len: length of payload** This function sends @data of length @len to the remote @dst address,* and uses @src as the source address.* The message will be sent to the remote processor which the @ept* endpoint belongs to.* In case there are no TX buffers available, the function will immediately* return -ENOMEM without waiting until one becomes available.** Can only be called from process context (for now).** Returns 0 on success and an appropriate error value on failure.*/
int rpmsg_trysend_offchannel(struct rpmsg_endpoint *ept, u32 src, u32 dst,void *data, int len)
{if (WARN_ON(!ept))return -EINVAL;if (!ept->ops->trysend_offchannel)return -ENXIO;return ept->ops->trysend_offchannel(ept, src, dst, data, len);
}
EXPORT_SYMBOL(rpmsg_trysend_offchannel);

2、rpmsg_char.c的详细介绍

2.1 rpmsg_chrdev_driver结构体

定义如下：

static struct rpmsg_driver rpmsg_chrdev_driver = {.probe = rpmsg_chrdev_probe,.remove = rpmsg_chrdev_remove,.drv = {.name = "rpmsg_chrdev",},
};

从该结构体定义可以看出其是一个字符设备，在rpmsg_char_init()会register dirver

static int rpmsg_char_init(void)
{int ret;/* 系统自动分配设备号 */ret = alloc_chrdev_region(&rpmsg_major, 0, RPMSG_DEV_MAX, "rpmsg");if (ret < 0) {pr_err("rpmsg: failed to allocate char dev region\n");return ret;}/* 创建/sys/class/rpmsg设备类 */rpmsg_class = class_create(THIS_MODULE, "rpmsg");if (IS_ERR(rpmsg_class)) {pr_err("failed to create rpmsg class\n");unregister_chrdev_region(rpmsg_major, RPMSG_DEV_MAX);return PTR_ERR(rpmsg_class);}/* 注册rpmsg driver，实质上是赋值操作 */ret = register_rpmsg_driver(&rpmsg_chrdev_driver);if (ret < 0) {pr_err("rpmsgchr: failed to register rpmsg driver\n");class_destroy(rpmsg_class);unregister_chrdev_region(rpmsg_major, RPMSG_DEV_MAX);}return ret;
}#define register_rpmsg_driver(drv) \__register_rpmsg_driver(drv, THIS_MODULE)int __register_rpmsg_driver(struct rpmsg_driver *rpdrv, struct module *owner)
{rpdrv->drv.bus = &rpmsg_bus;rpdrv->drv.owner = owner;return driver_register(&rpdrv->drv);
}int driver_register(struct device_driver *drv)
{int ret;struct device_driver *other;if (!drv->bus->p) {pr_err("Driver '%s' was unable to register with bus_type '%s' because the bus was not initialized.\n",drv->name, drv->bus->name);return -EINVAL;}/* 检查driver与bus的函数是否有冲突 */if ((drv->bus->probe && drv->probe) ||(drv->bus->remove && drv->remove) ||(drv->bus->shutdown && drv->shutdown))printk(KERN_WARNING "Driver '%s' needs updating - please use ""bus_type methods\n", drv->name);/* driver找到bus->p->drivers_kset中的空位（先会判断这个list中是否已经存在同名的driver） */other = driver_find(drv->name, drv->bus);if (other) {printk(KERN_ERR "Error: Driver '%s' is already registered, ""aborting...\n", drv->name);return -EBUSY;}/* bus中添加driver */ret = bus_add_driver(drv);if (ret)return ret;/* 如果grop不为空的话，将在驱动文件夹下创建以group名字的子文件夹，然后在子文件夹下添加group的属性文件 */ret = driver_add_groups(drv, drv->groups);if (ret) {bus_remove_driver(drv);return ret;}kobject_uevent(&drv->p->kobj, KOBJ_ADD);return ret;
}

而rpmsg_char_init会在驱动加载时被调用

  postcore_initcall(rpmsg_char_init);

2.2 rpmsg_chrdev_probe()函数

问：该函数在何时被调用呢？

答：

在bus中，若driver，会触发bus中的bus_add_driver->driver_attach->__driver_attach>driver_probe_device->really_probe->

if (dev->bus->probe) {ret = dev->bus->probe(dev);if (ret)goto probe_failed;
} else if (drv->probe) {ret = drv->probe(dev);if (ret)goto probe_failed;
}

在bus中，若device add，会触发bus中device_add->bus_add_device,if(dev->bus)bus_probe_device->device_initial_probe->__device_attach->这里有两条路if(dev->driver) device_bind_driver，（走else）**else** **bus_for_each_drv(dev->bus, NULL, &data,__device_attach_driver)**;->driver_match_device->driver_probe_device->>really_probe->
```
if (dev->bus->probe) {ret = dev->bus->probe(dev);if (ret)goto probe_failed;
} else if (drv->probe) {ret = drv->probe(dev);if (ret)goto probe_failed;
}
```

从上面分析可以看到bus->probe优先级比driver->probe高。

问：那是不是表示rpmsg driver->probe永远也不会被调用到？

答：不会，应为rpmsg bus->probe()中会调用rpmsg driver->probe；

接下来分析rpmsg_chrdev_probe()函数中主要做的事情。

前提：刚刚分析了，只有在driver match device后才会调用到rpmsg bus probe进而调用到rpmsg driver probe，故此时对应的device已经找到了。

static int rpmsg_chrdev_probe(struct rpmsg_device *rpdev)
{struct rpmsg_ctrldev *ctrldev;struct device *dev;int ret;/* 初始化rpmsg  控制设备，该控制设备保存着已经被实例化的ept device*/ctrldev = kzalloc(sizeof(*ctrldev), GFP_KERNEL);if (!ctrldev)return -ENOMEM;ctrldev->rpdev = rpdev;dev = &ctrldev->dev;device_initialize(dev);dev->parent = &rpdev->dev;dev->class = rpmsg_class;/* 为该控制设备添加字符设备，以便后续支持ioctl */cdev_init(&ctrldev->cdev, &rpmsg_ctrldev_fops);ctrldev->cdev.owner = THIS_MODULE;/* 获取ida数组中一个有效的index,并获取此设备号 */ret = ida_simple_get(&rpmsg_minor_ida, 0, RPMSG_DEV_MAX, GFP_KERNEL);if (ret < 0)goto free_ctrldev;dev->devt = MKDEV(MAJOR(rpmsg_major), ret);/* 获取ida数组中一个有效的index,并设置名字 */ret = ida_simple_get(&rpmsg_ctrl_ida, 0, 0, GFP_KERNEL);if (ret < 0)goto free_minor_ida;dev->id = ret;dev_set_name(&ctrldev->dev, "rpmsg_ctrl%d", ret);/* 填充设备号 */ret = cdev_add(&ctrldev->cdev, dev->devt, 1);if (ret)goto free_ctrl_ida;/* We can now rely on the release function for cleanup */dev->release = rpmsg_ctrldev_release_device;/* 添加字符设备，后续可以通过dev找到所对应的rpmsg_ctrldev，进而可以会找到rpmsg device */ret = device_add(dev);if (ret) {dev_err(&rpdev->dev, "device_add failed: %d\n", ret);put_device(dev);}dev_set_drvdata(&rpdev->dev, ctrldev);return ret;free_ctrl_ida:ida_simple_remove(&rpmsg_ctrl_ida, dev->id);
free_minor_ida:ida_simple_remove(&rpmsg_minor_ida, MINOR(dev->devt));
free_ctrldev:put_device(dev);kfree(ctrldev);return ret;
}

2.3 rpmsg_chrdev_remove()函数

从下面的函数可以知道，当该driver remove，则改在在该driver下的所有rpmsg device会一个个被调用rpmsg_eptdev_destroy-> ept->ops->destroy_ept，可以看到每个rpmsg device维护自己的device函数。

那么这里留一个问题，什么时候rpmsg_create_ept？

static void rpmsg_chrdev_remove(struct rpmsg_device *rpdev)
{struct rpmsg_ctrldev *ctrldev = dev_get_drvdata(&rpdev->dev);int ret;/* Destroy all endpoints */ret = device_for_each_child(&ctrldev->dev, NULL, rpmsg_eptdev_destroy);if (ret)dev_warn(&rpdev->dev, "failed to nuke endpoints: %d\n", ret);device_del(&ctrldev->dev);put_device(&ctrldev->dev);
}

二、virtio_rpmsg_bus.c 的详细介绍

1、virtio_ipc_driver 结构体的介绍

static struct virtio_device_id id_table[] = {{ VIRTIO_ID_RPMSG, VIRTIO_DEV_ANY_ID },{ 0 },
};static unsigned int features[] = {VIRTIO_RPMSG_F_NS,
};static struct virtio_driver virtio_ipc_driver = {.feature_table  = features,.feature_table_size = ARRAY_SIZE(features),.driver.name    = KBUILD_MODNAME,.driver.owner = THIS_MODULE,.id_table    = id_table,.probe      = rpmsg_probe,.remove      = rpmsg_remove,
};

从上面结构体中的变量可以看到，该virtio_dirver有属于自己的probo与remove函数，故可以猜测该dirver是属于virtio_bus的（该猜测在后续中会印证）。

该结构体会在 subsys_initcall(rpmsg_init); --> register_virtio_driver(&virtio_ipc_driver);中被注册，通过查看register_virtio_dirver函数：

该virtio_driver被设为的属于virtio_bus —>这就印证了刚刚的猜测；
通过driver_register将virtio_driver register 到 virtio_bus中；

int register_virtio_driver(struct virtio_driver *driver)
{/* Catch this early. */BUG_ON(driver->feature_table_size && !driver->feature_table);driver->driver.bus = &virtio_bus;return driver_register(&driver->driver);
}

2、rpmsg_probe()函数的介绍

注意该函数是virtio_driver中的probe函数。

源码如下图：

主要做了如下的事情：

根据vdev->config->find_vqs()，根据names作为匹配原则期望找到对应的rx与tx virtqueue;
根据找到的rx/tx，将其赋值到virtproc_info->virqueue[0/1] ；
统计rx/tx 所需要的buf size/buf num/total buf space，并为需要的buf申请DMA memory；
DMA memory对半分给若rx/tx;
对每一个rx buf进行vring的初始化；
将上述virtproc_info初始化赋值给该virtio_device；
为支持remote process，创建一个以RPMSG_NS_ADDR的virtproc_info->ns_ept，支持后续的name service announcement;
准备kick_off并告知remote process notify

在该函数中涉及到很多数据结构，统一的来说：

先根据名字，找到rx/tx virtqueue（vqs）;
将rx/tx virtqueue存储到virtproc_info(vrq)->rvq/tvq；
初始化vrq（rvq vring、tvq info、ns_ept）；
将vrq存储到virtio_device中；

static int rpmsg_probe(struct virtio_device *vdev)
{vq_callback_t *vq_cbs[] = { rpmsg_recv_done, rpmsg_xmit_done };static const char * const names[] = { "input", "output" };struct virtqueue *vqs[2];struct virtproc_info *vrp;void *bufs_va;int err = 0, i;size_t total_buf_space;bool notify;vrp = kzalloc(sizeof(*vrp), GFP_KERNEL);if (!vrp)return -ENOMEM;vrp->vdev = vdev;idr_init(&vrp->endpoints);mutex_init(&vrp->endpoints_lock);mutex_init(&vrp->tx_lock);init_waitqueue_head(&vrp->sendq);/* 根据vdev->config->find_vqs()，根据names作为匹配原则期望找到对应的rx与tx * 其中rx与tx对应各自的virtqueue*/err = virtio_find_vqs(vdev, 2, vqs, vq_cbs, names, NULL);if (err)goto free_vrp;/* 根据找到的rx/tx，将其赋值到virtproc_info->virqueue[0/1] */vrp->rvq = vqs[0];vrp->svq = vqs[1];/* 期望rx/tx   virtqueue对应的vring size是对称的 */WARN_ON(virtqueue_get_vring_size(vrp->rvq) !=virtqueue_get_vring_size(vrp->svq));/* 如果rx vring size小于MAX_RPMSG_NUM_BUFS / 2，则后续可利用的buf num为最小size * 2* 否则以最大的MAX_RPMS_NUM_BUFS为准*/if (virtqueue_get_vring_size(vrp->rvq) < MAX_RPMSG_NUM_BUFS / 2)vrp->num_bufs = virtqueue_get_vring_size(vrp->rvq) * 2;elsevrp->num_bufs = MAX_RPMSG_NUM_BUFS;vrp->buf_size = MAX_RPMSG_BUF_SIZE;total_buf_space = vrp->num_bufs * vrp->buf_size;/* 根据统计所得的buf space 申请一段连续的DMA memory */bufs_va = dma_alloc_coherent(vdev->dev.parent->parent,total_buf_space, &vrp->bufs_dma,GFP_KERNEL);if (!bufs_va) {err = -ENOMEM;goto vqs_del;}dev_dbg(&vdev->dev, "buffers: va %p, dma %pad\n",bufs_va, &vrp->bufs_dma);/* 将上述的DMA内存对半给rx与tx的buf, DMA memory的起始地址在rx  */vrp->rbufs = bufs_va;vrp->sbufs = bufs_va + total_buf_space / 2;/* 根据rx buf num对每一个buf进行初始化 */for (i = 0; i < vrp->num_bufs / 2; i++) {struct scatterlist sg;void *cpu_addr = vrp->rbufs + i * vrp->buf_size;    //获取每一个rx buf cpu addrrpmsg_sg_init(&sg, cpu_addr, vrp->buf_size);    //根据cpu addr初始化一个散列表err = virtqueue_add_inbuf(vrp->rvq, &sg, 1, cpu_addr,   //根据散列表与cpu addr，初始化rx vring inbufGFP_KERNEL);WARN_ON(err); /* sanity check; this can't really happen */}/* 设置相关的tx flag，来抑制发送行为 */virtqueue_disable_cb(vrp->svq);/* 将virtproc_info赋值给该virtio_device */vdev->priv = vrp;/*  创建一个RPMSG_NS_ADDR的ept，以供支持remote process */if (virtio_has_feature(vdev, VIRTIO_RPMSG_F_NS)) {/* a dedicated endpoint handles the name service msgs */vrp->ns_ept = __rpmsg_create_ept(vrp, NULL, rpmsg_ns_cb,vrp, RPMSG_NS_ADDR);if (!vrp->ns_ept) {dev_err(&vdev->dev, "failed to create the ns ept\n");err = -ENOMEM;goto free_coherent;}}/* 准备事件相关的kick off（中断、标志） */notify = virtqueue_kick_prepare(vrp->rvq);/* 将该virtio device设置成ready status. */virtio_device_ready(vdev);/* 告知remote device可以发消息了，notify一般为戳中断的形式 */if (notify)virtqueue_notify(vrp->rvq);dev_info(&vdev->dev, "rpmsg host is online\n");return 0;free_coherent:dma_free_coherent(vdev->dev.parent->parent, total_buf_space,bufs_va, vrp->bufs_dma);
vqs_del:vdev->config->del_vqs(vrp->vdev);
free_vrp:kfree(vrp);return err;
}

3、__rpmsg_create_ept()介绍

其主要将该ns_ept的ops = virtio_endpoint_ops，从上面的函数调用可以知道，传进去的rpdev == NULL，所以这个函数还未与rpmsg_bus建立联系。

问：何时才与rpmsg _bus建立联系呢？
答：(vrp->ns_ept->cb == rpmsg_ns_cb)–>rpmsg_create_channel–>rpmsg_register_device()；
问：何时才调用rpmsg_ns_cb?
答：从之前的分析，都是对virtio_driver结构体的分析，应该在后续有virtio_device match时候，调用到virtio_bus->probe --> virtio_driver->probe -->为这个virtio_device 进行初始化操作，此时virtio_device->priv->ns_ept = ept，其中ept->rpdev == NULL，后续可使用这个virtio_device 进行name service rpmsg_create_channel->rpmsg_register_device，进行rpmsg_device的真正建立。进而virtio_device对应的virtio_driver有真正的rpdev，使得virtio_driver、virtio_device通过rpmsg_device与rpmsg_bus打交道。

static struct rpmsg_endpoint *__rpmsg_create_ept(struct virtproc_info *vrp,struct rpmsg_device *rpdev,rpmsg_rx_cb_t cb,void *priv, u32 addr)
{int id_min, id_max, id;struct rpmsg_endpoint *ept;struct device *dev = rpdev ? &rpdev->dev : &vrp->vdev->dev;ept = kzalloc(sizeof(*ept), GFP_KERNEL);if (!ept)return NULL;kref_init(&ept->refcount);mutex_init(&ept->cb_lock);/* 初始化ept */ept->rpdev = rpdev;ept->cb = cb;ept->priv = priv;ept->ops = &virtio_endpoint_ops;    /* 该virproc_info->ns_ept->ops = virtio_endpoint_ops  *//* do we need to allocate a local address ? */if (addr == RPMSG_ADDR_ANY) {id_min = RPMSG_RESERVED_ADDRESSES;id_max = 0;} else {id_min = addr;id_max = addr + 1;}mutex_lock(&vrp->endpoints_lock);/* bind the endpoint to an rpmsg address (and allocate one if needed) */id = idr_alloc(&vrp->endpoints, ept, id_min, id_max, GFP_KERNEL);if (id < 0) {dev_err(dev, "idr_alloc failed: %d\n", id);goto free_ept;}ept->addr = id;mutex_unlock(&vrp->endpoints_lock);return ept;free_ept:mutex_unlock(&vrp->endpoints_lock);kref_put(&ept->refcount, __ept_release);return NULL;
}

4、 virtio_endpoint_ops结构体介绍

可以看到这个结构体中包含了很多后续rpmsg_device 的ops，所以对于利用了virtio 来实现rpmsg ipc的具体ops都在这个结构体里面。

static const struct rpmsg_endpoint_ops virtio_endpoint_ops = {.destroy_ept = virtio_rpmsg_destroy_ept,.send = virtio_rpmsg_send,.sendto = virtio_rpmsg_sendto,.send_offchannel = virtio_rpmsg_send_offchannel,.trysend = virtio_rpmsg_trysend,.trysendto = virtio_rpmsg_trysendto,.trysend_offchannel = virtio_rpmsg_trysend_offchannel,
};

5、rpmsg_ns_cb() 函数的介绍

在rpsmg_probe()函数中，为了支持remote_device，会进行virtio_device->priv(virtproc)->ns_ept = cretea ns_ept ，其中就会为注册rpmsg_ns_cb()，该函数主要进行如下事情：

初始化rpmsg_channel_info；
根据channel_info进行rpomsg_create_channel

static int rpmsg_ns_cb(struct rpmsg_device *rpdev, void *data, int len,void *priv, u32 src)
{struct rpmsg_ns_msg *msg = data;struct rpmsg_device *newch;struct rpmsg_channel_info chinfo;struct virtproc_info *vrp = priv;struct device *dev = &vrp->vdev->dev;int ret;#if defined(CONFIG_DYNAMIC_DEBUG)dynamic_hex_dump("NS announcement: ", DUMP_PREFIX_NONE, 16, 1,data, len, true);
#endifif (len != sizeof(*msg)) {dev_err(dev, "malformed ns msg (%d)\n", len);return -EINVAL;}/** the name service ept does _not_ belong to a real rpmsg channel,* and is handled by the rpmsg bus itself.* for sanity reasons, make sure a valid rpdev has _not_ sneaked* in somehow.*/if (rpdev) {dev_err(dev, "anomaly: ns ept has an rpdev handle\n");return -EINVAL;}/* don't trust the remote processor for null terminating the name */msg->name[RPMSG_NAME_SIZE - 1] = '\0';dev_info(dev, "%sing channel %s addr 0x%x\n",msg->flags & RPMSG_NS_DESTROY ? "destroy" : "creat",msg->name, msg->addr);strncpy(chinfo.name, msg->name, sizeof(chinfo.name));chinfo.src = RPMSG_ADDR_ANY;chinfo.dst = msg->addr;if (msg->flags & RPMSG_NS_DESTROY) {ret = rpmsg_unregister_device(&vrp->vdev->dev, &chinfo);if (ret)dev_err(dev, "rpmsg_destroy_channel failed: %d\n", ret);} else {newch = rpmsg_create_channel(vrp, &chinfo);if (!newch)dev_err(dev, "rpmsg_create_channel failed\n");}return 0;
}

6、rpmsg_create_channel() 函数的介绍

函数原型如下：

调用rpmsg_device_match，根据chinfo来确认该channel没有被创建；
分配virtio_rpmsg_channel memory；
初始化rpmsg-device：virtio_rpmsg_channel->rpmsg_device src、dst、ops、announce、id.name；
根据初始化的rpmsg_device，进行rpmsg_register_device，往rpmsg_bus中register device；
返回rpmsg_device，该rpmsg_device addr == virtio_rpmsg_channel->rpmsg_device；

这样就可以理解为：

一个virtio_device对应一个virtio_rpmsg_channel；
一个virtio_rpmsg_channel对应一个rpmsg_device；
一个rpmsg_device对应一个rpmsg_driver；

/** create an rpmsg channel using its name and address info.* this function will be used to create both static and dynamic* channels.*/
static struct rpmsg_device *rpmsg_create_channel(struct virtproc_info *vrp,struct rpmsg_channel_info *chinfo)
{struct virtio_rpmsg_channel *vch;struct rpmsg_device *rpdev;struct device *tmp, *dev = &vrp->vdev->dev;int ret;/* make sure a similar channel doesn't already exist *//* 调用rpmsg_device_match，根据chinfo来确认该channel没有被创建 */tmp = rpmsg_find_device(dev, chinfo);if (tmp) {/* decrement the matched device's refcount back */put_device(tmp);dev_err(dev, "channel %s:%x:%x already exist\n",chinfo->name, chinfo->src, chinfo->dst);return NULL;}/* 分配virtio_rpmsg_channel memory */vch = kzalloc(sizeof(*vch), GFP_KERNEL);if (!vch)return NULL;/* Link the channel to our vrp */vch->vrp = vrp;/* Assign public information to the rpmsg_device *//* 初始化rpmsg-device* virtio_rpmsg_channel->rpmsg_device src、dst、ops、announce、id.name*/rpdev = &vch->rpdev;rpdev->src = chinfo->src;rpdev->dst = chinfo->dst;rpdev->ops = &virtio_rpmsg_ops;/** rpmsg server channels has predefined local address (for now),* and their existence needs to be announced remotely*/rpdev->announce = rpdev->src != RPMSG_ADDR_ANY;strncpy(rpdev->id.name, chinfo->name, RPMSG_NAME_SIZE);rpdev->dev.parent = &vrp->vdev->dev;rpdev->dev.release = virtio_rpmsg_release_device;/* 根据初始化的rpmsg_device，进行该device的register */ret = rpmsg_register_device(rpdev);if (ret)return NULL;return rpdev;
}

7、virtio_rpmsg_ops() 结构体的介绍

上面提到过，会将rpmsg_device->ops = &virtio_rpmsg_ops，这个结构体里面有如下三个操作函数，结合上面的理解，可以进一步规划为：

一个virtio_device对应一个virtio_rpmsg_channel；
一个virtio_rpmsg_channel对应一个rpmsg_device，一个virtio_rpmsg_channel对应多个rpmsg_endpoint；
一个rpmsg_device对应一个rpmsg_driver；

static const struct rpmsg_device_ops virtio_rpmsg_ops = {.create_ept = virtio_rpmsg_create_ept,.announce_create = virtio_rpmsg_announce_create,.announce_destroy = virtio_rpmsg_announce_destroy,
};

其中virtio_rpmsg_create_ept()最终是调用__rpmsg_create_ept()。

三、Virtio的介绍

1、virtio.c 的介绍

1.1 virtio_bus结构体的介绍

源码如下：

该文件会建立一个name为“virtio”的bus

有几个比较关键的函数：

virtio_dev_match;
virtio_dev_groups;
virtio_dev_probe;
virtio_dev_remove;

static struct bus_type virtio_bus = {.name  = "virtio",.match = virtio_dev_match,.dev_groups = virtio_dev_groups,.uevent = virtio_uevent,.probe = virtio_dev_probe,.remove = virtio_dev_remove,
};

其通过core_initcall和module_exit进行bus的初始化

static int virtio_init(void)
{if (bus_register(&virtio_bus) != 0)panic("virtio bus registration failed");return 0;
}static void __exit virtio_exit(void)
{bus_unregister(&virtio_bus);ida_destroy(&virtio_index_ida);
}
core_initcall(virtio_init);
module_exit(virtio_exit);

1.2 register_virtio_driver() 函数的介绍

当我们需要向virtio_bus register一个virtio_driver就需要调用该函数。

源码如下：可以看到其最终是调用driver_register

int register_virtio_driver(struct virtio_driver *driver)
{/* Catch this early. */BUG_ON(driver->feature_table_size && !driver->feature_table);driver->driver.bus = &virtio_bus;return driver_register(&driver->driver);
}
EXPORT_SYMBOL_GPL(register_virtio_driver);

1.3 register_virtio_device() 函数的介绍

当我们需要向virtio_bus register一个virtio_device就需要调用该函数。

源码如下：可以看到其最终是调用device_add()，主要做了如下事情：

bus name 赋值；
设置相关标志；
调用device_add()向bus总线添加device；

/*** register_virtio_device - register virtio device* @dev        : virtio device to be registered** On error, the caller must call put_device on &@dev->dev (and not kfree),* as another code path may have obtained a reference to @dev.** Returns: 0 on suceess, -error on failure*/
int register_virtio_device(struct virtio_device *dev)
{int err;dev->dev.bus = &virtio_bus;device_initialize(&dev->dev);/* Assign a unique device index and hence name. */err = ida_simple_get(&virtio_index_ida, 0, 0, GFP_KERNEL);if (err < 0)goto out;dev->index = err;dev_set_name(&dev->dev, "virtio%u", dev->index);spin_lock_init(&dev->config_lock);dev->config_enabled = false;dev->config_change_pending = false;/* We always start by resetting the device, in case a previous* driver messed it up.  This also tests that code path a little. */dev->config->reset(dev);/* Acknowledge that we've seen the device. */virtio_add_status(dev, VIRTIO_CONFIG_S_ACKNOWLEDGE);INIT_LIST_HEAD(&dev->vqs);/** device_add() causes the bus infrastructure to look for a matching* driver.*/err = device_add(&dev->dev);if (err)ida_simple_remove(&virtio_index_ida, dev->index);
out:if (err)virtio_add_status(dev, VIRTIO_CONFIG_S_FAILED);return err;
}
EXPORT_SYMBOL_GPL(register_virtio_device);

1.4 virtio_dev_probe 函数的介绍

该函数主要做如下事情：

根据据传入的device，找该device说属于的virtio_device和virtio_driver；
设定相关的标志位；
**调用virtio_driver->probe()**这个函数后面会进行具体分析；
完成配置；

函数源码：

static int virtio_dev_probe(struct device *_d)
{int err, i;/* find virtio_device according to device  */struct virtio_device *dev = dev_to_virtio(_d);/* find virtio_driver according to virtio_device  */struct virtio_driver *drv = drv_to_virtio(dev->dev.driver);u64 device_features;u64 driver_features;u64 driver_features_legacy;/* We have a driver! */virtio_add_status(dev, VIRTIO_CONFIG_S_DRIVER);/* Figure out what features the device supports. */device_features = dev->config->get_features(dev);/* Figure out what features the driver supports. */driver_features = 0;for (i = 0; i < drv->feature_table_size; i++) {unsigned int f = drv->feature_table[i];BUG_ON(f >= 64);driver_features |= (1ULL << f);}/* Some drivers have a separate feature table for virtio v1.0 */if (drv->feature_table_legacy) {driver_features_legacy = 0;for (i = 0; i < drv->feature_table_size_legacy; i++) {unsigned int f = drv->feature_table_legacy[i];BUG_ON(f >= 64);driver_features_legacy |= (1ULL << f);}} else {driver_features_legacy = driver_features;}if (device_features & (1ULL << VIRTIO_F_VERSION_1))dev->features = driver_features & device_features;elsedev->features = driver_features_legacy & device_features;/* Transport features always preserved to pass to finalize_features. */for (i = VIRTIO_TRANSPORT_F_START; i < VIRTIO_TRANSPORT_F_END; i++)if (device_features & (1ULL << i))__virtio_set_bit(dev, i);if (drv->validate) {err = drv->validate(dev);if (err)goto err;}err = virtio_finalize_features(dev);if (err)goto err;/* callback virtio_driver->probe() */err = drv->probe(dev);if (err)goto err;/* If probe didn't do it, mark device DRIVER_OK ourselves. */if (!(dev->config->get_status(dev) & VIRTIO_CONFIG_S_DRIVER_OK))virtio_device_ready(dev);if (drv->scan)drv->scan(dev);virtio_config_enable(dev);return 0;
err:virtio_add_status(dev, VIRTIO_CONFIG_S_FAILED);return err;}

1.5 virtio_dev_match 函数的介绍

该函数是virtio_bus进行device 和driver match

源码如下：

可以看到，其有两个匹配原则：

driver匹配任意device：virtio_driver->id_table[i] (virtio_device_id) ->vendor == VIRTIO_DEV_ANY_ID;
driver匹配指定一类device：virtio_driver->id_table[i] (virtio_device_id) ->vendor == virtio_device->id.vendor

static inline int virtio_id_match(const struct virtio_device *dev,const struct virtio_device_id *id)
{if (id->device != dev->id.device && id->device != VIRTIO_DEV_ANY_ID)return 0;return id->vendor == VIRTIO_DEV_ANY_ID || id->vendor == dev->id.vendor;
}/* This looks through all the IDs a driver claims to support.  If any of them* match, we return 1 and the kernel will call virtio_dev_probe(). */
static int virtio_dev_match(struct device *_dv, struct device_driver *_dr)
{unsigned int i;struct virtio_device *dev = dev_to_virtio(_dv);const struct virtio_device_id *ids;ids = drv_to_virtio(_dr)->id_table;for (i = 0; ids[i].device; i++)if (virtio_id_match(dev, &ids[i]))return 1;return 0;
}

2、virtio_input.c的介绍

上面virtio.c是介绍virtio bus，该文件是介绍virtio_driver。

在整个目前所使用的kernel版本中，有多种virtio_driver（virtio_pci_driver、virtio-mmio、virtio_balloon_driver、virtio_input_driver），除了virtio_input_driver支持VIRTIO_DEV_ANY_ID，其他的virtio_driver都是支持指定的virtio_device。

2.1 virtio_input_driver结构体介绍

原型如下：

可以看到其支持power manager的相关freeze和restore操作，当然其最重要的函数就是virtinput_probe；
这个结构体是通过module_virtio_driver宏进而调用register_virtio_driver()

static unsigned int features[] = {/* none */
};
static struct virtio_device_id id_table[] = {{ VIRTIO_ID_INPUT, VIRTIO_DEV_ANY_ID },{ 0 },
};static struct virtio_driver virtio_input_driver = {.driver.name         = KBUILD_MODNAME,.driver.owner        = THIS_MODULE,.feature_table       = features,.feature_table_size  = ARRAY_SIZE(features),.id_table            = id_table,.probe               = virtinput_probe,.remove              = virtinput_remove,
#ifdef CONFIG_PM_SLEEP.freeze                = virtinput_freeze,.restore             = virtinput_restore,
#endif
};module_virtio_driver(virtio_input_driver);

2.2 virtinput_probe() 函数的介绍

函数原型如下：可以看到所做的事情和virtio_ipc_driver是类似的：

初始化virtioquqe，设置callback；
分配buf；
设置相关属性：name、physaddr、serial name；
设置device为ready状态；
kick off；

static int virtinput_probe(struct virtio_device *vdev)
{struct virtio_input *vi;unsigned long flags;size_t size;int abs, err;if (!virtio_has_feature(vdev, VIRTIO_F_VERSION_1))return -ENODEV;vi = kzalloc(sizeof(*vi), GFP_KERNEL);if (!vi)return -ENOMEM;vdev->priv = vi; vi->vdev = vdev; spin_lock_init(&vi->lock);/* 初始化virtqueue* callback virtio_device->config->find_vqs* init virtinput_recv_events and virtinput_recv_status callback*/err = virtinput_init_vqs(vi);if (err)goto err_init_vq;/* alloc buf for device */vi->idev = input_allocate_device();if (!vi->idev) {err = -ENOMEM;goto err_input_alloc;}input_set_drvdata(vi->idev, vi);/* 设置相关属性：name、physaddr、serial name*/size = virtinput_cfg_select(vi, VIRTIO_INPUT_CFG_ID_NAME, 0);virtio_cread_bytes(vi->vdev, offsetof(struct virtio_input_config,u.string),vi->name, min(size, sizeof(vi->name)));size = virtinput_cfg_select(vi, VIRTIO_INPUT_CFG_ID_SERIAL, 0);virtio_cread_bytes(vi->vdev, offsetof(struct virtio_input_config,u.string),vi->serial, min(size, sizeof(vi->serial)));snprintf(vi->phys, sizeof(vi->phys),"virtio%d/input0", vdev->index);vi->idev->name = vi->name;vi->idev->phys = vi->phys;vi->idev->uniq = vi->serial;size = virtinput_cfg_select(vi, VIRTIO_INPUT_CFG_ID_DEVIDS, 0);if (size >= sizeof(struct virtio_input_devids)) {virtio_cread(vi->vdev, struct virtio_input_config,u.ids.bustype, &vi->idev->id.bustype);virtio_cread(vi->vdev, struct virtio_input_config,u.ids.vendor, &vi->idev->id.vendor);virtio_cread(vi->vdev, struct virtio_input_config,u.ids.product, &vi->idev->id.product);virtio_cread(vi->vdev, struct virtio_input_config,u.ids.version, &vi->idev->id.version);} else {vi->idev->id.bustype = BUS_VIRTUAL;}virtinput_cfg_bits(vi, VIRTIO_INPUT_CFG_PROP_BITS, 0,vi->idev->propbit, INPUT_PROP_CNT);size = virtinput_cfg_select(vi, VIRTIO_INPUT_CFG_EV_BITS, EV_REP);if (size)__set_bit(EV_REP, vi->idev->evbit);vi->idev->dev.parent = &vdev->dev;vi->idev->event = virtinput_status;/* device -> kernel */virtinput_cfg_bits(vi, VIRTIO_INPUT_CFG_EV_BITS, EV_KEY,vi->idev->keybit, KEY_CNT);virtinput_cfg_bits(vi, VIRTIO_INPUT_CFG_EV_BITS, EV_REL,vi->idev->relbit, REL_CNT);virtinput_cfg_bits(vi, VIRTIO_INPUT_CFG_EV_BITS, EV_ABS,vi->idev->absbit, ABS_CNT);virtinput_cfg_bits(vi, VIRTIO_INPUT_CFG_EV_BITS, EV_MSC,vi->idev->mscbit, MSC_CNT);virtinput_cfg_bits(vi, VIRTIO_INPUT_CFG_EV_BITS, EV_SW,vi->idev->swbit,  SW_CNT);/* kernel -> device */virtinput_cfg_bits(vi, VIRTIO_INPUT_CFG_EV_BITS, EV_LED,vi->idev->ledbit, LED_CNT);virtinput_cfg_bits(vi, VIRTIO_INPUT_CFG_EV_BITS, EV_SND,vi->idev->sndbit, SND_CNT);if (test_bit(EV_ABS, vi->idev->evbit)) {for (abs = 0; abs < ABS_CNT; abs++) {if (!test_bit(abs, vi->idev->absbit))continue;virtinput_cfg_abs(vi, abs);}}/* 设置device为ready状态 */virtio_device_ready(vdev);vi->ready = true;err = input_register_device(vi->idev);if (err)goto err_input_register;/* 设定完成将会kickoff   */virtinput_fill_evt(vi);return 0;err_input_register:spin_lock_irqsave(&vi->lock, flags);vi->ready = false;spin_unlock_irqrestore(&vi->lock, flags);input_free_device(vi->idev);
err_input_alloc:vdev->config->del_vqs(vdev);
err_init_vq:kfree(vi);return err;
}

四、virtio_device、virtio_driver、virtio_bus、rpmsg_device、rpmsg_drivver、rpmsg_bus如何如何联系且运作起来

1、联系的建立

当系统初始化时（前提ce是打开的kernel的rpmsg与virtio的相关config），其实已经存在了virtio_bus、virtio_ipc_driver、rpmsg_bus、rpmsg_bus，如下图：

此时需要register virtio_device，进而触发virtio_bus->probe()，该probe会进行如下事情：
1. 根据据传入的device，找该device所属于的virtio_device和virtio_driver；
2. 设定相关的标志位；
3. 调用virtio_driver->probe()；
4. 完成配置；
virtio_bus->probe() 会进而调用virtio_ipc_driver->probe()，该probe会做如下事情：
1. 根据vdev->config->find_vqs()，根据names作为匹配原则期望找到对应的rx与tx virtqueue;
2. 根据找到的rx/tx，将其赋值到virtproc_info->virqueue[0/1] ；
3. 统计rx/tx 所需要的buf size/buf num/total buf space，并为需要的buf申请DMA memory；
4. DMA memory对半分给若rx/tx;
5. 对每一个rx buf进行vring的初始化；
6. 将上述virtproc_info初始化赋值给该virtio_device；
7. 为支持remote process，创建一个以RPMSG_NS_ADDR的virtproc_info->ns_ept，支持后续的name service announcement;
8. 准备kick_off并告知remote process notify

完成上述两个步骤后，此时virtio_ipc_driver-----virtio_bus-----virtio_device已经建立成功，且该virtio_device中有一个ns_ept（virtio_device->priv(virtproc_inf)->ns_ept）。

此时我们可以进行客制化，调用该virtio_device->priv(virtproc_inf)->ns_ept->cb()即可rpmsg_ns_cb()，该函数会进行rpmsg_create_channel()：
1. 初始化rpmsg_channel_info；
2. 根据channel_info进行rpomsg_create_channel
rpomsg_create_channel()进而会调用rpmsg_register_device()：
1. 调用rpmsg_device_match，根据chinfo来确认该channel没有被创建；
2. 分配virtio_rpmsg_channel memory；
3. 初始化rpmsg-device：virtio_rpmsg_channel->rpmsg_device src、dst、ops、announce、id.name；
4. 根据初始化的rpmsg_device，进行rpmsg_register_device，往rpmsg_bus中register device；
5. 返回rpmsg_device，该rpmsg_device addr == virtio_rpmsg_channel->rpmsg_device；
由于调用了rpmsg_register_device()，则进而会出发rpmsg_dev_probe()，将该rpmsg_device匹配上rpmsg_driver

此时就已经完成了virtio_device-----virtio_bus----virtio_ipc_driver <-----> rpmsg_device----rpmsg_bus-----rpmsg_driver，之间的联系，如下图：

2、运作

由于此时已经建立的联系，可以使用rpmsg_create_ept、rpmsg_send、rpmsg_trysend、rpmsg_poll等一系列的rpmsg operation，这个会进而会以callback的形式，最终调用virtio_rpmsg_bus.c中的virtio_rpmsg_ops。

举个例子，调用rpsmg_create_ept()

/----------------- rpmsg_core.c ---------------------/
struct rpmsg_endpoint *rpmsg_create_ept(struct rpmsg_device *rpdev,rpmsg_rx_cb_t cb, void *priv,struct rpmsg_channel_info chinfo)
{if (WARN_ON(!rpdev))return NULL;return rpdev->ops->create_ept(rpdev, cb, priv, chinfo);
}/* 该rpmsg device->ops，即是之前* virtio_device进行virtio_ipc_driver->probe()时：* virtio_device->priv(virtproc_info)->ns_ept->ops = & virtio_endpoint_ops;* 当根据该ns_ept->cb()进行rpmsg_channel-->rpmsg_device的建立时：* rpmsg->device->ops = & virtio_rpmsg_ops* virtio_rpmsg_ops中就有virtio_rpmsg_create_ept*/