驱动高级Day02_平台总线式驱动开发_基础框架

平台总线式驱动开发_基础框架

  • 一、总线、设备、驱动
    • 1.1 初期解决思路:设备和驱动分离
    • 1.2 升级思路:根据设备树,在系统启动时自动产生每个节点对应的设备
  • 二、基本数据类型
  • 三、platform总线驱动
    • 3.1 核心数据类型之platform_device
    • 3.2 核心数据类型之platform_driver
  • 四、platform的三种匹配方式
  • 五、名称匹配之基础框架
    • hello_device.c
    • hello_driver.c
  • 六、名称匹配之led实例
    • Makefile
    • fs4412led_device.c
    • fs4412led_driver.c
    • leddrv.h
    • testled_app.c

一、总线、设备、驱动

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

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

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

驱动高级Day02_平台总线式驱动开发_基础框架_第1张图片

​ struct device来表示一个具体设备,主要提供具体设备相关的资源(如寄存器地址、GPIO、中断等等)

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

​ 带来的问题-------怎样将二者进行关联(匹配)?

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

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

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

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

理解方式:

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

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

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

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是一种虚拟总线,主要用来管理那些不需要时序通信的设备

基本结构图:
驱动高级Day02_平台总线式驱动开发_基础框架_第2张图片

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的三种匹配方式

驱动高级Day02_平台总线式驱动开发_基础框架_第3张图片

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成员必须设置

五、名称匹配之基础框架

hello_device.c

/*platform device框架*/
#include  
#include 
#include 
#include 

//定义资源数组

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 = {
	.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_LICENSE("GPL");
module_init(platform_device_init);
module_exit(platform_device_exit);


hello_driver.c

/*platform driver框架*/
#include  
#include 
#include 
#include 

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

	pres = platform_get_resource(dev,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_LICENSE("GPL");
module_init(platform_driver_init);
module_exit(platform_driver_exit);

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

驱动高级Day02_平台总线式驱动开发_基础框架_第4张图片
驱动高级Day02_平台总线式驱动开发_基础框架_第5张图片

六、名称匹配之led实例

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

驱动高级Day02_平台总线式驱动开发_基础框架_第6张图片
驱动高级Day02_平台总线式驱动开发_基础框架_第7张图片

Makefile

ifeq ($(KERNELRELEASE),)

ifeq ($(ARCH),arm)
KERNELDIR ?= /home/hsd/fs4412/linux-3.14
ROOTFS ?= /opt/4412/rootfs
else
KERNELDIR ?= /lib/modules/$(shell uname -r)/build
endif
PWD := $(shell pwd)

modules:
	$(MAKE) -C $(KERNELDIR) M=$(PWD) modules

modules_install:
	$(MAKE) -C $(KERNELDIR) M=$(PWD) modules INSTALL_MOD_PATH=$(ROOTFS) modules_install

clean:
	rm -rf  *.o  *.ko  .*.cmd  *.mod.*  modules.order  Module.symvers   .tmp_versions

else
CONFIG_MODULE_SIG=n

obj-m +=fs4412led_driver.o
obj-m +=fs4412led_device.o

endif

fs4412led_device.c

#include 
#include 
#include 
#include 
 
#define GPX1CON 0x11000C20
#define GPX1DAT 0x11000C24
 
#define GPX2CON 0x11000C40
#define GPX2DAT 0x11000C44
 
#define GPF3CON 0x114001E0
#define GPF3DAT 0x114001E4
 
void leds_dev_release (struct device *dev)
{
    printk("leds_dev_release recalled.\n");
}
 
struct resource leds_dev_res [] =
{
	[0] = {.start = GPX1CON,.end= GPX1CON + 3,.name="GPX1CON",.flags = IORESOURCE_MEM},
	[1] = {.start = GPX1DAT,.end= GPX1DAT + 3,.name="GPX1DAT",.flags = IORESOURCE_MEM},
 
    [2] = {.start = GPX2CON,.end= GPX2CON + 3,.name="GPX2CON",.flags = IORESOURCE_MEM},
	[3] = {.start = GPX2DAT,.end= GPX2DAT + 3,.name="GPX2DAT",.flags = IORESOURCE_MEM},
 
    [4] = {.start = GPF3CON,.end= GPF3CON + 3,.name="GPX3CON",.flags = IORESOURCE_MEM},
	[5] = {.start = GPF3DAT,.end= GPF3DAT + 3,.name="GPX3DAT",.flags = IORESOURCE_MEM},
 
};
 
struct platform_device leds_device = {
    .name = "leds",
    .dev.release = leds_dev_release,
    .resource = leds_dev_res,
    .num_resources = ARRAY_SIZE(leds_dev_res),
};
 
int __init leds_device_init(void)
{
    platform_device_register(&leds_device);
    return 0;
}
 
void __exit leds_device_exit(void)
{
    platform_device_unregister(&leds_device);
}
 
MODULE_LICENSE("GPL");
module_init(leds_device_init);
module_exit(leds_device_exit);

fs4412led_driver.c

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include "leddrv.h"
 
int major = 11, minor = 0, num = 1;
 
struct myled_dev
{
	struct cdev mydev;
 
	volatile unsigned long *pled2_con;
	volatile unsigned long *pled2_dat;
 
	volatile unsigned long *pled3_con;
	volatile unsigned long *pled3_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 myopen(struct inode *pnode, struct file * pfile)
{
	pfile->private_data = (void *) (container_of(pnode->i_cdev, struct myled_dev, mydev));
 
	return 0;
}
 
int myclose(struct inode *pnode, struct file * pfile)
{
 
	return 0;
}
 
 
 
void led_on(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;
	}
}
 
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;
	}
}
 
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)
	{
		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;
}
 
void ioremap_ledreg(struct myled_dev *pmydev, struct platform_device *pdev)
{
	struct resource *pres = NULL;
 
	pres = platform_get_resource(pdev, IORESOURCE_MEM, 2);
	pmydev->pled2_con = ioremap(pres->start,4);
	pres = platform_get_resource(pdev, IORESOURCE_MEM, 3);
	pmydev->pled2_dat = ioremap(pres->start,4);
 
	pres = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	pmydev->pled3_con = ioremap(pres->start,4);
	pres = platform_get_resource(pdev, IORESOURCE_MEM, 1);
	pmydev->pled3_dat = ioremap(pres->start,4);
 
	pres = platform_get_resource(pdev, IORESOURCE_MEM, 4);
	pmydev->pled4_con = ioremap(pres->start,4);
	pres = platform_get_resource(pdev, IORESOURCE_MEM, 5);
	pmydev->pled4_dat = ioremap(pres->start,4);
 
	pmydev->pled5_con = pmydev->pled4_con;
	pmydev->pled5_dat = pmydev->pled4_dat;
}
 
void iounmap_ledreg(struct myled_dev *pmydev)
{
	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;
}
 
void set_output_ledconreg(struct myled_dev *pmydev)
{
	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);
}
 
struct file_operations myops = {
	.owner = THIS_MODULE,
	.open = myopen,
	.release = myclose,
	.unlocked_ioctl = myled_ioctl,
};
 
int myled_probe(struct platform_device *pdev)
{
	int ret = 0;
	dev_t devno = MKDEV(major,minor);
	ret = register_chrdev_region(devno, num, "myled");
 
	if(ret)
	{
		ret = alloc_chrdev_region(&devno, minor, num, "myled");
		if(ret)
		{
			printk("devno failed.\n");
			return -1;
		}
		major = MAJOR(devno);
		minor = MINOR(devno);
	}
 
	pgmydev = (struct myled_dev *) kmalloc(sizeof(struct myled_dev), GFP_KERNEL);
	if(pgmydev == NULL)
	{
		unregister_chrdev_region(devno, num);
		printk("kmalloc failed.\n");
		return -1;
	}
	memset(pgmydev,0,sizeof(struct myled_dev));
 
	cdev_init(&pgmydev->mydev,&myops);
	pgmydev->mydev.owner = THIS_MODULE;
	cdev_add(&pgmydev->mydev,devno,num);
 
	/*ioremap*/
	ioremap_ledreg(pgmydev,pdev);
 
	/*set gpio output*/
	set_output_ledconreg(pgmydev);
 
	return 0;
}
 
int myled_remove(struct platform_device *pdev)
{
	dev_t devno = MKDEV(major,minor);
 
	iounmap_ledreg(pgmydev);
 
	cdev_del(&pgmydev->mydev);
 
	kfree(pgmydev);
	pgmydev = NULL;
 
	unregister_chrdev_region(devno, num);
 
	return 0;
}
 
struct platform_driver leds_driver = {
	.driver.name = "leds",
	.probe = myled_probe,
	.remove = myled_remove,
};
 
int __init myled_init(void)
{
	platform_driver_register(&leds_driver);
	return 0;
}
 
void __exit myled_exit(void)
{
	platform_driver_unregister(&leds_driver);
}
 
MODULE_LICENSE("GPL");
MODULE_AUTHOR("imysy_22");
 
module_init(myled_init);
module_exit(myled_exit);


leddrv.h

#ifndef LED_DRIVER_H
#define LED_DRIVER_H

#define LED_DEV_MAGIC 'g'

#define MY_LED_OFF _IO(LED_DEV_MAGIC,0)
#define MY_LED_ON  _IO(LED_DEV_MAGIC,1)

#endif


testled_app.c

#include 
#include 
#include 
#include 
#include "leddrv.h"
#include 
#include 

int main(int argc,char *argv[])
{
	int fd = -1;
	int onoff = 0;
	int no = 0;
	
	if(argc < 4)
	{
		printf("The argument is too few\n");
		return -1;
	}
	sscanf(argv[2],"%d",&onoff);
	sscanf(argv[3],"%d",&no);

	if(no < 2 || no > 5)
	{
		printf("len-on is invalid\n");
		return 2;
	}
	fd = open(argv[1],O_RDONLY);
	if(fd < 0)
	{
		printf("open %s failed\n",argv[1]);
		return 3;
	}
	
	if(onoff)
	{
		ioctl(fd,MY_LED_ON,no);
	}
	else
	{
		ioctl(fd,MY_LED_OFF,no);
	}

	close(fd);
	fd = -1;
	return 0;
}

你可能感兴趣的:(Liunx,驱动开发)