17.平台总线程序设计

　　　　　　　　　　　　平台总线程序设计

 　　

一、平台总线概述

　　平台总线(Platform bus)是linux2.6内核加入的一种虚拟总线，其优势在于采用了总线的模型对设备与驱动进行了管理，这总线的模型对设备与驱动进行了管理，这样提高了程序的可移植性。

　　通过平台总线机制开发设备驱动的流程如图：

　　

平台总线的结构：platform_bus_type:

struct bus_type platform_bus_type = {
    .name        = "platform",
    .dev_attrs    = platform_dev_attrs,
    .match        = platform_match,
    .uevent        = platform_uevent,
    .pm        = &platform_dev_pm_ops,
};

该结构中，最重要的是我们的匹配函数platform_match:

static int platform_match(struct device *dev, struct device_driver *drv)
{
    struct platform_device *pdev = to_platform_device(dev);
    struct platform_driver *pdrv = to_platform_driver(drv);

    /* Attempt an OF style match first */
    if (of_driver_match_device(dev, drv))
        return 1;

    /* Then try to match against the id table */
    if (pdrv->id_table)
        return platform_match_id(pdrv->id_table, pdev) != NULL;

    /* fall-back to driver name match */
    return (strcmp(pdev->name, drv->name) == 0);
} 

在匹配函数里，有我们熟悉的代码：总线设备驱动程序学习中使用过的

二、平台设备

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

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

　　在这个结构中，重要的成员name，设备要和驱动的名字一样。另一个是resource。设备的资源，例如中断号，寄存器.....都是资源。这些就放到resource这个结构里：　

其中struct resource *resource描述：

struct resource{
    resource_size_t start;
    resource_size_t end;
    const char *name;
    unsigned long flags; /*资源的类型*/
    struct resource *parent, *sibling, *child;
};

 1.1注册和注销平台设备

注册平台设备，使用函数:
　　int platform_device_register(struct platform_device *pdev)

注销平台设备，使用函数:
　　int platform_device_unregister(struct platform_device *pdev)

使用实例：

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

MODULE_LICENSE("GPL");

#define GPNCON 0x7f008830

//定义资源
struct resource key_resource[] ={
    [0] = {   //第一项资源
            .start = GPNCON,
            .end = GPNCON+8,
            .flags = IORESOURCE_MEM,
    },
    [1] = {    //第二项资源，中断号
        .start = IRQ_EINT(0),
        .end = IRQ_EINT(1),
        .flags = IORESOURCE_IRQ,
    },
};

//定义平台设备结构
struct platform_device key_device = {
    .name = "my-key",
    .id = 0,
    .num_resources = 2,
    .resource = key_resource, 
};

int keydev_init(void)
{
    int ret;
    //平台设备的注册
    ret = platform_device_register(&key_device);
    return ret;
}

void keydev_exit(void)
{
    platform_device_unregister(&key_device);
}

module_init(keydev_init);
module_exit(keydev_exit);

执行结果如下：

　　

三、平台驱动

　　平台驱动使用struct 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;
};

 　　其中probe函数是当驱动找到对应的设备后要执行的函数，remove函数是当设备移除是要调用的函数。

#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 <linux/slab.h>
#include <linux/uaccess.h>
#include <linux/platform_device.h>
#include <linux/sched.h>
 
MODULE_LICENSE("GPL");

struct work_struct *work1;
struct timer_list key_timer;

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

unsigned int key_num = 0;
wait_queue_head_t key_q;

void work1_func(struct work_struct *work)
{
    mod_timer(&key_timer,jiffies + (HZ/10));  //启动定时器
    //100毫秒超时=HZ/10，HZ=1秒。jiffies是系统当前时间
}
 
void key_timer_func(unsigned long data)  //定时器超时函数
{
    unsigned int key_val;
     //超时的时候，就要读取data
    key_val = readw(key_base+1) &0x01;
    if(key_val==0)
        key_num = 1;
    
    key_val = readw(key_base+1) &0x02;
    if(key_val==0)
        key_num = 2;
    
    //当有数据的时候，需要唤醒
    wake_up(&key_q);
}
 
irqreturn_t key_int(int irp,void *dev_id)
{
     //1.检测是否发生了按键中断
    //2.清除已经发生的按键中断
//前面的都是硬件相关的工作，必须在中断里面执行
//下面是硬件无关的工作，我们把它放到到中断以外的work1_func函数去处理。
    //3.提交下半部
    schedule_work(work1);
    return IRQ_HANDLED;
}

void key_hw_init(void)   //硬件初始化
{
    unsigned short data;
    
    data = readw(key_base);
    data &= ~0xfff;
    data |= 0xaaa;
    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);   //进入睡眠
        printk(KERN_EMERG"key num is%d
",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,
};

static int key_probe(struct platform_device *pdev)
{
    int ret;
    int size;
    ret = misc_register(&key_miscdev);   //1注册混杂设备
    if(ret!=0)
        printk(KERN_EMERG"register fail!
");
    
    //获取资源信息
    res_irq = platform_get_resource(pdev,IORESOURCE_IRQ,0);
    
    request_irq(res_irq->start,key_int,IRQF_TRIGGER_FALLING,"6410key",0);  //注册中断处理程序
    request_irq(res_irq->end,key_int,IRQF_TRIGGER_FALLING,"6410key",0);  //注册中断处理程序
    
    res_mem = platform_get_resource(pdev,IORESOURCE_MEM,0);
    size = res_mem->end - res_mem->start+1;
    key_base = ioremap(res_mem->start,size);
    
    //按键硬件初始化 
    key_hw_init();   /*这个函数里面会用到上面获取到的资源信息所以必须放在获取资源之后执行*/
    
    //创建工作1
    work1 = kmalloc(sizeof(struct work_struct),GFP_KERNEL);
    INIT_WORK(work1,work1_func);
    
    //初始化内核定时器
    init_timer(&key_timer);
    key_timer.function = key_timer_func;
    
    //注册定时器
    add_timer(&key_timer);
    
    //初始化等待队列
    init_waitqueue_head(&key_q);
    return ret;
}

static int key_remove(struct platform_device *pdev)
{
    return misc_deregister(&key_miscdev);   //注销混杂设备    
}

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

//驱动程序初始化
static int button_init(void)
{
    return platform_driver_register(&key_driver);;
}

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

module_init(button_init);
module_exit(button_exit);

运行结果如下：

　　

　　这里面遇到最纠结的问题就是：刚开始的时候将硬件初始化放在了平台总线的前面结果只要想运行设备驱动成和设备程序就会出现段错误，之所以这样是因为没有考虑硬件初始化的时候会用到获取资源信息里面的内容。一下是正确的初始化过程

//获取资源信息
    res_irq = platform_get_resource(pdev,IORESOURCE_IRQ,0);
    
    request_irq(res_irq->start,key_int,IRQF_TRIGGER_FALLING,"6410key",0);  //注册中断处理程序
    request_irq(res_irq->end,key_int,IRQF_TRIGGER_FALLING,"6410key",0);  //注册中断处理程序
    
    res_mem = platform_get_resource(pdev,IORESOURCE_MEM,0);
    size = res_mem->end - res_mem->start+1;
    key_base = ioremap(res_mem->start,size);
    
    //按键硬件初始化 
    key_hw_init();   /*这个函数里面会用到上面获取到的资源信息所以必须放在获取资源之后执行*/