Rpmsg与Virtio介绍

Rpmsg与Virtio介绍


一、Rpmsg的介绍

  • 源码所在路径:drivers\rpmsg\

    Kconfig
      Makefile
      qcom_glink_native.c
      qcom_glink_native.h
      qcom_glink_rpm.c
      qcom_glink_smem.c
      qcom_smd.c
      rpmsg_char.c
      rpmsg_core.c
      rpmsg_internal.h
      virtio_rpmsg_bus.c
    

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

在这里插入图片描述

  1. Rpmsg的整体框架是Rpmsg BusRpmsg Device与Rpmsg Driver所构成,即Linux中的Bus模型;

  2. Rpmsg Bus:由rpmsg_core.c文件所构建,负责

    1. bus的构建;
    2. Driver-device的match;
    3. device的probe与remove;
    4. 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,
    };
    
  3. 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",
    	},
    };
    
  4. 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,
    };
    
  5. 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函数

  1. 完成bus_type_private的初始化、创建并注册的这条总线需要的目录,该目录为rpmsg;
  2. rpmsg目录下创建/device /driver 目录
  3. 初始化这条总线上的设备链表:struct klist klist_devices;
  4. 初始化这条总线上的驱动链表: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函数:

  1. 该virtio_driver被设为的属于virtio_bus —>这就印证了刚刚的猜测;
  2. 通过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函数。

源码如下图:

主要做了如下的事情:

  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

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

  1. 先根据名字,找到rx/tx virtqueue(vqs);
  2. 将rx/tx virtqueue存储到virtproc_info(vrq)->rvq/tvq;
  3. 初始化vrq(rvq vring、tvq info、ns_ept);
  4. 将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;
	else
		vrp->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 addr

	rpmsg_sg_init(&sg, cpu_addr, vrp->buf_size);    //根据cpu addr初始化一个散列表

	err = virtqueue_add_inbuf(vrp->rvq, &sg, 1, cpu_addr,   //根据散列表与cpu addr,初始化rx vring inbuf
		  GFP_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(),该函数主要进行如下事情:

  1. 初始化rpmsg_channel_info;
  2. 根据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);
#endif

	if (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() 函数的介绍

函数原型如下:

  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;

这样就可以理解为:

  1. 一个virtio_device对应一个virtio_rpmsg_channel;
  2. 一个virtio_rpmsg_channel对应一个rpmsg_device;
  3. 一个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,这个结构体里面有如下三个操作函数,结合上面的理解,可以进一步规划为:

  1. 一个virtio_device对应一个virtio_rpmsg_channel;
  2. 一个virtio_rpmsg_channel对应一个rpmsg_device,一个virtio_rpmsg_channel对应多个rpmsg_endpoint
  3. 一个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(),主要做了如下事情:

    1. bus name 赋值;
    2. 设置相关标志;
    3. 调用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 函数的介绍

该函数主要做如下事情:

  1. 根据据传入的device,找该device说属于的virtio_device和virtio_driver;
  2. 设定相关的标志位;
  3. **调用virtio_driver->probe()**这个函数后面会进行具体分析;
  4. 完成配置;
  • 函数源码:

    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;
    	else
    		dev->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

  • 源码如下:

    可以看到,其有两个匹配原则:

    1. driver匹配任意device:virtio_driver->id_table[i] (virtio_device_id) ->vendor == VIRTIO_DEV_ANY_ID;
    2. 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是类似的:

    1. 初始化virtioquqe,设置callback;
    2. 分配buf;
    3. 设置相关属性:name、physaddr、serial name;
    4. 设置device为ready状态 ;
    5. 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,如下图:

在这里插入图片描述

  1. 此时需要register virtio_device,进而触发virtio_bus->probe(),该probe会进行如下事情:
    1. 根据据传入的device,找该device所属于的virtio_device和virtio_driver;
    2. 设定相关的标志位;
    3. 调用virtio_driver->probe()
    4. 完成配置;
  2. 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)。

  1. 此时我们可以进行客制化,调用该virtio_device->priv(virtproc_inf)->ns_ept->cb()即可rpmsg_ns_cb(),该函数会进行rpmsg_create_channel():
    1. 初始化rpmsg_channel_info;
    2. 根据channel_info进行rpomsg_create_channel
  2. 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;
  3. 由于调用了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
 */
  • 14
    点赞
  • 47
    收藏
    觉得还不错? 一键收藏
  • 3
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值