Linux驱动开发十三.platform设备驱动——3.设备树下的platform驱动

在上一章节我们使用了platform框架在没有设备树的时候是如何使用的，不过现在的大多数半导体厂商都把设备树给我们完善了。区别就是在没有设备树信息的时候需要我们自己想总线注册platform设备，设备里主要包含寄存器地址信息等资源，而在有设备树支持的条件下，就不需要我们使用platform_device_register函数去向总线里注册设备了，我们只需要修改设备树然后编写驱动就行了。

设备树信息

在结合设备树完成platform驱动框架时，主要的设备树属性就是兼容性节点compatible

1 /*gpio蜂鸣器节点*/
2 beep{
3     compatible = "alientek,beep";
4     pinctrl-names = "default";
5     pinctrl-0 = <&pinctrl_gpiobeep>;
6     beep-gpios = <&gpio5 1 GPIO_ACTIVE_HIGH>;
7     status = "okay";
8 };

这次的驱动我们使用前面讲GPIO子系统时候的蜂鸣器来演示(还是因为LED点亮失败~)。设备树就不用更改了，一定要注意compatible节点的属性值，驱动是通过这个值来和设备进行匹配的。启动开发板以后打印一下设备树信息，看看有没有这个beep的节点

  节点正常，compatible属性的值也没问题。

 platform_driver对象

和前面一样，我们必须先声明一个platform_driver类型的变量来描述驱动，先回顾一下platform_driver的形式

 1 struct platform_driver {
 2     int (*probe)(struct platform_device *);
 3     int (*remove)(struct platform_device *);
 4     void (*shutdown)(struct platform_device *);
 5     int (*suspend)(struct platform_device *, pm_message_t state);
 6     int (*resume)(struct platform_device *);
 7     struct device_driver driver;
 8     const struct platform_device_id *id_table;
 9     bool prevent_deferred_probe;
10 };

上回我们在没有设备树的时候使用的成员是driver里面的name成员，这次我们要用到另一个

const struct of_device_id    *of_match_table;

从名称可以看出来，of是和设备树有关的，match是和匹配有关系的。可以再看看of_device_id的类型

1 /*
2  * Struct used for matching a device
3  */
4 struct of_device_id {
5     char    name[32];
6     char    type[32];
7     char    compatible[128];
8     const void *data;
9 };

可以从注释上看到，这是用来匹配设备的结构体，在和设备树信息进行匹配的时候，我们就要用到里面的compatible成员，这个值一定要和前面我强调的设备树里的compatible属性一致。

1 struct of_device_id beep_of_match[] = {
2     {.compatible = "alientek,beep"},
3     {/*Sentinel*/},                  //结尾标识符
4 };

这个compatible的内容一定要注意，必须和设备树里的内容相同顺序也要相同，即便是内容一样但是逗号左右的值反过来也无法匹配成功。

因为在device结构体这个match的是一个table，所以我们要把它声明成一个数组，好用来进行多个兼容性的匹配。要注意的是数组最后要用那个结尾的标识符来结束table的定义。在最后的platform_driver的成员就可以定义成下面这样了

1 static struct platform_driver beepdriver = {
2     .driver = {
3         .name = "imx6ull-led",              //无设备树时匹配驱动名称
4 
5         .of_match_table = beep_of_match,  //设备树匹配表
6     },
7     .probe = beep_probe,
8     .remove = beep_remove,
9 };

主要就是那个driver成员里的of_match_table了。其他就没什么了。

到这一步我们就可以试验一下driver的加载了，准备好ko文件后，启动开发板，可以先在/proc/device-tree下看看有没有我们要使用的设备，这个设备是从设备树中提取的，再加载驱动，可以在probe对应的函数中添加个打印信息检查下是否成功配对。

驱动的文件名我沿用上面章节leddrive没改，所以ko模块的文件名就是leddriver，加载以后如果和设备匹配成功就会执行probe对应的函数，打印出调试信息。

probe、release函数

如果能完成配对，剩下的就是probe函数了。和前面一样，probe主要就是完成设备的初始化、节点的生成什么的。可以把GPIO子系统试验里的初始化过程拿过来放在一个函数里，最后在probe里调用一下就可以了。卸载模块要释放资源的过程都放在release函数里，这样就可以了

/**
* @file leddriver.c
* @author your name ([email protected])
* @brief platfrom结合设备树驱动框架
* @version 0.1
* @date 2022-08-18
* 
* @copyright Copyright (c) 2022
* 
*/
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/fs.h>
#include <linux/uaccess.h>
#include <linux/io.h>
#include <linux/types.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_irq.h>
#include <linux/gpio.h>
#include <linux/of_gpio.h>
#include <linux/irq.h>
#include <linux/interrupt.h>
#include <linux/fcntl.h>
#include <linux/ide.h>
#include <linux/platform_device.h>
#define LEDOFF  0
#define LEDON   1
#define DEVICE_NAME "dtsplf_beep"
#define DEVICE_CNT 1
//内存映射后的地址指针
struct beep_dev
{
dev_t dev_id;
int major;
int minor;
struct class *class;
struct device *device;
struct cdev cdev;
struct device_node *dev_nd;
int beep_gpio;
};
struct beep_dev beep_dev;
static ssize_t beep_write(struct file *filp,const char __user *buf,
size_t count,loff_t *ppos)
{
int ret;
unsigned char databuf[1];
ret = copy_from_user(databuf,buf,count);
if(databuf[0] == 1){
gpio_set_value(beep_dev.beep_gpio,0);
}
else{
gpio_set_value(beep_dev.beep_gpio,1);
}
return ret;
}
/**
* @brief 文件操作集合
* 
*/
static const struct file_operations gpiobeep_fops = {
.owner = THIS_MODULE,
.write = beep_write,
// .open =  beep_dev_open,
// .release = beep_dev_release,
};
static int led_open(struct inode *inode, struct file *filp)
{
printk("dev open!/r/n");
return 0;
}
static ssize_t led_read(struct file *filp, 
__user char *buf,
size_t count, 
loff_t *ppos)
{
int ret = 0;
printk("dev read data!/r/n");
if (ret == 0){
return 0;
}
else{
printk("kernel read data error!");
return -1;
}
}
static void led_switch(u8 sta)
{
printk("led sta change %d/r/n",sta);
}
/**
* @brief 改变LED状态
* 
* @param file 
* @param buf 
* @param count 
* @param ppos 
* @return ssize_t 
*/
static ssize_t led_write(struct file *file, 
const char __user *buf, 
size_t count, 
loff_t *ppos)
{   
int ret = 0;
printk("led write called/r/n");
unsigned char databuf[1];                   //待写入的参数
ret = copy_from_user(databuf,buf,count);    //获取从用户空间传递来的参数
if (ret == 0){
led_switch(databuf[0]);                 //根据参数改变LED状态
}
else{
printk("kernelwrite err!/r/n");
return -EFAULT;
}
} 
static struct file_operations dev_fops= {
.owner = THIS_MODULE,
.open = led_open,
// .release = led_release,
.read = led_read,
.write = led_write,
};
static int beep_gpio_init(struct platform_device *p_dev){
int ret=0;
//从设备树搜索设备节点
beep_dev.dev_nd = of_find_node_by_path("/beep");
if(beep_dev.dev_nd == 0){
printk("no device found/r/n");
ret = -100;     //errno-base.h中定义的异常数值到34,这里从100开始使用防止冲突
}
//获取beep对应GPIO
beep_dev.beep_gpio =of_get_named_gpio(beep_dev.dev_nd,"beep-gpios",0);
printk("beep_gpio=%d/r/n",beep_dev.beep_gpio);
if(beep_dev.beep_gpio<0){
printk("no GPIO get/r/n");
ret = -100;     //errno-base.h中定义的异常数值到34,这里从100开始使用防止冲突
return ret;
}
//请求GPIO
ret = gpio_request(beep_dev.beep_gpio,"beep-gpio");
if(ret){
printk("gpio request err/r/n");
ret = -100;
return ret;
}
//设置GPIO为输出，默认输出状态为低电平
ret = gpio_direction_output(beep_dev.beep_gpio,0);
if(ret<0){
ret = -101;     //对应异常护理为fail_set
return ret;
}
//GPIO输出低电平，蜂鸣器发声
gpio_set_value(beep_dev.beep_gpio,0);
return ret;
}
static int __init beep_init(struct platform_device *p_dev){
int ret = 0; 
//申请设备号
beep_dev.major = 0;
if(beep_dev.major){
//手动指定设备号，使用指定的设备号
beep_dev.dev_id = MKDEV(beep_dev.major,0);
ret = register_chrdev_region(beep_dev.dev_id,DEVICE_CNT,DEVICE_NAME);
}
else{
//设备号未指定，申请设备号
ret = alloc_chrdev_region(&beep_dev.dev_id,0,DEVICE_CNT,DEVICE_NAME);
beep_dev.major = MAJOR(beep_dev.dev_id);
beep_dev.minor = MINOR(beep_dev.dev_id);
}
printk("dev id geted!/r/n");
if(ret<0){
//设备号申请异常，跳转至异常处理
goto faile_devid;
}
//字符设备cdev初始化
beep_dev.cdev.owner = THIS_MODULE;
cdev_init(&beep_dev.cdev,&gpiobeep_fops);                 //文件操作集合映射
ret = cdev_add(&beep_dev.cdev,beep_dev.dev_id,DEVICE_CNT);
if(ret<0){
//cdev初始化异常，跳转至异常处理
goto fail_cdev;
}
printk("chr dev inited!/r/n");
//自动创建设备节点
beep_dev.class = class_create(THIS_MODULE,DEVICE_NAME);
if(IS_ERR(beep_dev.class)){
//class创建异常处理
printk("class err!/r/n");
ret = PTR_ERR(beep_dev.class);
goto fail_class;
}
printk("dev class created/r/n");
beep_dev.device = device_create(beep_dev.class,NULL,beep_dev.dev_id,NULL,DEVICE_NAME);
if(IS_ERR(beep_dev.device)){
//设备创建异常处理
printk("device err!/r/n");
ret = PTR_ERR(beep_dev.device);
goto fail_device;
}
printk("device created!/r/n");
ret = beep_gpio_init(p_dev);
if(ret == -101){
goto fail_set;
}
else if(ret == -100){
goto fail_nd;
}
return 0;
fail_set:
gpio_free(beep_dev.beep_gpio);
fail_nd:
device_destroy(beep_dev.class,beep_dev.dev_id);
fail_device:
//device创建失败，意味着class创建成功，应该将class销毁
printk("device create err,class destroyed/r/n");
class_destroy(beep_dev.class);
fail_class:
//类创建失败，意味着设备应该已经创建成功，此刻应将其释放掉
printk("class create err,cdev del/r/n");
cdev_del(&beep_dev.cdev);
fail_cdev:
//cdev初始化异常，意味着设备号已经申请完成，应将其释放
printk("cdev init err,chrdev register/r/n");
unregister_chrdev_region(beep_dev.dev_id,DEVICE_CNT);
faile_devid:
//设备号申请异常，由于是第一步操作，不需要进行其他处理
printk("dev id err/r/n");
return ret;
}
static int beep_probe(struct platform_device *dev)
{
printk("beep driver device match/r/n");
beep_init(dev);
return 0;
}
static int beep_remove(struct platform_device *plt_dev)
{
printk("beep driver remove/r/n");
gpio_set_value(beep_dev.beep_gpio,1);
cdev_del(&beep_dev.cdev);
unregister_chrdev_region(beep_dev.dev_id,DEVICE_CNT);
device_destroy(beep_dev.class,beep_dev.dev_id);
class_destroy(beep_dev.class);
gpio_free(beep_dev.beep_gpio);
return 0;
}
struct of_device_id beep_of_match[] = {
{.compatible = "alientek,beep"},
{/*Sentinel*/},                  //结尾标识符
};
static struct platform_driver beepdriver = {
.driver = {
.name = "imx6ull-led",              //无设备树时匹配驱动名称
.of_match_table = beep_of_match,  //设备树匹配表
},
.probe = beep_probe,
.remove = beep_remove,
};
static int __init leddriver_init(void)
{
//注册platform驱动
return platform_driver_register(&beepdriver);
}
static void __exit leddriver_exit(void)
{
platform_driver_unregister(&beepdriver);
}
module_init(leddriver_init);
module_exit(leddriver_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("ZZQ");

platform设备树驱动

其实现在这样就可以了，但是可以注意一下上面折叠的代码里有个地方

static int __init beep_init(struct platform_device *p_dev){}

在调用设备初始化的时候我往里面穿了个platform_device的设备指针，这时因为这个platform_device结构体里是包含了很多设备树信息供我们直接调用的，就不用再使用of函数从设备树获取信息了。

 可以看一下device结构体定义里面有下面一个成员

struct device_node    *of_node; /* associated device tree node */

所以我们可以直接用这个值来获取设备节点，而不用of函数

beep_dev.dev_nd = of_find_node_by_path("/beep");
beep_dev.dev_nd = p_dev->dev.of_node;

platform为我们提供了很多的接口去获取设备信息，我们可以慢慢去琢磨。