【Linux学习笔记】platform 设备

系列文章目录

【Linux学习笔记】开发板挂载根文件系统

【Linux学习笔记】设备树学习

【Linux学习笔记】pinctrl和gpio子系统

【Linux学习笔记】Linux 并发与竞争

【Linux学习笔记】Linux内核定时器

【Linux学习笔记】Linux中断

【Linux学习笔记】阻塞和非阻塞IO

【Linux学习笔记】异步通知

---

本系列使用的开发板为正点原子阿尔法IMX6ULL开发板，及根据正点原子所的提供教程学习同系列笔记已放置链接在上面。

---

---

一、Linux驱动的分离与分层

1.1 驱动的分隔与分离

Linux系统中的总线（bus）、驱动（driver）和设备（device）模型，也就是驱动分离，这样就相当于驱动只负责驱动，设备只负责设备，两者进行匹配即可。
注册驱动的时候系统会匹配设备，注册设备的时候系统会匹配设备。

1.2 驱动的分层

分层的目的是为了在不同的层处理不同的内容。

二、platform平台

为了在没有总线的SOC上使用总线、驱动和设备模型，就有了platform虚拟总线，那么对应的就有了platform_driver和platform_device。

2.1 platform 总线

Linux内核使用bus_type结构体表示总线，此结构体定义在文件include/linux/device.h，bus_type 结构体内容如下：

struct bus_type {
	const char *name; /* 总线名字 */
	const char *dev_name;
	struct device *dev_root;
	struct device_attribute *dev_attrs;
	const struct attribute_group **bus_groups; /* 总线属性 */
	const struct attribute_group **dev_groups; /* 设备属性 */
	const struct attribute_group **drv_groups; /* 驱动属性 */

	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 (*online)(struct device *dev);
	int (*offline)(struct device *dev);
	int (*suspend)(struct device *dev, pm_message_t state);
	int (*resume)(struct device *dev);
	const struct dev_pm_ops *pm;
	const struct iommu_ops *iommu_ops;
	struct subsys_private *p;
	struct lock_class_key lock_key;
};

其中match函数很重要，此函数用来完成设备与驱动之间的匹配，总线就是使用match函数来根据注册的设备查找对应的驱动或者根据驱动查设备的，因此每条总线都必须实现此函数，match函数的两个参数dev和drv分别是device和device_driver类型，也就是设备和驱动。

platform总线就是bus_type的一个具体实例，定义在文件 drivers/base/platform.c，内容如下：

struct bus_type platform_bus_type = {
	.name = "platform",
	.dev_groups = platform_dev_groups,
	.match = platform_match,
	.uevent = platform_uevent,
	.pm = &platform_dev_pm_ops,
};

platform_bus_type 就是 platform 平台总线，其中 platform_match 就是匹配函数。platform_match 函数定义在文件 drivers/base/platform.c 中，函数内容如下所示：

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);
	
	/*When driver_override is set,only bind to the matching driver*/
	if (pdev->driver_override)
		return !strcmp(pdev->driver_override, drv->name);
	
	/* Attempt an OF style match first */
	if (of_driver_match_device(dev, drv))
		return 1;
	
	/* Then try ACPI style match */
	if (acpi_driver_match_device(dev, drv))
		return 1;
	/* Then try to match against the id table */
	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);
}

匹配方式共四种，具体如下：

1. 第一种匹配方式， OF 类型的匹配，也就是设备树采用的匹配方式，of_driver_match_device 函数定义在文件 include/linux/of_device.h 中。device_driver 结构体(表示设备驱动)中有个名为of_match_table的成员变量，此成员变量保存着驱动的compatible匹配表，设备树中的每个设备节点的 compatible 属性会和 of_match_table 表中的所有成员比较，查看是否有相同的条目，如果有的话就表示设备和此驱动匹配，设备和驱动匹配成功以后 probe 函数就会执行。这种一般都会存在
2. 第二种匹配方式，ACPI 匹配方式。
3. 第三种匹配方式，id_table 匹配，每个 platform_driver 结构体有一个 id_table成员变量，顾名思义，保存了很多 id 信息。这些 id 信息存放着这个 platformd 驱动所支持的驱动类型。
4. 第四种匹配方式，如果第三种匹配方式的 id_table 不存在的话就直接比较驱动和设备的 name 字段，看看是不是相等，如果相等的话就匹配成功。这种方式最简单使用也是最多的。

2.2 platform驱动

platform_driver 结 构 体 表 示 platform 驱动，此结构体定义在文件include/linux/platform_device.h 中，内容如下：

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;
	bool prevent_deferred_probe;
};

probe 函数，当驱动与设备匹配成功以后 probe 函数就会执行，非常重要的函数！！一般驱动的提供者会编写，如果自己要编写一个全新的驱动，那么 probe 就需要自行实现。

device_driver 结构体定义在 include/linux/device.h，device_driver 结构体内容如下：

struct device_driver {
	const char *name;
	struct bus_type *bus;
	......
	const struct of_device_id *of_match_table;
	......

of_match_table 就是采用设备树的时候驱动使用的匹配表，同样是数组，每个匹配项都为 of_device_id 结构体类型，此结构体定义在文件 include/linux/mod_devicetable.h 中，内容如下：

struct of_device_id {
	char name[32];
	char type[32];
	char compatible[128];
	const void *data;
};

compatible 非常重要，因为对于设备树而言，就是通过设备节点的 compatible 属性值和 of_match_table 中每个项目的 compatible 成员变量进行比较，如果有相等的就表示设备和此驱动匹配成功。

在编写platform驱动的时候，首先定义一个paltform_driver结构体变量，然后实现结构体中的各个成员变量，重点是实现匹配方法以及probe函数。当驱动和设备匹配成功以后probe函数就会执行，具体驱动程序再probe函数里面编写，如字符设备驱动等等。
当我们定义并初始化好 platform_driver 结构体变量以后，需要在驱动入口函数里面调用platform_driver_register 函数向 Linux 内核注册一个 platform 驱动，platform_driver_register 函数原型如下所示：

int platform_driver_register (struct platform_driver *driver)
driver：要注册的 platform 驱动。
返回值：负数，失败；0，成功。

驱动卸载函数中通过 platform_driver_unregister 函数卸载 platform 驱动，platform_driver_unregister 函数原型如下：

void platform_driver_unregister(struct platform_driver *drv)
drv：要卸载的 platform 驱动。
返回值：无。

platform 驱动框架如下所示：

/* 设备结构体 */
struct xxx_dev{
struct cdev cdev;
/* 设备结构体其他具体内容 */
};

struct xxx_dev xxxdev; /* 定义个设备结构体变量 */

static int xxx_open(struct inode *inode, struct file *filp)
{ 
	/* 函数具体内容 */
	return 0;
}

static ssize_t xxx_write(struct file *filp, const char __user *buf,
							size_t cnt, loff_t *offt)
{
	/* 函数具体内容 */
	return 0;
 }

 /*
 * 字符设备驱动操作集
*/
static struct file_operations xxx_fops = {
	.owner = THIS_MODULE,
	.open = xxx_open,
	.write = xxx_write,
};

/*
* platform 驱动的 probe 函数
* 驱动与设备匹配成功以后此函数就会执行
*/
static int xxx_probe(struct platform_device *dev)
{ 
	......
	cdev_init(&xxxdev.cdev, &xxx_fops); /* 注册字符设备驱动 */
	/* 函数具体内容 */
	return 0;
}

static int xxx_remove(struct platform_device *dev)
{
	......
	cdev_del(&xxxdev.cdev);/* 删除 cdev */
	/* 函数具体内容 */
	return 0;
}

/* 匹配列表 */
static const struct of_device_id xxx_of_match[] = {
	{ .compatible = "xxx-gpio" },
	{ /* Sentinel */ }
};

/* 
* platform 平台驱动结构体
*/
static struct platform_driver xxx_driver = {
	.driver = {
		.name = "xxx",
		.of_match_table = xxx_of_match,
	 },
	.probe = xxx_probe,
	.remove = xxx_remove,
};

/* 驱动模块加载 */
static int __init xxxdriver_init(void)
{
	return platform_driver_register(&xxx_driver);
}

/* 驱动模块卸载 */
static void __exit xxxdriver_exit(void)
{
	platform_driver_unregister(&xxx_driver);
}

module_init(xxxdriver_init);
module_exit(xxxdriver_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("xxx");

platform 驱动还是传统的字符设备驱动、块设备驱动或网络设备驱动，只是套上了一张“platform”的皮，目的是为了使用总线、驱动和设备这个驱动模型来实现驱动的分离与分层。

2.3 platform 设备

2.3.1 platform_device 来描述设备

有驱动了那就要有设备，platform_device 这个结构体表示 platform 设备这里我们要注意，如果内核支持设备树的话就不要再使用 platform_device 来描述设备了，因为改用设备树去描述了。非要用platform_device 来描述设备信息的话也是可以的。

platform_device 结构体定义在文件include/linux/platform_device.h 中，结构体内容如下：

struct platform_device {
	const char *name;//表示设备名字，要和所使用的 platform 驱动的 name 字段相同，否则的话设备就无法匹配到对应的驱动。
	int id; 
	bool id_auto;
	struct device dev;
	u32 num_resources; //num_resources 表示资源数量，一般为下一行的resource 资源的大小。
	struct resource *resource;//表示资源，也就是设备信息，比如外设寄存器等。Linux 内核使用 resource结构体表示资源
	
	const struct platform_device_id *id_entry;
	char *driver_override; /* Driver name to force a match */
	
	/* MFD cell pointer */
	struct mfd_cell *mfd_cell;
	
	/* arch specific additions */
	struct pdev_archdata archdata;
};

使用 platform_device_register 函数将设备信息注册到 Linux 内核中，此函数原型如下所示：

int platform_device_register(struct platform_device *pdev)
pdev：要注册的 platform 设备。
返回值：负数，失败；0，成功。

通过 platform_device_unregister 函数注销掉相应的 platform设备

void platform_device_unregister(struct platform_device *pdev)
pdev：要注销的 platform 设备。
返回值：无。

platform 设备信息框架如下所示：

/* 寄存器地址定义*/
#define PERIPH1_REGISTER_BASE (0X20000000) /* 外设 1 寄存器首地址 */ 
#define PERIPH2_REGISTER_BASE (0X020E0068) /* 外设 2 寄存器首地址 */
#define REGISTER_LENGTH 4

/* 资源 */
static struct resource xxx_resources[] = {
	[0] = {
		.start = PERIPH1_REGISTER_BASE,
		.end = (PERIPH1_REGISTER_BASE + REGISTER_LENGTH - 1),
		.flags = IORESOURCE_MEM,
	}, 
	[1] = {
		.start = PERIPH2_REGISTER_BASE,
		.end = (PERIPH2_REGISTER_BASE + REGISTER_LENGTH - 1),
		.flags = IORESOURCE_MEM,
	},
};

/* platform 设备结构体 */
static struct platform_device xxxdevice = {
	.name = "xxx-gpio",
	.id = -1,
	.num_resources = ARRAY_SIZE(xxx_resources),
	.resource = xxx_resources,
};

/* 设备模块加载 */
static int __init xxxdevice_init(void)
{
	return platform_device_register(&xxxdevice);
}

/* 设备模块注销 */
static void __exit xxx_resourcesdevice_exit(void)
{
	platform_device_unregister(&xxxdevice);
}

module_init(xxxdevice_init);
module_exit(xxxdevice_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("xx");

2.3.2 设备树下的 platform 驱动

当 Linux 内核支持了设备树以后就不需要用户手动去注册 platform 设备了。因为设备信息都放到了设备树中去描述，Linux 内核启动的时候会从设备树中读取设备信息，然后将其组织成 platform_device 形式。也就是说只需要实现platporm_driver即可。

1. 首先在设备树中创建设备节点，重点是设置好compatible属性的值。

gpioled {
	#address-cells = <1>;
	#size-cells = <1>;
	compatible = "atkalpha-gpioled";//这里是重点
	pinctrl-names = "default";
	pinctrl-0 = <&pinctrl_led>;
	led-gpio = <&gpio1 3 GPIO_ACTIVE_LOW>;
	status = "okay";
};

2. 编写platform驱动，和2.3.1中使用的platporm_drvice差不多，其中使用了pinctrl和gpio子系统。增加了如下内容，主要是compatible 属性的增加。

static const struct of_device_id leds_of_match[] = {
	{ .compatible = "atkalpha-gpioled" }, /* 兼容属性 */
	{ /* Sentinel */ }
};

MODULE_DEVICE_TABLE(of, leds_of_match);

static struct platform_driver leds_platform_driver = {
	.driver = {
		.name = "imx6ul-led",
		.of_match_table = leds_of_match,
	},
	.probe = leds_probe,
	.remove = leds_remove,
};