您现在的位置是：首页 > 硬件

当前栏目

嵌入式（驱动开发）（平台总线式驱动开发_基础框架_ID匹配和设备树匹配）

2023-09-11 14:15:47 时间

一、总线、设备、驱动

硬编码式的驱动开发带来的问题：

垃圾代码太多
结构不清晰
一些统一设备功能难以支持
开发效率低下

1.1 初期解决思路：设备和驱动分离

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LCzmy7ls-1669097501089)(.\SOC架构图.jpg)]$
struct device来表示一个具体设备，主要提供具体设备相关的资源（如寄存器地址、GPIO、中断等等）

struct device_driver来表示一个设备驱动，一个驱动可以支持多个操作逻辑相同的设备

带来的问题-------怎样将二者进行关联（匹配）？

硬件上同一总线上的设备遵循一致的时序通信，在其基础上增加管理设备和驱动的软件功能

于是引入总线（bus），各种总线的核心框架由内核来实现，通信时序一般由SOC供应商支持

内核中用struct bus_type来表示一种总线，总线可以是实际存在的总线，也可以是虚拟总线：

实际总线：提供时序通信方式 + 管理设备和驱动
虚拟总线：仅用来管理设备和驱动（最核心的作用之一就是完成设备和驱动的匹配）

理解方式：

设备：提供硬件资源——男方

驱动：提供驱动代码——女方

总线：匹配设备和驱动——婚介所：提供沟通机制，完成拉郎配

1.2 升级思路：根据设备树，在系统启动时自动产生每个节点对应的设备

初期方案，各种device需要编码方式注册进内核中的设备管理结构中，为了进一步减少这样的编码，引进设备树

二、基本数据类型

2.1 struct device

struct device 
{
	struct bus_type	*bus;	//总线类型
	dev_t			devt;	//设备号
	struct device_driver *driver;	//设备驱动
    struct device_node  *of_node;//设备树中的节点，重要
	void	(*release)(struct device *dev);//删除设备，重要
    //.......
}；

2.2 struct device_driver

struct device_driver 
{
	const char		*name;	//驱动名称，匹配device用，重要
	struct bus_type	*bus;    //总线类型
	struct module		*owner;	//模块THIS_MODULE 
	const struct of_device_id	*of_match_table;//用于设备树匹配 of_match_ptr(某struct of_device_id对象地址) 重要
    //......
};

struct of_device_id
{
	char name[32];//设备名
	char type[32];//设备类型
	char compatible[128]; //用于device和driver的match，重点
};
//用到结构体数组，一般不指定大小，初始化时最后加{}表示数组结束

三、platform总线驱动

platform是一种虚拟总线，主要用来管理那些不需要时序通信的设备

基本结构图：
$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7kS4IbZj-1669097501093)(.\platform基本结构.gif)]$

3.1 核心数据类型之platform_device

struct platform_device 
{
    const char    *name;    		//匹配用的名字
    int        id;					//设备id,用于在该总线上同名的设备进行编号，如果只有一个设备，则为-1
    struct device    dev;   		//设备模块必须包含该结构体
    struct resource    *resource;	//资源结构体 指向资源数组
    u32        num_resources;		//资源的数量 资源数组的元素个数
    const struct platform_device_id    *id_entry;//设备八字
};

struct platform_device_id
{
	char name[20];//匹配用名称
	kernel_ulong_t driver_data;//需要向驱动传输的其它数据
};

struct resource 
{
	resource_size_t start;  //资源起始位置   
	resource_size_t end;   //资源结束位置
	const char *name;      
	unsigned long flags;   //区分资源是什么类型的
};
 
#define IORESOURCE_MEM        0x00000200
#define IORESOURCE_IRQ        0x00000400 
/*
flags 指资源类型，我们常用的是 IORESOURCE_MEM、IORESOURCE_IRQ  这两种。start 和 end 的含义会随着 flags而变更，如

a -- flags为IORESOURCE_MEM 时，start 、end 分别表示该platform_device占据的内存的开始地址和结束值；注意不同MEM的地址值不能重叠

b -- flags为 IORESOURCE_IRQ   时，start 、end 分别表示该platform_device使用的中断号的开始地址和结束值
*/

/**
 *注册：把指定设备添加到内核中平台总线的设备列表，等待匹配,匹配成功则回调驱动中probe；
 */
int platform_device_register(struct platform_device *);
/**
 *注销：把指定设备从设备列表中删除，如果驱动已匹配则回调驱动方法和设备信息中的release；
 */
void platform_device_unregister(struct platform_device *);

struct resource *platform_get_resource(struct platform_device *dev,unsigned int type, unsigned int num);
/*
	功能：获取设备资源
	参数：dev:平台驱动
		type:获取的资源类型
		num:对应类型资源的序号（如第0个MEM、第2个IRQ等，不是数组下标）
	返回值：成功：资源结构体首地址,失败:NULL
*/

3.2 核心数据类型之platform_driver

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;  //能够支持的设备八字数组，用到结构体数组，一般不指定大小，初始化时最后加{}表示数组结束
};

int platform_driver_register(struct platform_driver*pdrv);
/*
	功能：注册平台设备驱动
	参数：pdrv:平台设备驱动结构体
	返回值：成功：0
	失败：错误码
*/
void platform_driver_unregister(struct platform_driver*pdrv);

四、platform的三种匹配方式

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0xiFWJG5-1669097501095)(.\driver和device.jpg)]$
2.1 名称匹配：一个驱动只对应一个设备 ----- 优先级最低

2.2 id匹配（可想象成八字匹配）：一个驱动可以对应多个设备 ------优先级次低

device模块中，id的name成员必须与struct platform_device中的name成员内容一致

因此device模块中，struct platform_device中的name成员必须指定

driver模块中，struct platform_driver成员driver的name成员必须指定，但与device模块中name可以不相同

2.3 设备树匹配：内核启动时根据设备树自动产生的设备 ------ 优先级最高

使用compatible属性进行匹配，注意设备树中compatible属性值不要包含空白字符

id_table可不设置，但struct platform_driver成员driver的name成员必须设置

五、名称匹配之基础框架

/*platform device框架*/
#include <linux/module.h> 
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/platform_device.h>

//定义资源数组

static void device_release(struct device *dev)
{
	printk("platform: device release\n");
}

struct resource hello_dev_res[] = 
{
	[0] = {.start = 0x1000,.end = 0x1003,.name = "reg1",.flags = IORESOURCE_MEM},
	[1] = {.start = 0x2000,.end = 0x2003,.name = "reg2",.flags = IORESOURCE_MEM},
	[2] = {.start = 10,.end = 10,.name = "irq1",.flags = IORESOURCE_IRQ},
	[3] = {.start = 0x3000,.end = 0x3003,.name = "reg3",.flags = IORESOURCE_MEM},
	[4] = {.start = 100,.end = 100,.name = "irq2",.flags = IORESOURCE_IRQ},
	[5] = {.start = 62,.end = 62,.name = "irq3",.flags = IORESOURCE_IRQ},
};

struct platform_device test_device = {
	.id = -1,
	.name = "test_device",//必须初始化
	.dev.release = device_release, 
	.resource = hello_dev_res,
	.num_resources = ARRAY_SIZE(hello_dev_res),
};

static int __init platform_device_init(void)
{
	platform_device_register(&test_device);
	return 0;
}

static void __exit platform_device_exit(void)
{
	platform_device_unregister(&test_device);
}

module_init(platform_device_init);
module_exit(platform_device_exit);
MODULE_LICENSE("Dual BSD/GPL");

/*platform driver框架*/
#include <linux/module.h> 
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/platform_device.h>

static int driver_probe(struct platform_device *dev)	  //设备和驱动匹配成功之后调用该函数		
{
	struct resource *pres = NULL;
	
	printk("platform: match ok!\n");
	
	pres = platform_get_resource(p_pltdev,IORESOURCE_MEM,2);	//2不是下标是第几个MEM资源
	printk("res.start = 0x%x\n",(unsigned int)pres->start);	

	pres = platform_get_resource(p_pltdev,IORESOURCE_IRQ,2);	//从dev里面获取信息设备信息
	printk("res.start = %d\n",(int)pres->start);	

	return 0;
}

static int driver_remove(struct platform_device *dev)		//设备卸载了调用该函数
{
	printk("platform: driver remove\n");
	return 0;
}

struct platform_driver test_driver = 				//提供一些函数指针指向用户自己编写的函数
{
	.driver.name = "test_device", //必须初始化
	.probe = driver_probe,
	.remove = driver_remove,
};

static int __init platform_driver_init(void)
{
	platform_driver_register(&test_driver);
	return 0;
}

static void __exit platform_driver_exit(void)
{
	platform_driver_unregister(&test_driver);
}

module_init(platform_driver_init);
module_exit(platform_driver_exit);
MODULE_LICENSE("Dual BSD/GPL");

设备中增加资源，驱动中访问资源

六、名称匹配之led实例

/*platform device框架*/
#include <linux/module.h> 
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/platform_device.h>

#define GPX1CON 0X11000C20 		//寄存器地址
#define GPX1DAT 0X11000C24

#define GPX2CON 0X11000C40
#define GPX2DAT 0X11000C44

#define GPF3CON 0X114001E0
#define GPF3DAT 0X114001E4


static void device_release(struct device *dev)
{
	printk("platform: device release\n");
}

struct resource fs4412leds_dev_res[] = 		//设备的资源
{
	[0] = {.start = GPX1CON ,.end = GPX1CON + 3,.name = "GPX1CON",.flags = IORESOURCE_MEM},  //IORESOURCE_MEM是寄存器
	[1] = {.start = GPX1DAT ,.end = GPX1DAT + 3,.name = "GPX1DAT",.flags = IORESOURCE_MEM},	 //.start起始地址 .end结束地址 

	[2] = {.start = GPX2CON ,.end = GPX2CON + 3,.name = "GPX2CON",.flags = IORESOURCE_MEM},  //IORESOURCE_MEM是寄存器
	[3] = {.start = GPX2DAT ,.end = GPX2DAT + 3,.name = "GPX2DAT",.flags = IORESOURCE_MEM},
	
	[4] = {.start = GPF3CON ,.end = GPF3CON + 3,.name = "GPF3CON",.flags = IORESOURCE_MEM},  //IORESOURCE_MEM是寄存器
	[5] = {.start = GPF3DAT ,.end = GPF3DAT + 3,.name = "GPF3DAT",.flags = IORESOURCE_MEM},
};

struct platform_device test_device = {		//设备的操作函数 
	.id = -1,
	.name = "fs4412leds",//必须初始化，设备与驱动一致，用于匹配
	.dev.release = device_release, 
	.resource = fs4412leds_dev_res,
	.num_resources = ARRAY_SIZE(fs4412leds_dev_res),
};

static int __init platform_device_init(void)
{
	platform_device_register(&test_device);
	return 0;
}

static void __exit platform_device_exit(void)
{
	platform_device_unregister(&test_device);
}

module_init(platform_device_init);
module_exit(platform_device_exit);
MODULE_LICENSE("Dual BSD/GPL");

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <linux/platform_device.h>
#include <linux/wait.h>
#include <linux/sched.h>
#include <linux/poll.h>
#include <asm/uaccess.h>
#include <asm/atomic.h>
#include <linux/slab.h>
#include <linux/mm.h>
#include <linux/io.h>
#include "leddrv.h"   //自己写的.h用“”引用，库用<>引用

int major = 11;			//主设备号
int minor = 0;			//次设备号
int myled_num = 1;		//设备数量

struct myled_dev		//led设备结构体
{
	struct cdev mydev;	//设备结构体
	
	volatile unsigned long *pled2_con;   //volatile：防止编译器优化
	volatile unsigned long *pled2_dat;		

  	volatile unsigned long *pled3_con;	 //con寄存器地址
	volatile unsigned long *pled3_dat;	 //dat寄存器地址	

    volatile unsigned long *pled4_con;
	volatile unsigned long *pled4_dat;

    volatile unsigned long *pled5_con;
	volatile unsigned long *pled5_dat;      
};

struct myled_dev *pgmydev = NULL;     //定义一个设备结构体变量，用于调用结构体成员

int myled_open(struct inode *pnode,struct file *pfile)	//打开文件函数
{																					//inode类型结构体中i_cdev是mydev的地址														
	pfile->private_data = (void *) (container_of(pnode->i_cdev,struct myled_dev,mydev));//知道成员地址可以得出结构体地址
    return 0;																		
}

int myled_close(struct inode *pnode,struct file *pfile)
{
	return 0;
}
//参数一：灯设备机构体。参数二：打开那个灯(2-5)
void led_on(struct myled_dev *pmydev,int ledno)			//灯打开函数
{
	switch(ledno)
	{
		case 2:			//读出pmydev->pled2_dat寄存器值或上1左移7位，然后在写入pmydev->pled2_dat寄存器实现点灯
       			writel(readl(pmydev->pled2_dat) | (0x1 << 7),pmydev->pled2_dat);
			break;
		case 3:
        		writel(readl(pmydev->pled3_dat) | (0x1),pmydev->pled3_dat);
			break;
		case 4:
 		        writel(readl(pmydev->pled4_dat) | (0x1 << 4),pmydev->pled4_dat);
			break;
		case 5:
		        writel(readl(pmydev->pled5_dat) | (0x1 << 5),pmydev->pled5_dat);
			break;
	}
}

void led_off(struct myled_dev *pmydev,int ledno)		//灯关闭函数
{
	switch(ledno)
	{
		case 2:
       			writel((readl(pmydev->pled2_dat) & (~(0x1 << 7))),pmydev->pled2_dat);
			break;
		case 3:
        		writel((readl(pmydev->pled3_dat) & (~(0x1))),pmydev->pled3_dat);
			break;
		case 4:
 		        writel((readl(pmydev->pled4_dat) & (~(0x1 << 4))),pmydev->pled4_dat);
			break;
		case 5:
		        writel((readl(pmydev->pled5_dat) & (~(0x1 << 5))),pmydev->pled5_dat);
			break;
	}
}
//参数一：文件描述符用于寻找设备结构体地址 参数二：app对驱动进行控制的参数 参数三：整型变量app传参操作驱动里面的函数
long myled_ioctl(struct file *pfile,unsigned int cmd,unsigned long arg)     //控制函数
{
	struct myled_dev *pmydev = (struct myled_dev *)pfile->private_data;		
	
	if(arg < 2 || arg > 5)		//要点亮几号灯范围2-5
	{
		return -1;
	}
	switch (cmd)					//进行开灯或者关灯
	{
		case MY_LED_ON:
			led_on(pmydev,arg);
			break;
		case MY_LED_OFF:
			led_off(pmydev,arg);
			break;	
		default:
			return -1;
	}

	return 0;
}
struct file_operations myops = {					//设备的操作函数，自己写的子函数必须在这儿与内核函数关联起来才能被调用
        .owner = THIS_MODULE,
        .open = myled_open,
        .release = myled_close,
		.unlocked_ioctl = myled_ioctl,
};
void ioremap_ledreg(struct myled_dev *pmydev,struct platform_device *p_pltdev)			//将设备结构体成员变量进行对设备硬件地址的映射
{
		struct resource *pres = NULL;
		
		pres = platform_get_resource(p_pltdev,IORESOURCE_MEM,2);
        pmydev->pled2_con = ioremap(pres->start,4);						//ioreamp参数一：十六进制地址的值  参数二：地址所占字节
        
        pres = platform_get_resource(p_pltdev,IORESOURCE_MEM,3);
        pmydev->pled2_dat = ioremap(pres->start,4);

		pres = platform_get_resource(p_pltdev,IORESOURCE_MEM,0);
        pmydev->pled3_con = ioremap(pres->start,4);
        
        pres = platform_get_resource(p_pltdev,IORESOURCE_MEM,1);
        pmydev->pled3_dat = ioremap(pres->start,4);

		pres = platform_get_resource(p_pltdev,IORESOURCE_MEM,4);
        pmydev->pled4_con = ioremap(pres->start,4);
        pres = platform_get_resource(p_pltdev,IORESOURCE_MEM,5);
        pmydev->pled4_dat = ioremap(pres->start,4);      

        pmydev->pled5_con = pmydev->pled4_con;
        pmydev->pled5_dat = pmydev->pled4_dat;            
}

void set_output_ledconreg(struct myled_dev *pmydev)			//io口初始化函数
{
        writel((readl(pmydev->pled2_con) & (~(0xF << 28))) | (0X1 << 28),pmydev->pled2_con);
        writel((readl(pmydev->pled3_con) & (~(0xF))) | (0X1),pmydev->pled3_con);
        writel((readl(pmydev->pled4_con) & (~(0xF << 16))) | (0X1 << 16),pmydev->pled4_con);
        writel((readl(pmydev->pled5_con) & (~(0xF << 20))) | (0X1 << 20),pmydev->pled5_con);

        writel((readl(pmydev->pled2_dat) & (~(0x1 << 7))),pmydev->pled2_dat);
        writel((readl(pmydev->pled3_dat) & (~(0x1))),pmydev->pled3_dat);
        writel((readl(pmydev->pled4_dat) & (~(0x1 << 4))),pmydev->pled4_dat);
        writel((readl(pmydev->pled5_dat) & (~(0x1 << 5))),pmydev->pled5_dat);


}

void iounmap_ledreg(struct myled_dev *pmydev)			//io口清除函数
{
        iounmap(pmydev->pled2_con);
        pmydev->pled2_con = NULL;
        iounmap(pmydev->pled2_dat);
        pmydev->pled2_dat = NULL;       

        iounmap(pmydev->pled3_con);
        pmydev->pled3_con = NULL;
        iounmap(pmydev->pled3_dat);
        pmydev->pled3_dat = NULL;      

        iounmap(pmydev->pled4_con);
        pmydev->pled4_con = NULL;
        iounmap(pmydev->pled4_dat);
        pmydev->pled4_dat = NULL;     

        pmydev->pled5_con = NULL;
        pmydev->pled5_dat = NULL;      
}


int fs4412leds_driver_probe(struct platform_device *p_pltdev)	
{
        int ret = 0;
        dev_t devno = MKDEV(major,minor);				//将主次设备号合成一个32位的设备号

        /*申请设备号*/
        ret = register_chrdev_region(devno,myled_num,"myled");	
        if(ret)
        {
                ret = alloc_chrdev_region(&devno,minor,myled_num,"myled");		//手动申请失败时自动申请
                if(ret)
                {
                        printk("get devno failed\n");
                        return -1;
                }
                major = MAJOR(devno);
        }

		pgmydev = (struct myled_dev *)kmalloc(sizeof(struct myled_dev),GFP_KERNEL);//给设备结构体申请一块内存，kmalloc是申请小内存效率高。GFP_KERNEL是可以进行忙等待，因为这个是任务上下文
		if(NULL == pgmydev)			//申请失败
		{
			unregister_chrdev_region(devno,myled_num);	//取消注册设备号
			printk("kmalloc failed\n");
			return -1;
		}

		memset(pgmydev,0,sizeof(struct myled_dev));		//给结构体变量赋初值
	
	    /*给struct cdev对象指定操作函数集*/
	    cdev_init(&pgmydev->mydev,&myops);				
	
	    /*将struct cdev对象添加到内核对应的数据结构里*/
	    pgmydev->mydev.owner = THIS_MODULE;
        cdev_add(&pgmydev->mydev,devno,myled_num);
        
        /*ioremap*/
        ioremap_ledreg(pgmydev,p_pltdev);
        /**/
        set_output_ledconreg(pgmydev);
        return 0;
}

int fs4412leds_driver_remove(struct platform_device *p_pltdev)
{
        dev_t devno = MKDEV(major,minor);

        /*iounmap*/
        iounmap_ledreg(pgmydev);
        
        cdev_del(&pgmydev->mydev);

        unregister_chrdev_region(devno,myled_num);

        kfree(pgmydev);
        pgmydev = NULL;
		
		return 0;
}

struct platform_driver fs4412leds_driver = 
{
	.driver.name = "fs4412leds", //必须初始化
	.probe = fs4412leds_driver_probe,
	.remove = fs4412leds_driver_remove,
}

int __init fs4412leds_driver_init(void)			
{
	platform_driver_register(&fs4412leds_driver);
	return 0;
}

void __exit fs4412leds_driver_exit(void)
{
	platform_driver_unregister(&fs4412leds_driver);
}

MODULE_LICENSE("GPL");

module_init(fs4412leds_driver_init);
module_exit(fs4412leds_driver_exit);

一、ID匹配之框架代码

id匹配（可想象成八字匹配）：一个驱动可以对应多个设备 ------优先级次低

注意事项：

device模块中，id的name成员必须与struct platform_device中的name成员内容一致，因此device模块中，struct platform_device中的name成员必须指定
driver模块中，struct platform_driver成员driver的name成员必须指定，但与device模块中name可以不相同

/*platform device框架*/
#include <linux/module.h> 
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/platform_device.h>

//定义资源数组

static void device_release(struct device *dev)
{
	printk("platform: device release\n");
}

struct platform_device_id test_id = {
    .name = "test_device",
};

struct platform_device test_device = {
	.name = "test_device",//必须初始化，名字与上面那个必须一致
	.dev.release = device_release, 
    .id_entry = &test_id,
};

static int __init platform_device_init(void)
{
	platform_device_register(&test_device);
	return 0;
}

static void __exit platform_device_exit(void)
{
	platform_device_unregister(&test_device);
}

module_init(platform_device_init);
module_exit(platform_device_exit);
MODULE_LICENSE("Dual BSD/GPL");

/*platform driver框架*/
#include <linux/module.h> 
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/platform_device.h>

static int driver_probe(struct platform_device *dev)
{
	printk("platform: match ok!\n");
	return 0;
}

static int driver_remove(struct platform_device *dev)
{
	printk("platform: driver remove\n");
	return 0;
}

struct platform_device_id testdrv_ids[] = 
{
	[0] = {.name = "test_device"},
    [1] = {.name = "abcxyz"},
    [2] = {}, //means ending
};

struct platform_driver test_driver = {
	.probe = driver_probe,
	.remove = driver_remove,
	.driver = {
		.name = "xxxxx", //必须初始化
	},
    .id_table = testdrv_ids,
};

static int __init platform_driver_init(void)
{
	platform_driver_register(&test_driver);
	return 0;
}

static void __exit platform_driver_exit(void)
{
	platform_driver_unregister(&test_driver);
}

module_init(platform_driver_init);
module_exit(platform_driver_exit);
MODULE_LICENSE("Dual BSD/GPL");

用到结构体数组，一般不指定大小，初始化时最后加{}表示数组结束

设备中增加资源，驱动中访问资源

二、ID匹配之led驱动

/*platform device框架*/
#include <linux/module.h> 
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/platform_device.h>

//定义资源数组

static void device_release(struct device *dev)
{
	printk("platform: device release\n");
}

struct resource hello_dev_res[] = 
{
	[0] = {.start = 0x1000,.end = 0x1003,.name = "reg1",.flags = IORESOURCE_MEM},
	[1] = {.start = 0x2000,.end = 0x2003,.name = "reg2",.flags = IORESOURCE_MEM},
	[2] = {.start = 10,.end = 10,.name = "irq1",.flags = IORESOURCE_IRQ},
	[3] = {.start = 0x3000,.end = 0x3003,.name = "reg3",.flags = IORESOURCE_MEM},
	[4] = {.start = 100,.end = 100,.name = "irq2",.flags = IORESOURCE_IRQ},
	[5] = {.start = 62,.end = 62,.name = "irq3",.flags = IORESOURCE_IRQ},
};

struct platform_device_id hello_id = {				//id匹配结构体
	.name = "hello",
};

struct platform_device test_device = {
	.id = -1,
	.name = "hello",//必须初始化
	.dev.release = device_release, 
	.resource = hello_dev_res,
	.num_resources = ARRAY_SIZE(hello_dev_res),

	.id_entry = &hello_id ,		//id访问
};

static int __init platform_device_init(void)
{
	platform_device_register(&test_device);
	return 0;
}

static void __exit platform_device_exit(void)
{
	platform_device_unregister(&test_device);
}

module_init(platform_device_init);
module_exit(platform_device_exit);
MODULE_LICENSE("Dual BSD/GPL");

/*platform driver框架*/
#include <linux/module.h> 
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/platform_device.h>

static int driver_probe(struct platform_device *dev)	  //设备和驱动匹配成功之后调用该函数		
{
	struct resource *pres = NULL;
	
	printk("platform: match ok!\n");
	
	pres = platform_get_resource(p_pltdev,IORESOURCE_MEM,2);	//2不是下标是第几个MEM资源
	printk("res.start = 0x%x\n",(unsigned int)pres->start);	

	pres = platform_get_resource(p_pltdev,IORESOURCE_IRQ,2);	//从dev里面获取信息设备信息
	printk("res.start = %d\n",(int)pres->start);	

	return 0;
}

static int driver_remove(struct platform_device *dev)		//设备卸载了调用该函数
{
	printk("platform: driver remove\n");
	return 0;
}

struct platform_device_id hellodrv_ids[]	//id匹配结构体
{
	[0] = {.name = "hello"},
	[1] = {.name = "xyz"},
	[2] = {},
};

struct platform_driver test_driver = 				//提供一些函数指针指向用户自己编写的函数
{
	.driver.name = "test_device", //必须初始化
	.probe = driver_probe,
	.remove = driver_remove,

	.id_table = hellodrv_ids,   //只要是上面那个结构体的字符串都能匹配
};

static int __init platform_driver_init(void)
{
	platform_driver_register(&test_driver);
	return 0;
}

static void __exit platform_driver_exit(void)
{
	platform_driver_unregister(&test_driver);
}

module_init(platform_driver_init);
module_exit(platform_driver_exit);
MODULE_LICENSE("Dual BSD/GPL");

三、设备树匹配

设备树匹配：内核启动时根据设备树自动产生的设备 ------ 优先级最高

注意事项：

无需编写device模块，只需编写driver模块
使用compatible属性进行匹配，注意设备树中compatible属性值不要包含空白字符
id_table可不设置，但struct platform_driver成员driver的name成员必须设置

/*platform driver框架*/
#include <linux/module.h>  
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/platform_device.h>

static int driver_probe(struct platform_device *dev)
{
	printk("platform: match ok!\n");
	return 0;
}

static int driver_remove(struct platform_device *dev)
{
	printk("platform: driver remove\n");
	return 0;
}

struct platform_device_id testdrv_ids[] = 	//ID匹配
{
	[0] = {.name = "test_device"},
    [1] = {.name = "abcxyz"},
    [2] = {}, //means ending
};

struct of_device_id test_of_ids[] =    //设备树匹配
{
	[0] = {.compatible = "xyz,abc"},		//这儿要写设备树里面的名称compatible=xxx
    [1] = {.compatible = "qwe,opq"},
    [2] = {},
};

struct platform_driver test_driver = {
	.probe = driver_probe,
	.remove = driver_remove,
	.driver = {
		.name = "xxxxx", //必须初始化
        .of_match_table = test_of_ids,
	},
};

static int __init platform_driver_init(void)
{
	platform_driver_register(&test_driver);
	return 0;
}

static void __exit platform_driver_exit(void)
{
	platform_driver_unregister(&test_driver);
}

module_init(platform_driver_init);
module_exit(platform_driver_exit);
MODULE_LICENSE("Dual BSD/GPL");

四、设备树匹配之led驱动

五、一个编写驱动用的宏

struct platform_driver xxx = {  
    ...
};
module_platform_driver(xxx);
//最终展开后就是如下形式：
static int __init xxx_init(void)
{
        return platform_driver_register(&xxx);
}
module_init(xxx_init);
static void __exit xxx_init(void)
{
        return platform_driver_unregister(&xxx);
}
module_exit(xxx_exit)

;

猜你喜欢

同步多个git仓库
混淆代码
输出一个金字塔
SpringCloud的入门学习之概念理解、Eureka服务注册与发现入门
OpenCV图像像素映射
【PHP面向对象(OOP)编程入门教程】16.__toString()方法
Opencv项目实战：19 手势控制鼠标
【刷题】【LeetCode】000-十大经典排序算法
webpack打包内存溢出的解决方法
3D游戏从入门到精通-16
1249. 亲戚（并查集）
使用直接排序法对一维数组进行排序
maven的groupid和artifactId
Zabbix之ZABBIX WEB界面安装
bash下如何使用bind[En]
PAT 1146 Topological Order[难]
[HTML5] Element id binding

相关主题

服务器设备
Linux设备驱动
Linux·设备驱动
在 Linux 中管理设备
linux字符设备驱动
linux 字符设备驱动
块设备驱动程序
新字符设备驱动
Linux驱动之设备树
Linux 内核类设备
Linux 内核设备驱动
iOS 获取设备信息
linux块设备驱动
Linux设备驱动（转）
linux 块设备驱动
linux驱动之LED驱动
驱动设备树
PCIE 设备
be设备
linux设备驱动2

zl程序教程

当前栏目

嵌入式（驱动开发）（平台总线式驱动开发_基础框架_ID匹配和设备树匹配）

一、总线、设备、驱动

1.1 初期解决思路：设备和驱动分离

1.2 升级思路：根据设备树，在系统启动时自动产生每个节点对应的设备

二、基本数据类型

三、platform总线驱动

3.1 核心数据类型之platform_device

3.2 核心数据类型之platform_driver

四、platform的三种匹配方式

五、名称匹配之基础框架

六、名称匹配之led实例

一、ID匹配之框架代码

二、ID匹配之led驱动

三、设备树匹配

四、设备树匹配之led驱动

五、一个编写驱动用的宏

相关文章