Linux字符设备驱动-LED-platform驱动模型
1.概述
在Linux设备驱动模型中，需要关心总线、设备和驱动这3个实体，总线将设备和驱动绑定。在系统注册一个设备的时候，会寻找与之匹配的驱动；相反的，在注册一个驱动的时候，会寻找与之匹配的设备，而匹配由总线完成。Linux实现了一种虚拟的总线，称为platform总线，相应的设备称为platform_device，而驱动称为platform_driver。
1.1.platform总线
Linux内核使用bus_type结构体表示总线，由内核统一管理，驱动程序一般不牵扯到修改总线，只需要使用即可。
include <linux/device.h>
struct bus_type {
const char *name; // 总线名称
const char *dev_name;
struct device *dev_root;
struct device_attribute *dev_attrs; /* use dev_groups instead */
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 (*suspend)(struct device *dev, pm_message_t state);
int (*resume)(struct device *dev);
};
platform总线是bus_type的一个具体实例，定义在文件drivers/base/platform.c文件中。
struct bus_type platform_bus_type = {
.name = "platform",
.dev_groups = platform_dev_groups,
.match = platform_match, // platform_device和platform_driver匹配函数
.uevent = platform_uevent,
.pm = &platform_dev_pm_ops,
};
1.2.platform驱动
Linux内核使用platform_driver结构体表示platform驱动。
include <linux/platform_device.h>
struct platform_driver {
// 当驱动和设备匹配成功后，probe函数就会执行，类似于初始化函数
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;
// 用于匹配的id_table指针，一般指向一个platform_device_id数组
const struct platform_device_id *id_table;
bool prevent_deferred_probe;
};
// id_table实质上就是一个字符串数组
struct platform_device_id {
char name[PLATFORM_NAME_SIZE];
kernel_ulong_t driver_data;
};
struct device_driver {
const char *name;
struct bus_type *bus;
struct module *owner;
const char *mod_name; /* used for built-in modules */
bool suppress_bind_attrs; /* disables bind/unbind via sysfs */
// 采用设备树时，采用of_match_table进行匹配
const struct of_device_id *of_match_table;
const struct acpi_device_id *acpi_match_table;
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 attribute_group **groups;
const struct dev_pm_ops *pm;
struct driver_private *p;
};
compatible非常重要，对于设备树而言，就是通过设备节点的compatible属性值和of_match_table数组中的每个compatible成员变量进行比较，如果有相等的就表示设备和此驱动匹配成功。
include <linux/mod_devicetable.h>
struct of_device_id {
char name[32];
char type[32];
char compatible[128];
const void *data;
};
在编写platform驱动的时候，需要定义一个platform_driver结构体，然后实现结构体中的各个变量成员，重点是实现匹配方法及probe函数。当我们定义好platform_driver结构体后，需要使用platform_driver_register函数向内核注册一个platform驱动。drv为platform_driver结构体结构体指针，返回值为0成功，返回值为负值表示失败。使用platform_driver_unregister注销。
include <linux/platform_device.h>
#define platform_driver_register(drv) __platform_driver_register(drv, THIS_MODULE)
void platform_driver_unregister(struct platform_driver *drv)
1.3.platform设备
Linux内核使用struct platform_device结构体表示platform设备。
include <linux/platform_device.h>
struct platform_device {
const char *name; // 设备名字，要和platform驱动的name字段一致
int id;
bool id_auto;
struct device dev;
u32 num_resources; // 表示资源数量，即resource指向的数组长度
struct resource *resource; // 表示资源，是一个数组，如IO、内存、寄存器、中断等资源
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;
};
include <linux/ioport.h>
struct resource {
resource_size_t start; // 资源的起始信息，如内存或寄存器的起始地址
resource_size_t end; // 资源的结束信息，如内存或寄存器的结束地址
const char *name; // 资源名称
unsigned long flags; // 资源类型
struct resource *parent, *sibling, *child;
};
// 资源类型宏定义
#define IORESOURCE_TYPE_BITS 0x00001f00 /* Resource type */
#define IORESOURCE_IO 0x00000100 /* PCI/ISA I/O ports */
#define IORESOURCE_MEM 0x00000200
#define IORESOURCE_REG 0x00000300 /* Register offsets */
#define IORESOURCE_IRQ 0x00000400
#define IORESOURCE_DMA 0x00000800
#define IORESOURCE_BUS 0x00001000
// 获取资源信息，type为资源类型，num为资源序号index
struct resource *platform_get_resource(struct platform_device *dev, unsigned int type, unsigned int num)
// 获取中断资源
int platform_get_irq(struct platform_device *dev, unsigned int num)
Linux内核不支持设备树的时候，需要编写platform_device变量来描述设备信息，然后使用platform_device_register函数将设备信息注册到内核中，模块退出时使用使用platform_device_unregister注销。当linux内核支持设备树后，就不需要手动注册platform_device了。Linux内核启动的时候会从设备树中读取设备信息，然后将其组织成platform_device形式，在驱动中只需要提取这些设备信息即可。
include <linux/platform_device.h>
int platform_device_register(struct platform_device *pdev)
void platform_device_unregister(struct platform_device *pdev)
1.4.platform设备设备树的兼容性
在设备树中创建的设备要被platform总线正确匹配，需要正确设置好compatible属性。下面是编写的rgbled的设备节点，compatible属性为"my,rgb-led"。
/* 在根节点添加rgb led节点 */
rgb_led {
#address-cells = <1>;
#size-cells = <1>;
pinctrl-names = "default";
compatible = "my,rgb-led";
pinctrl-0 = <&pinctrl_rgb_led>;
red = <&gpio1 4 GPIO_ACTIVE_LOW>;
green = <&gpio4 20 GPIO_ACTIVE_LOW>;
blue = <&gpio4 19 GPIO_ACTIVE_LOW>;
status = "okay";
};
1.5.platform驱动的兼容性
platform驱动想要正确匹配platform设备，需要正确设置compatible属性，使用设备树时，需要定义struct of_device_id变量，并设置compatible成员的值，同时在注册之前正确设置struct platform_driver结构体。
MODULE_DEVICE_TABLE展开后生成了一个_mod_type__name_device_table的符号表，其中type为类型，name是这个驱动的名称。在内核编译的时候将这部分符号单独放置在一个区域。当内核运行的时，用户通过类型tpye和设备表中名称name在表中查找MODULE_DEVICE_TABLE定义的符号，找到之后可以动态的加载驱动。MODULE_DEVICE_TABLE一般用于动态加载驱动也就是热插拔的时候使用。
static const struct of_device_id my_led_of_match[] = {
{ .compatible = "my,rgb-led" }, // 兼容属性，与设备树中的兼容属性一致
{ /* Sentinel */ } // 最后一个元素一定为空
};
include <linux/module.h>
MODULE_DEVICE_TABLE(of, my_led_of_match);
static struct platform_driver my_led_platform_driver = {
.driver = {
.name = "imx6ull-rgb-led", // 设置驱动的名称
.of_match_table = my_led_of_match, // 驱动的设备的匹配数组信息，一个驱动可以和多个设备匹配
},
.probe = my_led_probe, // 初始化probe函数，驱动和设备匹配成功后此函数会执行
.remove = my_led_remove, // 退出remove函数
};
1.5.Linux内核对设备树的处理
Linux内核在启动的时候会处理设备树，首先将设备树节点转换为device_node，然后视情况将device_node转换为platform_device。
dtb -> device_node -> platform_device // 内核处理dtb文件的过程
1.5.1.设备树节点如何转化为device_node
设备树中的节点被内核解析成struct device_node结构体，所有的struct device_node结构体组成一棵树，树的根节点保存在of_root变量中，类型为struct device_node*。
struct device_node {
const char *name; // 设备树节点中的name属性
const char *type; // 设备树节点中的device_type属性
phandle phandle;
const char *full_name; // 设备树节点的名称
struct fwnode_handle fwnode;
struct property *properties; // 节点内的所有属性，所有属性会组成一个链表
struct property *deadprops; /* removed properties */
struct device_node *parent; // 父节点
struct device_node *child; // 子节点
struct device_node *sibling; // 兄弟节点，同级节点
struct kobject kobj;
unsigned long _flags;
void *data;
};
1.5.2.device_node如何转换为platform_device
内核函数of_platform_default_populate_init遍历device_node树, 生成platform_device，但不是所有的device_node都会被要转化为platform_device，有以下几个条件。
（1） 根节点的子节点(节点必须含有compatible属性)
（2） 含有特殊compatible属性节点的子节点(子节点必须含有compatible属性)，这些特殊的compatilbe属性为"simple-bus",“simple-mfd”,“isa”,“arm,amba-bus”。
（3）i2c, spi等总线节点下的子节点, 应该交给对应的总线驱动程序来处理, 它们不应该被转换为platform_device。
属性的转换方法如下：
（1）platform_device中含有resource数组, 它来自device_node的reg, interrupts等属性。
（2）可以通过platform_device.dev.of_node指向device_node获得其他属性。
2.字符设备驱动源码
/*===========================my_led_platform_driver.h================================*/
#include 3.测试程序源码
#include -g -b \n"
"-r: Control red led\n"
"-g: Control green led\n"
"-b: Control blue led\n"
"on: Light on(default)\n"
"off: Light off\n");
}
extern char* optarg; // 指向参数值
extern int optind; // 记录getopt函数处理argv[]数组的位置，一般不需要设置
extern int opterr; // 保存出错信息，非0 getopt会向stderr打印出错信息，如为0时则不打印
/* 遇到无法识别的选项，getopt返回？号，并将？存储到optopt中，如果将选项字符串第一个字符设置
为：号，那么getopt函数在用户未提供值的情况下返回：号而不是？号 */
extern int optopt;
int parse_option(int argc, char* argv[], int* rgb)
{
int opt;
while (-1 != (opt = getopt(argc, argv, OPT_STRING))) {
switch (opt) {
case 'r':
if(0 == strcmp(optarg, "on")) rgb[0] = 1;
else if (0 == strcmp(optarg, "off")) rgb[0] = 0;
else return -1;
break;
case 'g':
if(0 == strcmp(optarg, "on")) rgb[1] = 1;
else if (0 == strcmp(optarg, "off")) rgb[1] = 0;
else return -1;
break;
case 'b':
if(0 == strcmp(optarg, "on")) rgb[2] = 1;
else if (0 == strcmp(optarg, "off")) rgb[2] = 0;
else return -1;
break;
case ':':
print_usage();
return -1;
break;
case '?':
print_usage();
return -1;
break;
default:
print_usage();
return -1;
break;
}
}
return 0;
}
int main(int argc, char* argv[])
{
int fd, ret, val[3] = {0};
if (7 != argc) {
print_usage();
return -1;
}
ret = parse_option(argc, argv, val);
if (0 != ret) {
print_usage();
printf("parse option error\n");
return -1;
}
fd = open(PATH, O_RDWR);
if (fd < 0){
printf("my_led open error\n");
return -1;
}
ret = write(fd, &val, sizeof(val));
if (ret < 0) {
printf("write error\n");
close(fd);
return -1;
}
close(fd);
return 0;
}