Linux下驱动:分层、分离机制学习笔记

最新推荐文章于 2024-05-15 11:31:49 发布

川渝小神丢

最新推荐文章于 2024-05-15 11:31:49 发布

阅读量2.6k

点赞数 2

分类专栏： Linux系统文章标签： linux 物联网链表

本文链接：https://blog.csdn.net/fengel_cs/article/details/50483301

版权

Linux系统专栏收录该内容

32 篇文章 6 订阅

订阅专栏

一、分层、分离的概念

分层即把硬件相关和相对稳定的东西给抽出来，并向上提供统一的接口，每一层专注于自己的事情，比如输入子系统。后续文章中会继续介绍相关例子；

分离即把硬件相关和相对稳定的东西给分离开来，实际上即是bus-dev-drv模型(平台总线、平台设备、平台驱动)，本文章中的led驱动即使用了此模型。

二、bus-dev-drv模型

在硬件相关部分(即硬件操作的部分，其实在drv中也会有操作硬件，只是基本上不用改动，比较稳定。要改硬件，一般改dev部分代码即可。)，入口函数中会调用platform_device_register→platform_device_add→device_add，device_add函数的作用如下：

（1）把device(结构体)放入bus(结构体)的dev链表中去。即注册。

（2）从bus(结构体)的drv(结构体)链表中取出每个drv，用bus的match函数判断drv能否支持此dev。

（3）如果支持(实际上是判断结构的.name成员是否一样)，调用drv(结构体)的probe函数。

在driver相关部分，会向上注册一个结构体，实际上就是调用platform_driver_register函数→driver_register函数把driver结构体放到bus 里(结构体)的driver链表里：

（1）把driver(结构体)放入bus(结构体)的drv链表中去。即注册。

（2）从bus(结构体)的dev(结构体)链表中取出每个dev，跟此drv一一比较（用bus的match函数去比较）。

（3）如果支持，调用drv(结构体)的probe函数。

总的来说，上述只不过是左右建立一种联系的机制，在probe里面做什么完全由自己决定，比如打印一句话，注册一个字符设备，或者注册一个input_dev结构体。如果要修改硬件，只需要修改硬件相关的代码即可，右边比较稳定的代码可以不动，这样大家就有一种约定，其实不管是device还是driver(它们只是一个结构体而已)。

三、bus-dev-drv模型具体实例

以一个LED驱动的例子说明分层分离的概念，源码分为led_dev.c，led_drv.c，led_test.c。led_dev.c为硬件相关，led_drv.c为右边较稳定的部分代码，led_test.c为应用程序测试代码。基本功能是点亮或关闭LED灯。

其实这个程序完全可以用简单的字符型驱动程序框架实现，这里只是为了理解平台总线、设备、驱动模型，而用此框架实现的驱动。具体代码如下：

led_dev.c :

</pre><pre name="code" class="cpp">/* 分配/设置/注册一个platform_device */
#include <linux/module.h>
#include <linux/version.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/types.h>
#include <linux/interrupt.h>
#include <linux/list.h>
#include <linux/timer.h>
#include <linux/init.h>
#include <linux/serial_core.h>
#include <linux/platform_device.h>

/*   "~~~~~~~~~~~Tiny4412支持的Linux3.5中不需要用资源的方式~~~~~~~~~~~"
static struct resource led_resource[] = {
	//寄存器起始地址，如果要换硬件寄存器，只需要在这里修改即可
    [0] = {
        .start = 0x110002E0,
        .end   = 0x110002E0 + 8 - 1,//结束地址
        .flags = IORESOURCE_MEM,//表示哪类资源
    },
	//哪根引脚，如果要换一个led亮，只需要修改下面的数字即可
    [1] = {
        .start = 0,//Tiny4412中GPM4(0-3)分别接led0-3，所以0、1、2、3分别表示led1、led2、led3、led4
        .end   = 0,
        .flags = IORESOURCE_IRQ,
    }

};*/

static void led_release(struct device * dev)
{
}

static struct platform_device led_dev = {
    .name         = "myled",//这个名字要和led_dev.c中的相同
    .id       = -1,
    //.num_resources    = ARRAY_SIZE(led_resource),
	.num_resources    = 0,
    //.resource     = led_resource,
    .dev = { 
    	.release = led_release, //如果不提供此函数，在卸载模块时会报错
	},
};

static int led_dev_init(void)
{
	//platform_device_register→platform_device_add→device_add即把设备放入平台总线里的设备链表中去
	//即加载lsmod led_dev.ko后，会调用driver的probe函数。
	platform_device_register(&led_dev);
	return 0;
}

static void led_dev_exit(void)
{
	/*
	  rmmod  led_dev模块后，调用此函数，而此函数会从bus总线的dev链表中找出此设备，然后
	  去掉并根据match函数找到对应的drv，然后调用里面(drv结构体)的remove函数做些
	  清理工作*/
	platform_device_unregister(&led_dev);//会调用platform_driver中led_remove函数
}
module_init(led_dev_init);
module_exit(led_dev_exit);
MODULE_LICENSE("GPL");

led_drv.c :

/* 分配/设置/注册一个platform_driver */
#include <linux/version.h>
#include <linux/init.h>
#include <linux/interrupt.h>
#include <linux/sched.h>
#include <linux/pm.h>
#include <linux/sysctl.h>
#include <linux/proc_fs.h>
#include <linux/delay.h>
#include <linux/platform_device.h>
#include <linux/input.h>
#include <linux/irq.h>
#include <asm/uaccess.h>
#include <asm/io.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/miscdevice.h>
#include <linux/fs.h>
#include <linux/types.h>
#include <linux/moduleparam.h>
#include <linux/slab.h>
#include <linux/ioctl.h>
#include <linux/cdev.h>

#include <linux/gpio.h>
#include <mach/gpio.h>
#include <plat/gpio-cfg.h>

#define DEVICE_NAME "bus_dev_drv_leds"
#define LED_NUM		ARRAY_SIZE(led_gpios)
static int led_gpios[] = {
	EXYNOS4X12_GPM4(0),
	EXYNOS4X12_GPM4(1),
	EXYNOS4X12_GPM4(2),
	EXYNOS4X12_GPM4(3),
};
/*
static int major;
static struct class *cls;
static volatile unsigned long *gpio_con;
static volatile unsigned long *gpio_dat;
static int pin;
*/

static int led_open(struct inode *inode, struct file *file)
{
	printk("Kernel:bus_dev_drv_leds OPEN\n");
	/*
	// 配置为输出 
	*gpio_con &= ~(0x3<<(pin*2));
	*gpio_con |= (0x1<<(pin*2));*/
	return 0;	
}

static ssize_t led_write(struct file *file, const char __user *buf, size_t count, loff_t * ppos)
{
	int val;

	printk("Kernel:dev_drv_leds WRITE\n");

	if(copy_from_user(&val, buf, count)) //	copy_to_user();
	{
		printk("LED_DRV:copy_from_user ERR!\n");
		return -1;
	}

	if (val == 1)
	{
		// 点灯
		//*gpio_dat &= ~(1<<pin);
		gpio_set_value(led_gpios[0], 0);
	}
	else
	{
		// 灭灯
		//*gpio_dat |= (1<<pin);
		gpio_set_value(led_gpios[0], 1);
	}
	
	return 0;
}

/*
static struct file_operations led_fops = {
    .owner  =   THIS_MODULE,    // 这是一个宏，推向编译模块时自动创建的__this_module变量 
    .open   =   led_open,     
	.write	=	led_write,	   
};*/

static struct file_operations tiny4412_led_dev_fops = {
	.owner			= THIS_MODULE,
	//.unlocked_ioctl	= tiny4412_leds_ioctl,
	.open   =   led_open,     
	.write	=	led_write,
};

static struct miscdevice tiny4412_led_dev = {
	.minor			= MISC_DYNAMIC_MINOR,
	.name			= DEVICE_NAME,
	.fops			= &tiny4412_led_dev_fops,
};

static int led_probe(struct platform_device *pdev)//这里面想做什么就做什么，用户决定
{
	/*struct resource		*res;

	//根据platform_device的资源进行ioremap 
	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	gpio_con = ioremap(res->start, res->end - res->start + 1);
	gpio_dat = gpio_con + 1;//指针加一相当于加4，即指向另外一个寄存器

	res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
	pin = res->start;*/
	
	int ret;
	int i;
	for (i = 0; i < LED_NUM; i++) {
		ret = gpio_request(led_gpios[i], "LED");
		if (ret) {
			printk("%s: request GPIO %d for LED failed, ret = %d\n", DEVICE_NAME,
					led_gpios[i], ret);
			return ret;
		}

		s3c_gpio_cfgpin(led_gpios[i], S3C_GPIO_OUTPUT);
		gpio_set_value(led_gpios[i], 1);
	}
	
	/* 注册字符设备驱动程序 */
	printk("led_drv: led_probe, found led\n");
	misc_register(&tiny4412_led_dev);
/*
	major = register_chrdev(0, "myled", &led_fops);
	cls = class_create(THIS_MODULE, "myled");
	class_device_create(cls, NULL, MKDEV(major, 0), NULL, "led"); //设备文件dev/led 
*/	
	return 0;
}

static int led_remove(struct platform_device *pdev)
{
	/* 卸载字符设备驱动程序 */	
	int i;
	printk("led_drv: led_remove, remove led\n");
	
	for (i = 0; i < LED_NUM; i++) {
		gpio_free(led_gpios[i]);
	}
	misc_deregister(&tiny4412_led_dev);
	/*
	class_device_destroy(cls, MKDEV(major, 0));
	class_destroy(cls);
	unregister_chrdev(major, "myled");
	iounmap(gpio_con);
	*/
	return 0;
}

struct platform_driver led_drv = {
	.probe		= led_probe,
	.remove		= led_remove,
	.driver		= {
		.name	= "myled",//这个名字要和led_dev.c中的相同
	}
};

static int led_drv_init(void)
{
	platform_driver_register(&led_drv);
	return 0;
}

static void led_drv_exit(void)
{
	platform_driver_unregister(&led_drv);
}
module_init(led_drv_init);
module_exit(led_drv_exit);
MODULE_LICENSE("GPL");

led_test.c :

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>

/* led_test on
 * led_test off
 */
int main(int argc, char **argv)
{
	int fd;
	int val = 1;
	fd = open("/dev/bus_dev_drv_leds", O_RDWR);
	if (fd < 0)
	{
		printf("can't open!\n");
	}
	if (argc != 2)
	{
		printf("Usage :\n");
		printf("%s <on|off>\n", argv[0]);
		return 0;
	}

	if (strcmp(argv[1], "on") == 0)
	{
		val  = 1;
	}
	else
	{
		val = 0;
	}
	
	write(fd, &val, 4);
	return 0;
}

Makefile:

KERN_DIR = /home/samba/linuxKernel_ext4Fs_src/linux-3.5-2015-8

all:
	make -C $(KERN_DIR) M=`pwd` modules 

clean:
	make -C $(KERN_DIR) M=`pwd` modules clean
	rm -rf modules.order

obj-m	+= led_drv.o
obj-m	+= led_dev.o

如果是先装载led_dev，会把dev加入bus的设备链表中去，然后找对应的drv，此时找不到没关系，等装载了led_drv后，会把drv加入到bus的driver链表中去，然后会在dev链表中找一遍有没有匹配的dev（这样就相当于再找了一遍，只是找的是dev而已），如果找到，也将调用drv的probe函数。所以，不管是在dev链表中找设备还是在drv链表中找驱动，只要找到了，都会调用drv中的probe函数，这样设备和驱动可以不同时加载，也可不分顺序加载，通过试验也表明，不管先装载led_drv.ko还是先装载led_dev.ko，都是等两个都装载了后才会匹配并调用drv的probe函数。

所以说，不管先加载led_dev.ko还是led_drv.ko，只要匹配了，就会调用drv结构的probe函数成员。不管先卸载led_dev还是led_drv，凡是第一个卸载后，就会调用drv结构的led_remove函数成员。注意，本文是学校韦东山老师驱动视频后做的笔记，方便后面参考。