Linux平台总线设备驱动

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

2. 平台总线开发设备驱动流程

（1）定义平台设备

（2）注册平台设备

（3）定义平台驱动

（4）注册平台驱动

3. 平台设备使用struct platform_device来描述

struct platform_device {

    const char    * name;

    int        id;

    struct device    dev;

    u32        num_resources;

    struct resource    * resource;

};

① name：设备名

② id：设备ID：配合设备名使用，以区分不同设备

③ dev：

④ num_resources：硬件资源个数

⑤ resource：硬件资源

struct resource {

    resource_size_t start;

    resource_size_t end;

    const char *name;

    unsigned long flags;

    struct resource *parent, *sibling, *child;

};

（1）注册平台设备：int platform_device_register(struct platform_device *pdev)；

（2）注销平台设备：void platform_device_unregister(struct platform_device *pdev)；

4. 平台驱动使用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 (*suspend_late)(struct platform_device *, pm_message_t state);

    int (*resume_early)(struct platform_device *);

    int (*resume)(struct platform_device *);

    struct device_driver driver;

};

（1）平台驱动注册： int platform_driver_register(struct platform_driver *)

（2）平台驱动注销：void platform_driver_unregister(struct platform_driver *)

5. 简单示例

① PlatformKeyDevice.c

#include <linux/module.h>

#include <linux/init.h>

#include <linux/interrupt.h>

#include <linux/platform_device.h>

MODULE_LICENSE("GPL");

#define GPGCON 0x56000060

void key_release(struct device *dev)

{

    printk("dev->init_name = %s release!\n", dev->init_name);

}

static struct resource key_resource[] = {

    [] = {

        .start = GPGCON,

        .end   = GPGCON + ,

        .flags = IORESOURCE_MEM,

    },

    [] = {

        .start = IRQ_EINT8,

        .end   = IRQ_EINT11,

        .flags = IORESOURCE_IRQ,

    },

    [] = {

        .start = IRQ_EINT13,

        .end   = IRQ_EINT14,

        .flags = IORESOURCE_IRQ,

    },

    [] = {

        .start = IRQ_EINT15,

        .end   = IRQ_EINT19,

        .flags = IORESOURCE_IRQ,

    },

};

struct platform_device key_device = {

    .name = "my-key",

    .id = ,

    .dev = {

        .init_name = "init_key",

        .release = key_release,

    },

    .num_resources = ARRAY_SIZE(key_resource),

    .resource = key_resource,

};

static int button_init(void)

{

    platform_device_register(&key_device);

    return ;

}

static void button_exit(void)

{

    platform_device_unregister(&key_device);

}

module_init(button_init);

module_exit(button_exit);

② PlatformKeyDriver.c

#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 timer_list buttons_timer;

unsigned int key_num = ;

wait_queue_head_t key_wait_queue;

unsigned int *key_base = NULL;

void buttons_timer_function(unsigned long data)

{

    printk("keys_timer_function\n");

    key_num = ;

    printk("data = %lx\n", data);

    switch(data)

    {

        case IRQ_EINT8:

            key_num = ;

            break;

        case IRQ_EINT11:

            key_num = ;

            break;

        case IRQ_EINT13:

            key_num = ;

            break;

        case IRQ_EINT14:

            key_num = ;

            break;

        case IRQ_EINT15:

            key_num = ;

            break;

        case IRQ_EINT19:

            key_num = ;

            break;            

        default:

            break;

    }

    printk("key_num = %d\n", key_num);

    wake_up(&key_wait_queue);

} 

irqreturn_t key_int(int irq, void *dev_id)

{

    //1. 检测是否发生了按键中断

    //2. 清除已经发生的按键中断

    //3. 提交下半部

    buttons_timer.data = irq;

    mod_timer(&buttons_timer, jiffies + (HZ /));     

    //return 0;

    return IRQ_HANDLED;

}

void key_hw_init(void)

{

    unsigned int config_data;

    if(key_base != NULL)

    {

        config_data = readl(key_base);

        config_data &= 0b001111110000001100111100;

        config_data |= 0b100000001010100010000010;

        writel(config_data, key_base);

    }

}

int key_open(struct inode *node,struct file *filp)

{

    return ;

}

ssize_t key_read(struct file *filp, char __user *buf, size_t size, loff_t *pos)

{

    wait_event(key_wait_queue, key_num);

    copy_to_user(buf, &key_num, );

    key_num = ;

    return ;

}

struct file_operations key_fops =

{

    .open = key_open,

    .read = key_read,

};

struct miscdevice key_miscdev = {

    .minor = ,

    .name = "key",

    .fops = &key_fops,

};

int key_probe(struct platform_device *pdev)

{

    int ret, size;

    struct resource *resources;

    struct resource *resources_irq;

    ret = misc_register(&key_miscdev);

    if (ret != )

        printk("register fail!\n");

    //注册中断处理程序

    resources_irq = platform_get_resource(pdev, IORESOURCE_IRQ, );

    request_irq(resources_irq->start, key_int, IRQF_TRIGGER_LOW, "key1", );

    request_irq(resources_irq->end, key_int, IRQF_TRIGGER_LOW, "key2", );

    resources_irq = platform_get_resource(pdev, IORESOURCE_IRQ, );

    request_irq(resources_irq->start, key_int, IRQF_TRIGGER_LOW, "key3", );

    request_irq(resources_irq->end, key_int, IRQF_TRIGGER_LOW, "key4", );

    resources_irq = platform_get_resource(pdev, IORESOURCE_IRQ, );

    request_irq(resources_irq->start, key_int,IRQF_TRIGGER_LOW, "key5", );

    request_irq(resources_irq->end, key_int,IRQF_TRIGGER_LOW, "key6", );

    //按键初始化

    resources = platform_get_resource(pdev, IORESOURCE_MEM, );

    size = (resources->end - resources->start) + ;

    key_base = ioremap(resources->start, size);

    key_hw_init();

    /* 初始化定时器 */

    init_timer(&buttons_timer);

    buttons_timer.function  = buttons_timer_function;  

    /* 向内核注册一个定时器 */

    add_timer(&buttons_timer);  

    /*初始化等待队列*/

    init_waitqueue_head(&key_wait_queue);

    return ;

}

int key_remove(struct platform_device *pdev)

{

    struct resource *resources_irq;

    int i = ;

    printk("PlatformKeyDriver: key_remove!\n");

    for(i = ; i <= ; i++)

    {

        resources_irq = platform_get_resource(pdev, IORESOURCE_IRQ, i);

        free_irq(resources_irq->start, );

        free_irq(resources_irq->end, );

    }

    iounmap(key_base);

    misc_deregister(&key_miscdev);

    return ;

}

static struct platform_driver key_driver = {

    .probe        = key_probe,

    .remove        = key_remove,

    .driver        = {

        .owner    = THIS_MODULE,

        .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);

巴特西

Linux平台总线设备驱动

最新文章

热门文章