6410之驱动程序的分层分离，总线设备驱动模型

什么是分离分层的概念？

如前面的input子系统所述，分离分层概念可以如下图所示：



input.c和buttons.c,evdev.c形成分层的概念，buttons.c和evdev.c形成分离的概念，一边是硬件相关的代码由编写驱动的人员编写，一边是纯软件是由linux内核所提供的。

总线驱动设备模型：



该模型有三个结构体:

struct bus_type，struct device和struct device_driver。详细的设备模型内容可以参考/article/10646599.html

如上图所示：

device_add的作用：

1.把device放入bus的dev链表中

2.从bus的drv链表中取出每一个drv，再使用bus上的match函数判断drv是否支持dev

3.若可以支持，则调用drv的probe函数

driver_register的作用：

1.将driver放入到bus的drv链表中。

2.从bus上的devices链表中取出每一个dev，再使用bus上的match函数判断drv是否支持dev

3.若可以支持，则调用drv的probe函数

综上所述：总线，设备，驱动模型只是一个driver和dev建立链接的一种机制而已。

当一个文件夹中有多个模块文件，就需要将Makefile修改：

obj-m += led_dev.o

obj-m += led_drv.o

led_dev.c

#include <linux/kernel.h>
#include <linux/types.h>
#include <linux/init.h>
#include <linux/platform_device.h>
#include <linux/gpio.h>

static struct resource s3c_led_resource[] = {
[0] = {
.start = 0x7F008830,
.end   = 0x7F008830 + 8 - 1,
.flags = IORESOURCE_MEM,
},
[1] = {
.start = 1,
.end   = 1,
.flags = IORESOURCE_IRQ,//表示led灯接到寄存器的第几个引脚
}
};

void led_release(struct device *dev)
{

}

struct platform_device led_dev = {
.name         = "s3c-led",
.id           = -1,
.num_resources    = ARRAY_SIZE(s3c_led_resource),
.resource     = s3c_led_resource,
.dev 		  = {
.release = led_release,//这个函数在rmmod led_dev的时候会使用到，最终调用到led_remove
}
};

static int led_devices_init(void)
{
platform_device_register(&led_dev);
return 0;
}

static void led_devices_exit(void)
{
platform_device_unregister(&led_dev);
}

module_init(led_devices_init);
module_exit(led_devices_exit);
MODULE_LICENSE("GPL");

如果不加release函数的话，在rmmod led_dev的时候出现下面现象：



led_drv.c

#include <linux/module.h>
#include <linux/init.h>
#include <linux/platform_device.h>
#include <linux/gpio.h>

static int led_probe(struct platform_device *pdev)
{
printk("Led probe !!!\n");
return 0;
}

static int led_remove(struct platform_device *dev)
{
printk("Led remove !!!\n");
return 0;
}

struct platform_driver led_driver = {
.probe	= led_probe,
.remove	= led_remove,
.driver	= {
.name	= "s3c-led",
.owner  = THIS_MODULE,
},
};

static int led_driver_init(void)
{
platform_driver_register(&led_driver);
return 0;
}

static void led_driver_exit(void)
{
platform_driver_unregister(&led_driver);
}

module_init(led_driver_init);
module_exit(led_driver_exit);
MODULE_LICENSE("GPL");

具体操作led：

只需要修改led_drv.c即可：

#include <linux/module.h>
#include <linux/init.h>
#include <linux/platform_device.h>
#include <linux/gpio.h>
#include <asm/uaccess.h>
#include <linux/device.h>
#include <asm/io.h>
#include <linux/fs.h>

struct class *led_dev_class;
struct device *led_dev;
int major;
static int pin;
static volatile unsigned long *gpiocon;
static volatile unsigned long *gpiodat;

static int led_drv_open(struct inode *inode, struct file *file)
{
//设置gpio为输出引脚
*gpiocon &= ~(0x3 << (pin*4));        //pin为从led_dev.c获取到的resource
*gpiocon |= (0x1 << (pin*4));

return 0;
}

ssize_t led_drv_write(struct file *filp, const char __user *buf, size_t len, loff_t *ppos)
{
int val;

copy_from_user(&val,buf,len);

if(val == 1){
//点灯
*gpiodat &= ~(1 << pin );
}else if(val == 0){
//灭灯
*gpiodat |= (1 << pin );
}

return sizeof(buf);
}

static struct file_operations led_drv_fops = {
.owner   =   THIS_MODULE,
.open    =   led_drv_open,
.write   =   led_drv_write,
};

static int led_probe(struct platform_device *pdev)
{
printk("Led probe !!!\n");

struct resource *res ;
res = platform_get_resource(pdev,IORESOURCE_MEM,0);  //获取到标志为IORESORCE_MEM的res

gpiocon = ioremap(res->start,res->end - res->start + 1);
gpiodat = gpiocon + 1;

res = platform_get_resource(pdev,IORESOURCE_IRQ,0);
pin = res->start;

major = register_chrdev(0,"led_drv",&led_drv_fops);
led_dev_class = class_create(THIS_MODULE,"led_class");
led_dev = device_create(led_dev_class,NULL,MKDEV(major,0),NULL,"led");
return 0;
}

static int led_remove(struct platform_device *dev)
{
printk("Led remove !!!\n");

device_destroy(led_dev_class,MKDEV(major,0));
class_destroy(led_dev_class);
unregister_chrdev(major,"led_drv");
iounmap(gpiocon);

return 0;
}

struct platform_driver led_driver = {
.probe	= led_probe,
.remove	= led_remove,
.driver	= {
.name	= "s3c-led",
.owner  = THIS_MODULE,
},
};

static int led_driver_init(void)
{
platform_driver_register(&led_driver);
return 0;
}

static void led_driver_exit(void)
{
platform_driver_unregister(&led_driver);
}

module_init(led_driver_init);
module_exit(led_driver_exit);
MODULE_LICENSE("GPL");

测试程序：

#include <stdio.h>
#include <fcntl.h>

int main(int argc , char **argv)
{
int fd ;
int val;

if(argc < 2){
printf("Usage : %s <on/off> \n",argv[0]);
return -1;
}

if(!strcmp(argv[1],"on")){
val = 1;
}else if(!strcmp(argv[1],"off")){
val = 0;
}
fd = open("/dev/led",O_RDWR); //打开设备节点/dev/led
if(fd < 0){
printf("Can not open devices\n");
return -1;
}

write(fd,&val,4);//向设备节点做写操作
return 0;
}