Linux下的platform总线驱动（二）

版权所有，转载请说明转自 http://my.csdn.net/weiqing1981127

三．平台设备驱动测试

这里我们采用Mini2440开发板，编写基于平台设备的按键驱动，要求按键驱动触发方式为单边沿触发，同时要求添加设备属性项。因为这个驱动比较简单，我就不去细致分析了，如果对硬件不理解可以参考mini2440开发板数据手册，如果对软件不理解，可以参考上文平台设备的讲解。在此，我提供platform设备模块代码，platform驱动模块代码，应用层测试代码，需要注意的是在动态加载测试时需要先加载设备模块，再加载驱动模块。

1. platform设备模块代码

#include <linux/device.h>

#include <linux/module.h>

#include <linux/kernel.h>

#include <linux/init.h>

#include <linux/string.h>

#include <linux/platform_device.h>

#include <linux/interrupt.h>

#include <linux/sysfs.h>

#include <linux/stat.h>

#define GPGCON   0x56000060   //控制端口地址

#define GPGDAT   0x56000064  //数据端口地址

ssize_t test_show(struct device *dev, struct attribute *attr, char *buf);

ssize_t test_store(struct device *dev, struct attribute *attr, char *buf,size_t count);

static DEVICE_ATTR(buttons, S_IRWXUGO, test_show, test_store);  //设备属性

ssize_t test_show(struct device *dev, struct attribute *attr, char *buf)  //读设备属性

{

       printk("call :  test_show . \n");

       printk("attrname:%s . \n",attr->name);

       sprintf(buf,"%s\n",attr->name);

       return strlen(attr->name)+2;

}

ssize_t test_store(struct device *dev, struct attribute *attr, char *buf,size_t count) //写设备属性

{

       printk("call :  test_store . \n");

       printk("write : %s . \n",buf);

       strcpy(attr->name,buf);

       return count;

}

static struct resource s3c_buttons_resource[]=                

{

       [0]={                                   //内存资源

              .start = GPGCON,

              .end = GPGDAT,

              .flags=IORESOURCE_MEM,

              },

       [1]={                                   //中断号

              //KEY1

              .start = IRQ_EINT8,

              .end = IRQ_EINT8,

              .flags=IORESOURCE_IRQ,

              },   

       [2]={

              //KEY2

              .start = IRQ_EINT11,

              .end = IRQ_EINT11,

              .flags=IORESOURCE_IRQ,

              },

};

MODULE_AUTHOR("WJB");

MODULE_LICENSE("Dual BSD/GPL");

static struct platform_device *my_device = NULL;

static int __init my_device_init(void)

{

     int ret = 0;

     my_device = platform_device_alloc("s3c2410-buttons", -1);   //申请平台设备

     platform_device_add_resources(my_device, s3c_buttons_resource, 3);  //添加资源

     ret =  platform_device_add(my_device);       //注册平台设备

        device_create_file(&my_device->dev,&dev_attr_buttons);  //添加设备属性

     if(ret)

         platform_device_put(my_device);

     return ret;

}

static void my_device_exit(void)

{

     platform_device_unregister(my_device);

        device_remove_file(&my_device->dev,&dev_attr_buttons);

}

module_init(my_device_init);

module_exit(my_device_exit);

2. platform驱动模块代码

#include <linux/device.h>

#include <linux/module.h>

#include <linux/kernel.h>

#include <linux/init.h>

#include <linux/string.h>

#include <linux/platform_device.h>

#include <asm/io.h>

#include <linux/poll.h>       

#include <linux/irq.h>

#include <linux/interrupt.h>

#include <linux/miscdevice.h>

#include <linux/sched.h>

MODULE_AUTHOR("WJB");

MODULE_LICENSE("Dual BSD/GPL");

#define BUTTONS_12INPUT_MASK   0x41

struct button_irq_desc {               //私有数据结构体

    int number;

    char *name;   

};

static struct button_irq_desc buttons_irqs [] = {  //私有数据

    { 0, "KEY1"},

    { 1, "KEY2"},

};

static volatile char key_values [] = {'0', '0'};

static DECLARE_WAIT_QUEUE_HEAD(button_waitq);      //定义等待队列

static volatile int ev_press = 0;

static struct resource     *buttons_irq1;

static struct resource     *buttons_irq2;

static struct resource *buttons_mem;

static void __iomem *buttons_base;

static irqreturn_t s3c2410buttons_irq(int irq, void *dev_id)

{  

    struct button_irq_desc *buttons_irqs = (struct button_irq_desc *)dev_id;

    unsigned int tmp;

    void __iomem *base = buttons_base;

   tmp=readb(base+0x04);

   if(buttons_irqs->number==0)

   {

     tmp &=0x01;

   }else{

     tmp &=0x08;

    }  

    // process data

    if (tmp == (key_values[buttons_irqs->number] & 1)) { // Changed

       key_values[buttons_irqs->number] = '1' ;

    }

        ev_press = 1;

      wake_up_interruptible(&button_waitq);

    return IRQ_RETVAL(IRQ_HANDLED);

}

static int s3c24xx_buttons_open(struct inode *inode, struct file *file)

{   int ret;

    unsigned int tmp;

    void __iomem *base = buttons_base;

    // set key1 and key2 input

    tmp=readb(base);

    writeb(tmp|BUTTONS_12INPUT_MASK ,base);

       ret = request_irq(buttons_irq1->start, s3c2410buttons_irq,IRQ_TYPE_EDGE_FALLING, "KET1", (void *)&buttons_irqs[0]);

       if (ret != 0) {

              printk( "failed to install irq (%d)\n", ret);

              goto err1;

       }

     ret = request_irq(buttons_irq2->start, s3c2410buttons_irq, IRQ_TYPE_EDGE_FALLING, "KET2", (void *)&buttons_irqs[1]);

       if (ret != 0) {

              printk( "failed to install irq (%d)\n", ret);

              goto err2;

       }

       ev_press = 1;

   

        return 0;

err2: disable_irq(buttons_irq2->start);

            free_irq(buttons_irq2->start, (void *)&buttons_irqs[1]);

err1: disable_irq(buttons_irq1->start);

            free_irq(buttons_irq1->start, (void *)&buttons_irqs[0]);

      

        return -EBUSY;

}

static int s3c24xx_buttons_close(struct inode *inode, struct file *file)

{

           disable_irq(buttons_irq2->start);

        free_irq(buttons_irq2->start, (void *)&buttons_irqs[1]);

           disable_irq(buttons_irq1->start);

        free_irq(buttons_irq1->start, (void *)&buttons_irqs[0]);

    return 0;

}

static int s3c24xx_buttons_read(struct file *filp, char __user *buff, size_t count, loff_t *offp)

{

    unsigned long err;

    int i;

    if (!ev_press) {

       if (filp->f_flags & O_NONBLOCK)

           return -EAGAIN;

       else

           wait_event_interruptible(button_waitq, ev_press);

    }  

    ev_press = 0;

    err = copy_to_user(buff, (const void *)key_values, min(sizeof(key_values), count));

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

    {

    key_values[i]='0';

    }   

    return err ? -EFAULT : min(sizeof(key_values), count);

}

static struct file_operations dev_fops = {

    .owner   =   THIS_MODULE,

    .open    =   s3c24xx_buttons_open,

    .release =   s3c24xx_buttons_close,

    .read    =   s3c24xx_buttons_read,

};

static struct miscdevice s3c2410buttons_miscdev = {

       .minor = MISC_DYNAMIC_MINOR,

       .name = "s3c2410-buttons",

       .fops = &dev_fops,

};

static int my_probe(struct platform_device* pdev)

{  

      int ret;

        struct resource *res;

       struct device *dev;

       dev = &pdev->dev;

// get resource

       res = platform_get_resource(pdev, IORESOURCE_MEM, 0);

       if (res == NULL) {

              dev_err(&pdev->dev, "failed to get memory region resource\n");

              return -ENOENT;

       }

       buttons_mem = request_mem_region(res->start,

                                    res->end-res->start+1,

                                    pdev->name);

       if (buttons_mem == NULL) {

              dev_err(&pdev->dev, "failed to reserve memory region\n");

              ret = -ENOENT;

              goto err_nores;

       }

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

       if (buttons_base == NULL) {

              dev_err(&pdev->dev, "failed ioremap()\n");

              ret = -EINVAL;

              goto err_nores;

       }

//get key1 interrupt

       buttons_irq1 = platform_get_resource(pdev, IORESOURCE_IRQ, 0);

       if (buttons_irq1 == NULL) {

              dev_err(dev, "no irq resource specified\n");

              ret = -ENOENT;

              goto err_map;

       }

//get key2 interrupt

       buttons_irq2 = platform_get_resource(pdev, IORESOURCE_IRQ, 1);

       if (buttons_irq2 == NULL) {

              dev_err(dev, "no irq resource specified\n");

              ret = -ENOENT;

              goto err_map;

       }

// register misc device

       ret = misc_register(&s3c2410buttons_miscdev);

       if (ret) {

              dev_err(dev, "cannot register miscdev on minor=%d (%d)\n",

                     WATCHDOG_MINOR, ret);

              goto err_map;

       }

     printk("driver found device which my driver can handle!\n");

err_map:

       iounmap(buttons_base);

err_nores:

       release_resource(buttons_mem);

       kfree(buttons_mem);

     return ret;

}

static int my_remove(struct platform_device* pdev)

{

    release_resource(buttons_mem);

       kfree(buttons_mem);

       buttons_mem = NULL;

       free_irq(buttons_irq1->start, (void *)&buttons_irqs[0]);

       buttons_irq1 = NULL;

       free_irq(buttons_irq2->start, (void *)&buttons_irqs[1]);

       buttons_irq2 = NULL;

       iounmap(buttons_base);

       misc_deregister(&s3c2410buttons_miscdev);

    printk("drvier found device unpluged!/n");

    return 0;

}

static struct platform_driver my_driver = {

     .probe = my_probe,

     .remove = my_remove,

     .driver = {

          .owner = THIS_MODULE,

          .name = "s3c2410-buttons",

     },

};

static int __init my_driver_init(void)

{

     return platform_driver_register(&my_driver);

}

static void my_driver_exit(void)

{

     platform_driver_unregister(&my_driver);

}

module_init(my_driver_init);

module_exit(my_driver_exit);

3.应用层测试代码

#include <stdio.h>

#include <stdlib.h>

#include <unistd.h>

#include <sys/ioctl.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <fcntl.h>

#include <sys/select.h>

#include <sys/time.h>

#include <errno.h>

int main(void)

{

       int buttons_fd;

       char buttons[2] = {'0', '0'};

       buttons_fd = open("/dev/s3c2410-buttons", 0);

       if (buttons_fd < 0) {

              perror("open device buttons");

              exit(1);

       }

       for (;;) {

              char current_buttons[2];

              int count_of_changed_key;

              int i;

              if (read(buttons_fd, current_buttons, sizeof current_buttons) != sizeof current_buttons) {

                     perror("read buttons:");

                     exit(1);

              }

              for (i = 0, count_of_changed_key = 0; i < sizeof buttons / sizeof buttons[0]; i++) {

                     if (buttons[i] != current_buttons[i]) {

                            printf("%skey %d is %s", count_of_changed_key? ", ": "", i+1, buttons[i] == '0' ? "up" : "down");

                            count_of_changed_key++;

                     }

              }

              if (count_of_changed_key) {

                     printf("\n");

              }          

       }

       close(buttons_fd);

       return 0;

}

平台设备测试：

在超级终端下：

cd  /home/platform/device

insmod device.ko

cd  ../driver

insmod driver.ko

cd ../

./buttons

然后通过Mini2440开发板的按键，观察到超级终端的按键信息。

设备属性项测试：

在超级终端下：

cd /sys/platform/ s3c2410-buttons

ls后，会显示buttons这一目录

读取设备属性：cat buttons

修改设备属性：echo modify>buttons