Linux驱动学习day7

复习和复现

今天重新复习了一下Linux中的面向对象/分离/分层思想，并且重新理解一下昨天学习的总线，platform_driver 和 platform_device 。

使用设备树来实现LED驱动 

这里主要先来看一下有关设备树的语法部分，一个根结点下面的结点，如果含有compatile属性，就会生成相应的platform_device ， 如果根节点下的结点的compatile属性中含有simple-bus ， "arm,amba-bus" ， “simple-mfd” , "isa" , "pci"等。该结点下的子节点也会生成对应的platform_device，看看图中mytest结点的compatile属性中含有simple-bus ， 那么其子节点mytest@0就会生成对应的platform_device ， 反之如i2c ， spi结点的子节点就不会生成对应的platform_device。

分析流程 

下面是大概的简要流程框图。

使用设备树来匹配platform_driver的一般流程设备树中 compatible = "atk,my_led"↓
of_platform_populate 创建 platform_device↓
platform_driver_register 注册驱动↓
platform_match 匹配 compatible↓
调用 myled_probe()

下面这个图是用来匹配的几个要素

1、通过 driver_override 强制匹配

如果 platform_device 中设置了 driver_override，则该字段会被用作强制绑定，只有与该字段字符串完全相同的 platform_driver.name 才会匹配成功。这种方式绕过了其他所有匹配逻辑，用于特定调试或临时需求。

/* When driver_override is set, only bind to the matching driver */if (pdev->driver_override)return !strcmp(pdev->driver_override, drv->name);

2、通过设备树中的 compatible 匹配

如果 platform_device 是由设备树生成的，并且驱动中定义了 of_match_table，内核会优先使用设备树节点中的 compatible 属性与驱动的 of_device_id 表进行匹配。这是设备树时代最常用、最可靠的匹配方式。

/* Attempt an OF style match first */if (of_driver_match_device(dev, drv))return 1;

3、通过 platform_device_id 匹配

如果设备不是通过设备树生成，而是通过手动注册的 platform_device，则系统会使用设备的 .name 字符串在驱动的 id_table 表中查找匹配项。

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

4、通过 device.name 与 driver.name 直接匹配

如果以上方式都未命中，内核会最后尝试直接比较 platform_device.name 与 platform_driver.driver.name 是否一致。

(strcmp(pdev->name, drv->name) == 0)

Linux内核关于匹配的源代码如下

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);
}

编写流程 

那么我们编写这种方法的时候，就可以不用使用之前设置板子引脚资源的board_demo.c和led_resource.h两个文件。主要编写设备树文件.dts ， chip_demo_gpio.c , led_template_drv.c

1、编写设备树文件.dts

找到各个板子的设备树文件，并将自己需要的设备树文件编写进去，设置compatile属性(让内核自动生成platform_device)。

#define GROUP_PIN(g , p) ((g<<16) | (p))
/ {myled@0{compatible = "my , myled";pin        = <GROUP_PIN(3 , 1)>;};myled@1{compatible = "my , myled";pin        = <GROUP_PIN(5 , 2)>;};
};

 2、编写chip_demo_gpio.c

这部分代码主要编写platform_driver结构体，并且要使用设备树在该结构体中的.driver成员中设置一个成员函数.of_match_table。这里不知道如何写这个，需要在内核其他代码中查找一下该函数的用法。模仿下面函数：

static const struct of_device_id imx_mmdc_dt_ids[] = {{ .compatible = "fsl,imx6q-mmdc", .data = (void *)&imx6q_data},{ .compatible = "fsl,imx6qp-mmdc", .data = (void *)&imx6qp_data},{ /* sentinel */ }
};static struct platform_driver imx_mmdc_driver = {.driver		= {.name	= "imx-mmdc",.of_match_table = imx_mmdc_dt_ids,},.probe		= imx_mmdc_probe,.remove		= imx_mmdc_remove,
};

改写：

static const struct of_device_id myled_match[] = {{ .compatible = "my , myled" },{},
};static struct platform_driver my_led_drv = {.probe		= my_led_drv_probe,.remove		= my_led_drv_remove,.driver		= {.name		= "my_led",.of_match_table = myled_match,},
};

3、led_template_drv.c

这部分不用需要改。按照之前的代码即可。

设备树编写LED驱动完整代码

1、chip_demo_gpio.c

#include <linux/gfp.h>
#include <linux/io.h>
#include <linux/of.h>
#include <asm/io.h>
#include <linux/module.h>
#include <linux/platform_device.h>
#include <linux/mod_devicetable.h>
#include "led_resource.h"
#include "led_opr.h"static int g_ledpins[100];
static int g_ledcnt = 0;void led_device_create(int minor);
void led_device_destroy(int minor);
void register_led_operations(struct fed_operations *opr);static int board_demo_led_init(int which)
{printk("%s \n" , __FUNCTION__);printk("init gpio : group %d , pin %d \n" , GROUP(g_ledpins[which]) , PIN(g_ledpins[which]));switch (GROUP(g_ledpins[which])) {case 0:{printk("init pin of group 0...\n");break;}case 1:{printk("init pin of group 1...\n");break;}case 2:{printk("init pin of group 2...\n");break;}}return 0;
}static int board_demo_led_ctl(int which , char status)
{//printk("%s :%d \n" , __FUNCTION__ , status);printk("set led %s: group %d , pin %d \n"  , status ? "on" : "off" , GROUP(g_ledpins[which]) , PIN(g_ledpins[which]));//printk("set led : group %d , pin %d \n" , GROUP(led_rsc->pin) , PIN(led_rsc->pin));switch (PIN(g_ledpins[which])) {case 0:{printk("set pin of group 0...\n");break;}case 1:{printk("set pin of group 1...\n");break;}case 2:{printk("set pin of group 2...\n");break;}}return 0;
}static struct fed_operations board_demo_led_opr = {.num  = 1,.init = board_demo_led_init,.ctl  = board_demo_led_ctl,
};struct fed_operations *get_board_led_opr(void)
{return &board_demo_led_opr;
}static int my_led_drv_probe(struct platform_device *pdev)
{/* get group and pin */int err = 0;int led_pin;struct device_node * np;np = pdev->dev.of_node;if(!np)return -1;err = of_property_read_u32(np, "pin", &led_pin);g_ledpins[g_ledcnt] = led_pin;/* device_create */led_device_create(g_ledcnt);g_ledcnt++;return 0;
}static int my_led_drv_remove(struct platform_device *pdev)
{int err = 0;int led_pin;int i;struct device_node * np;np = pdev->dev.of_node;if(!np)return -1;err = of_property_read_u32(np, "pin", &led_pin);for(i = 0 ; i < g_ledcnt ; i++){if(g_ledpins[i] == led_pin){led_device_destroy(i);g_ledpins[i] = -1;break;}}for(i = 0 ; i < g_ledcnt ; i++){if(g_ledpins[i] != -1)break;}if(i == g_ledcnt)g_ledcnt = 0;return 0;
}static const struct of_device_id myled_match[] = {{ .compatible = "my , myled" },{},
};static struct platform_driver my_led_drv = {.probe		= my_led_drv_probe,.remove		= my_led_drv_remove,.driver		= {.name		= "my_led",.of_match_table = myled_match,},
};static int __init led_device_init(void)
{int err;register_led_operations(&board_demo_led_opr);err = platform_driver_register(&my_led_drv);return 0;
}static void __exit led_device_exit(void)
{platform_driver_unregister(&my_led_drv);
}module_init(led_device_init);
module_exit(led_device_exit);
MODULE_LICENSE("GPL");

2、 led_template_drv.c

#include <linux/module.h>     // 最基本模块宏
#include <linux/kernel.h>     // printk
#include <linux/init.h>       // __init/__exit
#include <linux/fs.h>         // register_chrdev 等
#include <linux/uaccess.h>    // copy_to_user, copy_from_user
#include <linux/types.h>      // dev_t, bool 等类型
#include <linux/device.h>
#include "led_opr.h"static int major = 0;static struct class *myled_class;struct fed_operations *p_led_opr;/* funciton */static ssize_t led_drv_read (struct file *file, char __user *buf , size_t size, loff_t * offset)
{printk("%s %s %d\n" , __FILE__ , __FUNCTION__ , __LINE__);printk("read from drivers:%s %s\n" , __FILE__ , __FUNCTION__ );return 0;
}
/* write(fd , &val , 1) */
static ssize_t led_drv_write (struct file *file, const char __user *buf , size_t size, loff_t * offset)
{unsigned char status;unsigned int ret;struct inode * inode = file_inode(file);int minor = iminor(inode); printk("%s %s %d\n" , __FILE__ , __FUNCTION__ , __LINE__);ret = copy_from_user(&status, buf, 1);/* minior and status  */p_led_opr->ctl(minor , status);return 1;
}static int led_drv_open (struct inode *node, struct file *file)
{int minor = iminor(node);printk("%s %s %d\n" , __FILE__ , __FUNCTION__ , __LINE__);/* init LED */p_led_opr->init(minor);return 0;
}static int led_drv_close (struct inode *node, struct file *file)
{// printk("%s %s %d\n" , __FILE__ , __FUNCTION__ , __LINE__);return 0;
}/*  create struct file_operations */
static struct file_operations myled_drv = 
{.owner          = THIS_MODULE,.open           = led_drv_open,.read           = led_drv_read,.write          = led_drv_write,.release        = led_drv_close,
};/* register_chrdev */
static int __init led_init(void)
{major = register_chrdev(0 , "led_drv", &myled_drv);/* do not need mknod */if(!myled_class){myled_class = class_create(THIS_MODULE, "led_class");if (IS_ERR(myled_class)) {printk("failed to allocate class\n");unregister_chrdev(major, "led_class");return PTR_ERR(myled_class);}}/* struct device *device_create(struct class *class, struct device *parent,dev_t devt, void *drvdata, const char *fmt, ...) *///p_led_opr = get_board_led_opr();return 0;
}void led_device_create(int minor)
{device_create(myled_class , NULL , MKDEV(major, minor) , NULL , "myled%d" , minor); /* create node /dev/myled */
}
EXPORT_SYMBOL(led_device_create);void led_device_destroy(int minor)
{device_destroy(myled_class , MKDEV(major, minor));
}
EXPORT_SYMBOL(led_device_destroy);void register_led_operations(struct fed_operations *opr)
{p_led_opr = opr;
}
EXPORT_SYMBOL(register_led_operations);/* entry function */
static void __exit  led_exit(void)
{/* distroy void device_destroy(struct class *class, dev_t devt)*/printk("%s %s %d \n", __FILE__ , __FUNCTION__ , __LINE__);class_destroy(myled_class);unregister_chrdev(major, "led_drv");return;
}module_init(led_init);
module_exit(led_exit);
MODULE_LICENSE("GPL");//#warning "MODULE_LICENSE included in led_template_drv.c"

makefile

# 内核源码路径
KERN_DIR := /home/dd/RK3568/SDK/linux/rk3568_linux_sdk/kernel
CURRENT_PATH := $(shell pwd)# 驱动模块目标
obj-m := led_template_drv.o chip_demo_gpio.o # 源文件列表（注意 .o 后缀）
led_template_drv1-objs := led_template_drv.o chip_demo_gpio.o # 交叉编译工具链
CROSS_COMPILE ?= /home/dd/RK3568/SDK/linux/rk3568_linux_sdk/prebuilts/gcc/linux-x86/aarch64/gcc-linaro-6.3.1-2017.05-x86_64_aarch64-linux-gnu/bin/aarch64-linux-gnu-
ARCH ?= arm64# 默认目标：编译模块 + 用户程序
build: kernel_modules ledtest# 编译内核模块
kernel_modules:$(MAKE) -C $(KERN_DIR) M=$(CURRENT_PATH) ARCH=$(ARCH) CROSS_COMPILE=$(CROSS_COMPILE) modules# 编译用户态测试程序
ledtest: ledtest.c$(CROSS_COMPILE)gcc -o ledtest ledtest.c# 清理所有编译产物
clean:$(MAKE) -C $(KERN_DIR) M=$(CURRENT_PATH) ARCH=$(ARCH) CROSS_COMPILE=$(CROSS_COMPILE) cleanrm -f ledtest

编写字符驱动程序的三种方法

1、资源和驱动在同一个文件

2、资源使用platform_device指定，驱动用platform_driver实现

3、资源用设备树指定。驱动在platform_driver实现

设备树编写LED驱动具体操作

找到单板的设备树文件(如rk3568操作文件中讲到其设备树文件在~/RK3568/SDK/linux/rk3568_linux_sdk/kernel/arch/arm64/boot/dts/rockchip/rk3568-atk-evb1-ddr4-v10.dtsi)，保存完之后切换到SDK上层目录执行./build.sh kernel 编译一下新设备树的内核文件。

 将/kernel中的boot.img文件导入到PC端，然后将板子切换到LOADER模式，烧入新的boot.img。

重启加载之后就可以进入到/sys/firmware/devicetree/base/文件中，输入ls -ld *myled* ， 可以看到加载完成之后的设备结点，使用cat命令可以看到里面的内容。 

 

进入到/sys/devices/platform/myled文件中，加载驱动程序之后，该目录底下会自动生成一个driver目录。

可以看到这个目录的类型是l，也就是软连接，进入软连接的目录就可以看到其适配的设备文件myled@0 , myled@1了。接着使用ls /dev/myled*查看挂载好的设备文件。便可以使用ledtest对驱动进行读写操作等。