platform平台总线

努力加班的阿韬

已于 2023-08-17 19:00:34 修改

阅读量149

点赞数

分类专栏： X210嵌入式Linux开发板学习文章标签：驱动开发 linux 物联网

于 2023-08-07 16:40:21 首次发布

本文链接：https://blog.csdn.net/weixin_54683011/article/details/132134672

版权

X210嵌入式Linux开发板学习专栏收录该内容

16 篇文章 0 订阅

订阅专栏

相对于usb、pci、i2c等物理总线来说，platform总线是虚拟的、抽象出来的
CPU与外部通信的2种方式：地址总线式连接（如DM9000网卡连接方式）和专用接口式（USB、IIC等）连接。平台总线对应地址总线式连接设备，也就是SoC内部集成的各种内部外设。platform 所描述的资源有一个共同点：在CPU 的总线上直接取址。
当我们将设备和驱动注册到虚拟总线上（内核）时，如果该设备是该驱动的设备，且该驱动是该设备的驱动，在他们注册时，会互相寻找一次对方（只在注册的时候寻找一次，找完了就玩了）。这个找的过程是platform_bus来完成的，我们暂不管他如何让寻找。如果device和driver中的name这个字符串是想相同的话，platform_bus就会调用driver中的.probe函数。这个匹配到调用probe的过程是自动的，有总线自己完成。
设备和驱动的关系是多对一的关系，即多个相同设备可使用一个driver，靠device（设备）中的id号来区别

1、平台总线下管理的2员大将

(1)platform工作体系都定义在drivers/base/platform.c中

(2)两个结构体：platform_device和platform_driver

(3)两个接口函数：platform_device_register和platform_driver_register

struct platform_device {
	const char	* name;			// 平台总线下设备的名字
	int		id;                //区分多个设备的id例如led1、led2之类的
	struct device	dev;		// 所有设备通用的属性部分
	u32		num_resources;	// 设备使用到的resource的个数，资源可以是IO口，地址范围，中断号等等
	struct resource	* resource;	// 设备使用到的资源数组的首地址

	const struct platform_device_id	*id_entry;	// 设备ID表 ，同一系列不同设备的id

	/* arch specific additions */
	struct pdev_archdata	archdata;			// 自留地，用来提供扩展性的
};

struct platform_driver {
	int (*probe)(struct platform_device *);		// 驱动探测函数，是否可以控制，类似驱动安装函数
	int (*remove)(struct platform_device *);	// 去掉一个设备，去掉后就没有了，如同卸载
	void (*shutdown)(struct platform_device *);	// 关闭一个设备，不等同于卸载
	int (*suspend)(struct platform_device *, pm_message_t state);//设备的挂起函数
	int (*resume)(struct platform_device *);//设备的恢复函数，与挂起相对应
	struct device_driver driver;				// 所有设备共用的一些属性
	const struct platform_device_id *id_table;	// 设备ID表
};

2、平台总线体系的工作流程

(1)第一步：系统启动时在bus系统中注册platform

(2)第二步：内核移植的人负责提供platform_device

(3)第三步：写驱动的人负责提供platform_driver

(4)第四步：platform的match函数发现driver和device匹配后，调用driver的probe函数来完成驱动的初始化和安装，然后设备就工作起来了

platform本身注册

(1)每种总线（不光是platform，usb、i2c那些也是）都会带一个match方法，match方法用来对总线下的device和driver进行匹配。

(2)platform_match函数就是平台总线的匹配方法。该函数的工作方法是：

如果有id_table就说明驱动可能支持多个设备，所以这时候要去对比id_table中所有的name，只要找到一个相同的就匹配上了不再找了
如果找完id_table都还没找到就说明没匹配上
如果没有id_table或者每匹配上，那就直接对比device和driver的name，如果匹配上就匹配上了，如果还没匹配上那就匹配失败

有两个重要的链表挂在bus上，一个是设备device链表，一个是驱动driver链表。

static int platform_match(struct device *dev, struct device_driver *drv)
{
	struct platform_device *pdev = to_platform_device(dev);
	struct platform_driver *pdrv = to_platform_driver(drv);

	/* match against the id table first */
	if (pdrv->id_table)
		return platform_match_id(pdrv->id_table, pdev) != NULL;

	/* fall-back to driver name match */
	return (strcmp(pdev->name, drv->name) == 0);
}

分析platform设备和驱动的注册过程

以leds-s3c24xx.c为例:

两个接口函数：platform_device_register 和 platform_driver_register

(1)platform_driver_register

static struct platform_driver s3c24xx_led_driver = {
	.probe		= s3c24xx_led_probe,//检测驱动是否可用，类似安装，初始化驱动
	.remove		= s3c24xx_led_remove,//用来卸载设备
	.driver		= {//所有设备共有的一些属性
		.name		= "s3c24xx_led",
		.owner		= THIS_MODULE,
	},
};//可以尝试搜索s3c24xx_led找到它对应的device结构体
static int __init s3c24xx_led_init(void)
{
	return platform_driver_register(&s3c24xx_led_driver);//注册driver
}
static void __exit s3c24xx_led_exit(void)
{
	platform_driver_unregister(&s3c24xx_led_driver);
}

platform_device_register:

/**
 * platform_add_devices - add a numbers of platform devices
 * @devs: array of platform devices to add
 * @num: number of platform devices in array
 */
int platform_add_devices(struct platform_device **devs, int num)
{
	int i, ret = 0;

	for (i = 0; i < num; i++) {
		ret = platform_device_register(devs[i]);
		if (ret) {
			while (--i >= 0)//只要出错会将之前注册的注销掉
				platform_device_unregister(devs[i]);
			break;
		}
	}

	return ret;
}

int platform_device_register(struct platform_device *pdev)
{
	device_initialize(&pdev->dev);
	return platform_device_add(pdev);
}

int platform_device_add(struct platform_device *pdev)
{
	int i, ret = 0;

	if (!pdev)
		return -EINVAL;

	if (!pdev->dev.parent)
		pdev->dev.parent = &platform_bus;

	pdev->dev.bus = &platform_bus_type;

	if (pdev->id != -1)
		dev_set_name(&pdev->dev, "%s.%d", pdev->name,  pdev->id);
	else
		dev_set_name(&pdev->dev, "%s", pdev->name);

	for (i = 0; i < pdev->num_resources; i++) {
		struct resource *p, *r = &pdev->resource[i];

		if (r->name == NULL)
			r->name = dev_name(&pdev->dev);

		p = r->parent;
		if (!p) {
			if (resource_type(r) == IORESOURCE_MEM)
				p = &iomem_resource;
			else if (resource_type(r) == IORESOURCE_IO)
				p = &ioport_resource;
		}

		if (p && insert_resource(p, r)) {
			printk(KERN_ERR
			       "%s: failed to claim resource %d\n",
			       dev_name(&pdev->dev), i);
			ret = -EBUSY;
			goto failed;
		}
	}

	pr_debug("Registering platform device '%s'. Parent at %s\n",
		 dev_name(&pdev->dev), dev_name(pdev->dev.parent));

	ret = device_add(&pdev->dev);
	if (ret == 0)
		return ret;

 failed:
	while (--i >= 0) {
		struct resource *r = &pdev->resource[i];
		unsigned long type = resource_type(r);

		if (type == IORESOURCE_MEM || type == IORESOURCE_IO)
			release_resource(r);
	}

	return ret;
}
EXPORT_SYMBOL_GPL(platform_device_add);

platdata:

在这里插入图片描述

(1)platdata其实就是设备注册时提供的设备有关的一些数据（譬如设备对应的gpio、使用到的中断号、设备名称····）
(2)这些数据在设备和驱动match之后，会由设备方转给驱动方。驱动拿到这些数据后，通过这些数据得知设备的具体信息，然后来操作设备。
(3)这样做的好处是：
驱动源码中不携带数据，只负责算法（对硬件的操作方法）。现代驱动设计理念就是算法和数据分离，这样最大程度保持驱动的独立性和适应性。

probe函数的功能和意义

probe在设备驱动被注册到内核中的时候，被总线型驱动调用。
总线驱动类似于用轮训方法bai探测总线上的所有设备，将设备的识别型信息和关键数据结构 (pci ids, usb ids, i2c ids and etc.)传递给probe函数，probe就会识别是否是自己负责驱动的设备，并负责完成该设备的初始化操作。

probe函数在设备驱动注册进行最后收尾工作，当设备的device 和其对应的driver 在总线上完成配对之后，系统就调用platform设备的probe函数完成驱动注册最后工作。资源、中断调用函数以及其他相关工作。

每当我们向一根bus注册一个驱动driver时，套路是这样的：

driver_register(struct device_driver * drv) -> bus_add_driver() ->
driver_attach() ->bus_for_each_dev(drv->bus, NULL, drv, __driver_attach);

bus_for_each_dev遍历该总线上所有的device，执行一次__driver_attach()，看能不能将驱动关联(attach)到某个设备上去。

__driver_attach()->driver_probe_device()

->drv->bus->match(dev, drv), // 调用bus的match函数，看device和driver匹不匹配。如果匹配上，

继续执行really_probe()。->really_probe()->driver->probe()。(如果bus->probe非空，则调用bus->probe)

match函数的调用轨迹

struct bus_type {
	const char		*name;
	struct bus_attribute	*bus_attrs;
	struct device_attribute	*dev_attrs;
	struct driver_attribute	*drv_attrs;

	int (*match)(struct device *dev, struct device_driver *drv);
	int (*uevent)(struct device *dev, struct kobj_uevent_env *env);
	int (*probe)(struct device *dev);
	int (*remove)(struct device *dev);
	void (*shutdown)(struct device *dev);

	int (*suspend)(struct device *dev, pm_message_t state);
	int (*resume)(struct device *dev);

	const struct dev_pm_ops *pm;

	struct bus_type_private *p;
};
struct bus_type platform_bus_type = {
	.name		= "platform",
	.dev_attrs	= platform_dev_attrs,
	.match		= platform_match,
	.uevent		= platform_uevent,
	.pm		= &platform_dev_pm_ops,
};
EXPORT_SYMBOL_GPL(platform_bus_type);

#define to_platform_device(x) container_of((x), struct platform_device, dev)
#define to_platform_driver(drv)	(container_of((drv), struct platform_driver,driver))

static int platform_match(struct device *dev, struct device_driver *drv)
{
	struct platform_device *pdev = to_platform_device(dev);
	struct platform_driver *pdrv = to_platform_driver(drv);

	/* match against the id table first */
	if (pdrv->id_table)
		return platform_match_id(pdrv->id_table, pdev) != NULL;

	/* fall-back to driver name match */
	return (strcmp(pdev->name, drv->name) == 0);
}

在这里插入图片描述