Chinaunix首页 | 论坛 | 博客

毕赖子的ChinaUnix博客

首页　| 　博文目录　| 　关于我

毕赖子

  • 博客访问： 369245
  • 博文数量： 159
  • 博客积分： 0
  • 博客等级： 民兵
  • 技术积分： 182
  • 用 户 组： 普通用户
  • 注册时间： 2013-11-02 10:42
文章分类

全部博文（159）

文章存档

2015年（18）

2014年（132）

2013年（9）

我的朋友
最近访客
推荐博文
相关博文
基于platform总线的中断(按键)字符设备驱动设计

分类： LINUX

2014-07-07 18:07:29

原文地址：基于platform总线的中断(按键)字符设备驱动设计 作者：gongping11

我的环境：
主机:Fedora 14，内核版本2.6.38.1
开发板:ARM9 tq2440
移植内核版本:linux-2.6.30.4

1、platform简介
为了理解platform总线设备驱动模型的实际运用，我首先分析了基于S3C2410的看门狗驱动实现过程，我本着将自己学过的知识在温习一遍的态度，完成了基于platform平台总线的外部中断（按键）的基本实现过程，分别采用了混杂字符设备和一般字符设备进行了操作，其中混杂字符设备驱动、应用程序参照了 Y-Kee http://blog.csdn.net/ayangke,QQ:843308498的基本框架。
platform总线是总线设备驱动模型中的一种，内核帮助实现了总线部分，我们在设计驱动的过程中只需要完成驱动和设备的添加即可。其中设备的添加包括添加设备名和相关的硬件资源（中断号和寄存器分布）。而驱动的添加除了添加必要的驱动模型以外，还需要得到硬件的具体资源，并对资源进行相应的操作和处理。
2、中断处理简介
中断是处理外设与处理器速度不匹配过程中常用的方法，基本的思想是，当产生中断以后，CPU必须停止当前处理的任务，转去执行中断处理程序，待中断处理程序处理完成以后再回到当前处理任务的过程。嵌入式处理器中的中断主要包括两部分CPU的内部中断（主要是异常）以及外设的中断（外部中断）。同时有的中断可以被屏蔽，而有的中断又不能被屏蔽，又可以将中断分为屏蔽和不可屏蔽中断。根据入口的跳转方法又可以将中断分为向量中断和非向量中断。向量中断通常是不同的中断号有不同的处理程序入口地址（硬件提供），而非向量中断通常是指共享型的中断，入口地址通常是由用户软件提供。

在linux内核中对中断的操作主要包括两部分：1、中断的申请和释放；2、中断处理程序设计
其中的中断的申请和释放，具体的采用函数：
  1. /*申请中断*/
  2. request_irq(unsigned int irq, irq_handler_t handler, unsigned long flags,const char *name, void *dev)
  3. /*释放中断*/
  4. void free_irq(unsigned int irq, void *dev_id)
在request_irq中的参数：
1、unsigned int irq表示具体的中断号，一般而言，针对不同的CPU，中断号存在一定的差别。
2、irq_handler_t handler表示一个回调函数，具体的就是中断操作的具体函数，称为中断处理函数。根据
typedef irqreturn_t (*irq_handler_t)(int, void *);
irq_handler_t 是一个函数指针，也就是中断处理函数应该是一个参数分别为int和void*,返回值为irqreturn_t,是枚举型参数。
  1. enum irqreturn {
  2.     IRQ_NONE,
  3.     IRQ_HANDLED,
  4.     IRQ_WAKE_THREAD,
  5. };

  7. typedef enum irqreturn irqreturn_t;
  8. #define IRQ_RETVAL(x)    ((x) != IRQ_NONE)
其中中断处理函数的形式就是一个函数，采用一般的C语言就可以实现。并没有什么特别需要注意的事项，但是需要保证的是中断要尽可能的短小精悍，不要出现长时间等待以及睡眠等形式，不能出现互信息量、信号量等并发机制，只能采用自旋锁实现。
3、unsigned long flags参数表示的中断的触发方式（高低电平触发等）或者处理方式(快速、一般中断)，其中的IRQF_DISABLE表示快速中断模式，IRQF_SHARED表示共享中断模式。
  
 /*可以选择的基本触发方式和处理方式*/
  1. #include <linux/interrupt.h>
 /*中断处理方式*/
  1. #ifndef IRQF_DISABLED
  2. #define IRQF_DISABLED SA_INTERRUPT
  3. #define IRQF_SAMPLE_RANDOM SA_SAMPLE_RANDOM
  4. #define IRQF_SHARED SA_SHIRQ
  5. #define IRQF_PROBE_SHARED SA_PROBEIRQ
  6. #define IRQF_PERCPU SA_PERCPU
  7. #ifdef SA_TRIGGER_MASK
  8. #define IRQF_TRIGGER_NONE 0
  9. #define IRQF_TRIGGER_LOW SA_TRIGGER_LOW
  10. #define IRQF_TRIGGER_HIGH SA_TRIGGER_HIGH
  11. #define IRQF_TRIGGER_FALLING SA_TRIGGER_FALLING
  12. #define IRQF_TRIGGER_RISING SA_TRIGGER_RISING
  13. #define IRQF_TRIGGER_MASK SA_TRIGGER_MASK
  14. #else /*中断触发方式*/
  15. #define IRQF_TRIGGER_NONE 0
  16. #define IRQF_TRIGGER_LOW 0
  17. #define IRQF_TRIGGER_HIGH 0
  18. #define IRQF_TRIGGER_FALLING 0
  19. #define IRQF_TRIGGER_RISING 0
  20. #define IRQF_TRIGGER_MASK 0
  21. #endif
  22. #endif

4、const char *name表示具体的设备名。
5、void *dev，这个参数比较灵活，可以选择不同的值，当中断选择为共享中断模式时，dev必须是唯一的；而当中断选择为其他处理模式时，该参数可以为NULL,也可以用来传递需要处理的变量或者资源。具体后面分析。

释放函数则相对来说简单很多，主要是释放的中断号和相关的处理数据。free_irq()针对共享设备非常有用，因为不能关闭中断disable_irq()，影响其他共享该中断号的设备。

3、功能简介
我这次完成的设计主要是采用platform设备驱动模型实现外部中断的设计。具体的操作主要是包括如下两步：
1、设备的添加(主要包括资源的添加和设备的注册)
2、驱动的设计(难点),首先要注册总线驱动，第二要完成具体驱动（外部中断或者按键）的设计(字符型驱动或者混杂设备驱动)，最后实现对应的操作函数。

难点分析：
1、具体设备的结构体设计，设备包含的数据，这一步是驱动设计的重点。
2、中断函数的设计，需要处理那些数据，保证短小精悍。
3、具体操作的设计，主要包括初始化和具体函数的操作。

字符设备的驱动源码代码分析，关于混杂设备的参看引用文章。
首先是设备添加代码：
  1. #include<linux/module.h>
  2. #include<linux/init.h>
  3. #include<linux/kernel.h>
  4. #include<linux/string.h>
  5. #include<linux/platform_device.h>
  6. /*硬件相关的头文件*/
  7. #include<mach/regs-gpio.h>
  8. #include<mach/hardware.h>
  9. #include<linux/gpio.h>

  11. /*这个是硬件（CPU）密切相关的中断号*/
  12. #include<mach/irqs.h>

  14. /*硬件资源量，这是根据tq2440开发板确定的*/
  15. static struct resource tq2440_button_resource[]=
  16. {
  17.     /*EINT0*/
  18.     [0]=
  19.     {
  20.         .flags = IORESOURCE_IRQ,
  21.         .start = IRQ_EINT0,
  22.         .end = IRQ_EINT0,
  23.         .name = "S3C24XX_EINT0",
  24.     },
  25.     /*EINT1*/
  26.     [1]=
  27.     {
  28.         .flags = IORESOURCE_IRQ,
  29.         .start = IRQ_EINT1,
  30.         .end = IRQ_EINT1,
  31.         .name = "S3C24xx_EINT1",
  32.     },
  33.     /*EINT2*/
  34.     [2]=
  35.     {
  36.         .flags = IORESOURCE_IRQ,
  37.         .start = IRQ_EINT2,
  38.         .end = IRQ_EINT2,
  39.         .name = "S3C24xx_EINT2",
  40.     },
  41.     /*EINT4*/
  42.     [3]=
  43.     {
  44.         .flags = IORESOURCE_IRQ,
  45.         .start = IRQ_EINT4,
  46.         .end = IRQ_EINT4,
  47.         .name = "S3C24xx_EINT4",
  48.     },
  49. };

  51. static struct platform_device tq2440_button_device=
  52. {
  53.     /*设备名*/
  54.     .name = "tq2440_button",
  55.     .id = -1,
  56.     /*资源数*/
  57.     .num_resources = ARRAY_SIZE(tq2440_button_resource),
  58.     /*资源指针*/
  59.     .resource = tq2440_button_resource,
  60. };

  62. static int __init tq2440_button_init(void)
  63. {
  64.     int ret ;
  65.     /*设备注册*/
  66.     ret = platform_device_register(&tq2440_button_device);
  67. }

  69. static void __exit tq2440_button_exit(void)
  70. {
  71.     /*设备的注销*/
  72.     platform_device_unregister(&tq2440_button_device);
  73. }

  75. /*加载与卸载*/
  76. module_init(tq2440_button_init);
  77. module_exit(tq2440_button_exit);

  79. /*LICENSE和作者信息*/
  80. MODULE_LICENSE("GPL");
  81. MODULE_AUTHOR("GP-");
然后是驱动实现代码：
  1. #include<linux/types.h>
  2. #include<linux/kernel.h>
  3. #include<linux/init.h>
  4. #include<linux/module.h>
  5. #include<linux/platform_device.h>
  6. #include<mach/irqs.h>
  7. #include<linux/irq.h>
  8. #include<mach/regs-gpio.h>
  9. #include<linux/device.h>
  10. #include<linux/string.h>
  11. #include<linux/cdev.h>
  12. #include<linux/fs.h>
  13. #include<linux/spinlock.h>
  14. #include<linux/wait.h>
  15. #include<linux/interrupt.h>
  16. #include<linux/uaccess.h>
  17. #include<linux/poll.h>


  20. #define NUM_RESOURCE    4

  22. /*主设备号*/
  23. int dev_major = -1;

  25. /*中断结构体定义*/
  26. struct irqs
  27. {
  28.     int pirqs[NUM_RESOURCE];
  29.     char *names[NUM_RESOURCE];
  30. }irqs;
  31. /*完成具体设备的结构体设计*/
  32. struct tq2440_button
  33. {
  34.     /*添加具体的字符设备结构*/
  35.     struct cdev cdev;
  36.     /*用于自动创建设备*/
  37.     struct class *myclass;
  38.     /*引用次数统计表*/
  39.     unsigned int count;
  40.     /*添加并行机制*/
  41.     spinlock_t lock;
  42.     /*添加等待队列*/
  43.     wait_queue_head_t read_wait_queue;
  44.     /*数据*/
  45.     int bepressed;
  46.     /*案件值*/
  47.     int key_values;
  48. };

  50. static struct tq2440_button tq2440_button;

  52. static irqreturn_t tq2440_button_interrupt_handler(int irq,void *dev_id)
  53. {
  54.     /*得到传递过来的参数*/
  55.     struct tq2440_button * dev = dev_id;
  56.     int i;
  57.     /*根据得到的irq值确定具体的按键值*/
  58.     for (i = 0; i < NUM_RESOURCE; ++ i)
  59.     {
  60.         /*判断条件*/
  61.         if(irq == irqs.pirqs[i])
  62.         {
  63.             /*对关键数据添加并行机制*/
  64.             spin_lock(&(dev->lock));
  65.             /*确定被按下的值*/
  66.             dev->key_values = i ;
  67.             /*表示有数据可以读*/
  68.             dev->bepressed = 1;
  69.             spin_unlock(&(dev->lock));
  70.             /*唤醒等待的队列*/
  71.             wake_up_interruptible(&(dev->read_wait_queue));    
  72.         }
  73.     }
  74.     /*返回值*/
  75.     return IRQ_RETVAL(IRQ_HANDLED);
  76. }

  78. static int tq2440_button_open(struct inode *inode,struct file *filp)
  79. {
  80.     int i = 0,ret = 0;
  81.     
  82.     /*中断申请*/
  83.     /*这句话主要是实现间接控制，但是还是可以直接控制*/
  84.     filp->private_data = &tq2440_button;
  85.     
  86.     /*修改被打开的次数值*/
  87.     spin_lock(&(tq2440_button.lock));    
  88.     tq2440_button.count ++ ;
  89.     spin_unlock(&(tq2440_button.lock));

  91.     /*如果是第一次打开则需要申请中断，这是比较推荐的方法，也可以在probe函数中申请中断*/
  92.     if(1==tq2440_button.count)
  93.     {
  94.         for(i = 0;i < NUM_RESOURCE; ++ i)
  95.         {
  96.             /*request_irq操作*/
  97.             ret = request_irq(irqs.pirqs[i],
  98.                 tq2440_button_interrupt_handler,
  99.                 IRQ_TYPE_EDGE_BOTH,irqs.names[i],(void *)&tq2440_button);
  100.         
  101.             if(ret)
  102.             {
  103.                 break;
  104.             }
  105.         }
  106.         if(ret)/*错误处理机制*/
  107.         {
  108.             i --;
  109.             for(; i >=0; --i)
  110.             {
  111.                 /*禁止中断*/
  112.                 
  113.                 disable_irq(irqs.pirqs[i]);
  114.             
  115.                 free_irq(irqs.pirqs[i],(void *)&tq2440_button);
  116.             }
  117.             return -EBUSY;
  118.         }
  119.     }    
  120.     return 0;
  121. }

  123. /*closed函数*/
  124. static int tq2440_button_close(struct inode *inode,struct file *filp)
  125. {
  126.     /*确保是最后一次使用设备*/
  127.     int i = 0;
  128.     if(tq2440_button.count == 1)
  129.     {
  130.         for(i = 0; i < NUM_RESOURCE; ++ i)
  131.         {
  132.             free_irq(irqs.pirqs[i],(void *)&tq2440_button);
  133.         }
  134.     }
  135.     /*更新设备文件引用次数*/
  136.     spin_lock(&(tq2440_button.lock));
  137.     tq2440_button.count = 0;
  138.     spin_unlock(&(tq2440_button.lock));

  140.     return 0;
  141. }

  143. static unsigned long tq2440_button_read(struct file *filp,char __user *buff,
  144.                     size_t count,loff_t offp)
  145. {
  146.     /*设备操作*/
  147.     struct tq2440_button *dev = filp->private_data;
  148.     
  149.     unsigned long err;
  150.         if(!dev->bepressed)/*确保没有采用非堵塞方式读标志*/
  151.         {
  152.         if(filp->f_flags & O_NONBLOCK)
  153.             return -EAGAIN;
  154.         else
  155.             /*添加等待队列，条件是bepressed*/
  156.             wait_event_interruptible(dev->read_wait_queue,dev->bepressed);
  157.     }    

  159.     /*复制数据到用户空间*/
  160.     err = copy_to_user(buff, &(dev->key_values),min(sizeof(dev->key_values),count));
  161.     
  162.     /*修改标志表示没有数据可读了*/
  163.     spin_lock(&(dev->lock));
  164.     dev->bepressed = 0;
  165.     spin_unlock(&(dev->lock));
  166.     
  167.     /*返回数据量*/
  168.     
  169.     return err ? -EFAULT:min(sizeof(dev->key_values),count);
  170. }


  173. static unsigned int tq2440_button_poll(struct file *filp,
  174.                 struct poll_table_struct *wait)
  175. {
  176.     struct tq2440_button *dev = filp->private_data;

  178.     unsigned int mask = 0;
  179.     
  180.     /*将结构体中的等待队列添加到wait_table*/    
  181.     poll_wait(filp,&(dev->read_wait_queue),wait);

  183.     /*
  184.     返回掩码
  185.     POLLIN|POLLRDNORM表示有数据可读
  186.     */
  187.     if(dev->bepressed)
  188.     {
  189.         mask |= POLLIN | POLLRDNORM;
  190.     }

  192.     return mask;
  193. }

  195. /*设备的具体操作函数*/
  196. static const struct file_operations tq2440_fops=
  197. {
  198.     .owner = THIS_MODULE,
  199.     .open = tq2440_button_open,
  200.     .release = tq2440_button_close,
  201.     .read = tq2440_button_read,
  202.     .poll = tq2440_button_poll,
  203. };


  206. /*remove函数实现字符设备的注销操作*/

  208. static int tq2440_button_probe(struct platform_device *dev)
  209. {
  210.     printk("The driver found a device can be handler on platform bus\n");
  211.     
  212.     /*用来存储定义好的资源，即中断号*/
  213.     
  214.     struct resource * irq_resource;
  215.     struct platform_device *pdev = dev;
  216.     int i = 0,ret = 0;

  218.     /*接下来完成具体字符驱动结构体的初始化*/
  219.     /*1、设备号申请*/
  220.     
  221.     dev_t devno;

  223.     if(dev_major > 0)/*静态申请设备号*/
  224.     {
  225.         devno = MKDEV(dev_major,0);
  226.         ret = register_chrdev_region(devno,1,"tq2440_button");
  227.     }
  228.     else/*动态申请设备号*/
  229.     {
  230.         ret = alloc_chrdev_region(&devno,0,1,"tq2440_button");
  231.         dev_major = MAJOR(devno);
  232.     }
  233.     if(ret < 0)
  234.     {
  235.         return ret;
  236.     }

  238.     /*完成设备类的创建，主要实现设备文件的自动创建*/
  239.     tq2440_button.myclass = class_create(THIS_MODULE,"tq2440_button_class");
  240.  
  241.     /*2、完成字符设备的加载*/
  242.     cdev_init(&(tq2440_button.cdev),&tq2440_fops);
  243.     tq2440_button.cdev.owner = THIS_MODULE;
  244.     ret = cdev_add(&(tq2440_button.cdev),devno,1);    
  245.     if(ret)
  246.     {
  247.         printk("Add device error\n");
  248.         return ret;
  249.     }
  250.     
  251.         /*初始化自旋锁*/
  252.     spin_lock_init(&(tq2440_button.lock));
  253.     
  254.     /*修改引用次数值*/
  255.     
  256.     spin_lock(&(tq2440_button.lock));
  257.     /*被打开次数统计*/
  258.     tq2440_button.count = 0;    
  259.     /*键值*/
  260.     tq2440_button.key_values = -1;
  261.     spin_unlock(&(tq2440_button.lock));
  262.     
  263.     /*初始化等待队列*/
  264.     
  265.     init_waitqueue_head(&(tq2440_button.read_wait_queue));
  266.     
  267.     
  268.     /*设备的创建，实现设备文件自动创建*/
  269.     
  270.     device_create(tq2440_button.myclass,NULL,devno,NULL,"tq2440_button");

  272.     /*3.获得资源*/
  273.     for(; i < NUM_RESOURCE; ++ i)
  274.     {
  275.         /*获得设备的资源*/
  276.         irq_resource = platform_get_resource(pdev,IORESOURCE_IRQ,i);
  277.         
  278.         if(NULL == irq_resource)
  279.         {
  280.             return -ENOENT;
  281.         }
  282.         irqs.pirqs[i] = irq_resource->start;

  284.         /*实现名字的复制操作*/
  285.         //strcpy(tq2440_irqs.name[i],irq_resource->name);

  287.         /*这一句是将指针的地址指向一个具体的地址*/
  288.         irqs.names[i] = irq_resource->name;
  289.     }
  290.     /*将设备的指针指向中断号*/
  291.     
  292.     return 0;
  293. }

  295. /*probe函数实现字符设备的初始化操作*/
  296. static int tq2440_button_remove(struct platform_device *dev)
  297. {
  298.     printk("The driver found a device be removed from the platform bus\n");
  299.     
  300.     /*注销设备*/
  301.     device_destroy(tq2440_button.myclass,MKDEV(dev_major,0));
  302.     /*字符设备注销*/
  303.     cdev_del(&(tq2440_button.cdev));
  304.     /*注销创建的设备类*/
  305.     class_destroy(&(tq2440_button.myclass));
  306.     /*释放设备号*/
  307.     unregister_chrdev_region(MKDEV(dev_major,0),1);
  308.     return 0;
  309. }

  311. /*完成平台总线结构体的设计*/
  312. static const struct platform_driver tq2440_button_driver =
  313. {
  314.     /*完成具体设备的初始化操作*/
  315.     .probe = tq2440_button_probe,
  316.     /*完成具体设备的退出操作*/
  317.     .remove = tq2440_button_remove,
  318.     .driver =
  319.     {
  320.         .owner = THIS_MODULE,
  321.         .name = "tq2440_button",
  322.     },
  323. };

  325. /*总线设备初始化过程*/
  326. static int __init platform_driver_init(void)
  327. {
  328.     int ret;
  329.     
  330.     /*总线驱动注册*/
  331.     ret = platform_driver_register(&tq2440_button_driver);
  332.     
  333.     /*错误处理*/
  334.     if(ret)
  335.     {
  336.         platform_driver_unregister(&tq2440_button_driver);
  337.         return ret;
  338.     }

  340.     return 0;
  341. }

  343. static void __exit platform_driver_exit(void)
  344. {
  345.     /*总线驱动释放*/
  346.     platform_driver_unregister(&tq2440_button_driver);
  347. }

  349. /*加载和卸载*/
  350. module_init(platform_driver_init);
  351. module_exit(platform_driver_exit);

  353. /*LICENSE和作者信息*/
  354. MODULE_LICENSE("GPL");
  355. MODULE_AUTHOR("GP-");
应用程序
  1. #include<stdio.h>
  2. #include<stdlib.h>
  3. #include<unistd.h>
  4. #include<sys/types.h>
  5. #include<sys/ioctl.h>
  6. #include<sys/stat.h>
  7. #include<sys/select.h>
  8. #include<sys/time.h>
  9. #include<errno.h>

  11. int main()
  12. {
  13.     int buttons_fd;
  14.     int key_value = 0;
  15.     
  16.     /*open函数测试*/
  17.     buttons_fd = open("/dev/tq2440_button",0);

  19.     if(buttons_fd < 0)
  20.     {
  21.         perror("open device buttons\n");
  22.         exit(1);
  23.     }

  25.     while(1)
  26.     {
  27.         fd_set rds;
  28.         int ret;

  30.         FD_ZERO(&rds);
  31.         FD_SET(buttons_fd,&rds);
  32.         /*poll函数测试*/
  33.         ret = select(buttons_fd + 1,&rds,NULL,NULL,NULL);
  34.         if(ret < 0)
  35.         {
  36.             perror("select");
  37.             exit(1);
  38.         }
  39.         if(ret == 0)
  40.         {
  41.             printf("Timeout.\n");
  42.         }
  43.         else if(FD_ISSET(buttons_fd,&rds))
  44.         {
  45.     /*read函数测试*/
  46.             int ret = read(buttons_fd,&key_value,sizeof key_value);
  47.             if(ret != sizeof key_value)
  48.             {
  49.                 if(errno != EAGAIN)
  50.                     perror("read buttons\n");
  51.                 continue;
  52.             }
  53.             else
  54.             {
  55.                 printf("buttons_value:%d\n",key_value+1);
  56.             }
  57.         }
  58.     }
  59.     /*release函数测试*/
  60.     close(buttons_fd); 
  61.     return 0;
  62. }
采用plotform总线实现中断的操作，基本中断的操作。
中断操作设备驱动集合：
阅读(1082) | 评论(0) | 转发(0) |
0

上一篇：linux驱动之内核定时器驱动设计

下一篇：混杂字符设备之LED设备驱动设计及CPU寄存器虚拟内存映射分析

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6