Linux中总线设备驱动模型及平台设备驱动实例

　　本文将简要地介绍Linux总线设备驱动模型及其实现方式，并不会过多地涉及其在内核中的具体实现，最后，本文将会以平台总线为例介绍设备和驱动程序的实现过程。

目录：

一、总线设备驱动模型总体介绍及其实现方式

　　1.总线设备驱动模型总体介绍

　　2、总线实现方式

　　　　（1）：描述

　　　　（2）：注册和卸载

　　3、设备实现方式

　　4、驱动实现方式

二、平台总线设备驱动

　　1、平台设备的实现方式

　　2、平台驱动的实现方式

　　3、平台总线驱动与设备匹配机制

三、按键实例

　　1.按键设备

　　2.按键驱动

一、总线设备驱动模型总体介绍及其实现方式

1.总线设备驱动模型总体介绍

　　如果cpu和外设或者外设和外设想要进行通讯，需要将通信的双方挂载到一条总线上，这里的总线可以是具体的总线，如IIC、CAN总线等，也可以是虚拟的总线，如平台总线。随着技术的不断进步，系统的拓扑结构也越来越复杂，对热插拔，跨平台移植性的要求也越来越高，2.4内核已经难以满足这些需求。为适应这种形势的需要，从Linux 2.6内核开始提供了全新的设备模型（当然也可以选择不用这样的方式实现）。其示意图如下所示：

　　总线设备驱动模型可分为总线、设备和驱动三个部分，当将一个设备加入到总线上时，内核会在这条总线上寻找该设备对应的驱动；当将一个驱动加入到一条总线上时，内核会在该总线上寻找与该驱动对应的设备。匹配的规则根据不同类型的总线及设备特征进行定义。

2、总线实现方式

(1):总线的描述

　　在 Linux 内核中, 总线由 bus_type 结构表示,定义在 <linux/device.h>中

struct bus_type {
const char *name; /*总线名称*/
int (*match) (struct device *dev, struct
device_driver *drv); /*驱动与设备的匹配函数*/
………
}

 　　其中，match函数的定义为：

int (*match)(struct device * dev, struct device_driver * drv)

　　设备和驱动的匹配规则在此函数中定义，match函数的职责为：当一个新设备或者新驱动被添加到这个总线时，该函数被调用，用于判断指定的驱动程序是否能处理指定的设备。若可以，则返回非零，若不可以则返回0值。

(2):总线的注册和注销

　　总线的注册使用如下函数

bus_register(struct bus_type *bus)

 　　若成功，新的总线将被添加进系统，并可在/sys/bus 下看到相应的目录。

　　总线的注销使用：

void bus_unregister(struct bus_type *bus)

　　若成功，则总线将会从系统中删除。

3、设备的实现方式

(1):设备的描述方式

　　在 Linux内核中, 设备由struct device结构表示。

struct device {
{
const char *init_name; /*设备的名字*/
struct bus_type *bus; /*设备所在的总线*/
………
}

　　其中，init_name为设备的名称，*bus指向总线的描述结构。

(2):设备的注册和注销

　　设备的注册使用如下函数：

int device_register(struct device *dev);

　　当一个设备成功地添加到一条总线上时可以在/sys/bus/xxx_bus/目录下看到相应的设备。

　　设备的注销使用如下函数：

void device_unregister(struct device *dev);

4.驱动实现方式

(1):驱动的描述方式

　　在 Linux内核中, 驱动由 device_driver结构表示：

struct device_driver {
{
const char *name; /*驱动名称*/
struct bus_type *bus; /*驱动程序所在的总线*/
int (*probe) (struct device *dev);/*设备匹配成功后调用的函数*/
………
}

 　　其中，*name为驱动的名称，可以作为一种设备和驱动匹配的条件；*bus指向所要加入的总线的描述结构；*probe函数指针指向一个操作函数，该函数会在设备和驱动匹配成功之后(即match函数返回为1时)被调用，一般用来完成对设备的初始化操作。

(2):驱动的注册和注销

　　驱动的注册使用如下函数

int driver_register(struct device_driver *drv);

　　驱动的注销使用：

void driver_unregister(struct device_driver *drv);

二、平台总线设备驱动实例

　　平台总线(Platform bus)是linux2.6内核加入的一种虚拟总线（已经在Linux内核中实现，是上文介绍的总线的一个实例），其优势在于采用了总线的模型对设备与驱动进行了管理，这样提高了程序的可移植性。平台总线的开发主要包括平台设备和平台驱动两个部分的实现，其开发流程图如下所示：

1.设备的实现方式

(1):平台设备的描述方式

　　平台设备使用struct platform_device来描述:

struct platform_device {
const char *name; /*设备名*/
int id; /*设备编号，配合设备名使用*/
struct device dev;
u32 num_resources;
struct resource *resource; /*设备资源*/
}

 　　其中，*name为设备名，*resource指针指向该平台设备所占有的资源，其用struct resource 结构来描述：

struct resource {
resource_size_t start;/*资源的起始地址*/
resource_size_t end;/*资源的结束地址*/
const char *name; 
unsigned long flags; /*资源的类型*/ 
struct resource *parent, *sibling, *child; 7 };

(2):平台设备的注册和注销

　　注册平台设备，使用函数:

int platform_device_register(struct platform_device *pdev);

　　注销平台设备，使用函数:

int platform_device_unregister(struct platform_device *pdev);

2.平台驱动的实现方式

(1):平台驱动的描述方式

　　平台驱动使用struct platform_driver 描述：

struct platform_driver {
int (*probe)(struct platform_device *);
int (*remove)(struct platform_device *);
……
}

 　　其中，*probe函数指针指向设备处理函数，当平台设备和平台驱动匹配成功时被调用。

(1):平台驱动的注册和注销

　　平台驱动注册使用函数：

int platform_driver_register(struct platform_driver *);

　　平台驱动注销使用函数：

1 int platform_driver_unregister(struct platform_driver *);

3.平台总线驱动与设备的匹配机制

　　平台总线驱动和设备采用名称是否相同的方式进行匹配，在平台总线的match函数中对驱动和设备的名称进行比较，若两者名称相同则match函数返回为非0，否则返回为0。另外，平台设备一般直接载入内核进行初始化而不通过模块的方式进行加载（平台设备可以看成是对应于具体设备的资源的集合，将设备和驱动分开有利于程序的移植）。

三、按键实例

1.平台按键的定义和注册

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

MODULE_LICENSE("GPL");

#define GPFCON 0x56000050
 9 //所用的资源描述
static struct resource key_resource[] = {
    [0] = {
        .start = GPFCON,
        .end   = GPFCON + 8,
        .flags = IORESOURCE_MEM,
    },
    [1] = {
        .start = IRQ_EINT0,
        .end   = IRQ_EINT2,
        .flags = IORESOURCE_IRQ,
    },
};

struct platform_device key_device = {
    .name          = "my-key",
    .id          = 0,
    .num_resources      = ARRAY_SIZE(key_resource),
    .resource      = key_resource,
};

static int button_init()
{
    platform_device_register(&key_device);
     
    return 0;
}


static void button_exit()
{       
    platform_device_unregister(&key_device);
}


module_init(button_init);
module_exit(button_exit);

2.平台驱动的定义和注册

#include <linux/module.h>
#include <linux/init.h>
#include <linux/miscdevice.h>
#include <linux/interrupt.h>
#include <linux/io.h>
#include <linux/fs.h>
#include <asm/uaccess.h>
#include <linux/platform_device.h>

MODULE_LICENSE("GPL");

struct work_struct *work;

struct timer_list buttons_timer;

unsigned int key_num = 0;

wait_queue_head_t  key_q;

struct resource *res;
struct resource *res_irq;
unsigned int *key_base;

void work_func(struct work_struct *work)
{
    mod_timer(&buttons_timer, jiffies + (HZ /10));     
}

void buttons_timer_function(unsigned long data)  
{
    unsigned int key_val;
    
    key_val = readw(key_base+1)&0x1; 
    if (key_val == 0)
       key_num = 4;
    
    key_val = readw(key_base+1)&0x4;
    if (key_val == 0)
        key_num = 3;
    
    wake_up(&key_q); 
} 


irqreturn_t key_int(int irq, void *dev_id)
{
    //1. 检测是否发生了按键中断
    
    //2. 清除已经发生的按键中断
    
    //3. 提交下半部
    schedule_work(work);
  
    //return 0;
    return IRQ_HANDLED;
        
}

void key_hw_init()
{
    unsigned short data;
        
    data = readw(key_base);
    data &= ~0b110011;
    data |= 0b100010;

    writew(data,key_base);
}


int key_open(struct inode *node,struct file *filp)
{
    return 0;    
}

ssize_t key_read(struct file *filp, char __user *buf, size_t size, loff_t *pos)
{ 
    wait_event(key_q,key_num);
        
    copy_to_user(buf, &key_num, 4);
    
    key_num = 0;
  
    return 4;
}

struct file_operations key_fops = 
{
    .open = key_open,
    .read = key_read,    
};

struct miscdevice key_miscdev = {
    .minor = 200,
    .name = "key",
    .fops = &key_fops,    
};

int key_probe(struct platform_device *pdev)
{
    int ret,size;
    
    
    ret = misc_register(&key_miscdev);
    
    if (ret !=0)
        printk("register fail!
");
    
    //注册中断处理程序
    
    res_irq =  platform_get_resource(pdev, IORESOURCE_IRQ, 0);
    
    request_irq(res_irq->start,key_int,IRQF_TRIGGER_FALLING,"key",(void *)4);
    request_irq(res_irq->end,key_int,IRQF_TRIGGER_FALLING,"key",(void *)3);
    
    //按键初始化
    res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
    size = (res->end - res->start) + 1;
    key_base = ioremap(res->start, size);
    
    key_hw_init();
    
    //. 创建工作
    work = kmalloc(sizeof(struct work_struct),GFP_KERNEL);
    INIT_WORK(work, work_func);
    
    /* 初始化定时器 */  
    init_timer(&buttons_timer);   
    buttons_timer.function  = buttons_timer_function;  
    
    /* 向内核注册一个定时器 */  
    add_timer(&buttons_timer);  
    
    /*初始化等待队列*/
    init_waitqueue_head(&key_q);
    
    return 0;
}

int key_remove(struct platform_device *dev)
{
    free_irq(res_irq->start, (void *)4);
    free_irq(res_irq->end, (void *)3);

    iounmap(key_base);
    misc_deregister(&key_miscdev);
    return 0;
}

static struct platform_driver key_driver = {
    .probe        = key_probe,
    .remove        = key_remove,
    .driver        = {
        .owner    = THIS_MODULE,
        .name    = "my-key",
    },
};

static int button_init()
{
    return platform_driver_register(&key_driver);
}


static void button_exit()
{       
    platform_driver_unregister(&key_driver);
}


module_init(button_init);
module_exit(button_exit);