Chinaunix首页 | 论坛 | 博客

千古风流keytounix.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

keytounix

  • 博客访问： 72812
  • 博文数量： 13
  • 博客积分： 302
  • 博客等级： 二等列兵
  • 技术积分： 210
  • 用 户 组： 普通用户
  • 注册时间： 2010-07-27 18:51
文章分类

全部博文（13）

文章存档

2012年（1）

2011年（12）

我的朋友
最近访客
推荐博文
相关博文
TQ2440按键驱动1-作为字符设备

分类： 嵌入式

2011-03-29 12:44:07

这个文档重在阐述TQ2440开发板上的按键驱动，该驱动是作为字符设备的.我们将从思路阐述.典型的数据/函数结构分析和一些注意事项三个方面阐述这个问题，最后附录上源代码.该代码是在开发板上调试通过的。
硬件环境:TQ2440
内核版本:linux-2.6.32
文件系统:busybox-1.13.1
交叉工具:arm-2009q1,codesource出品
效果图：

一、作为字符设备的按键驱动
在这里，先陈述几个观点，如果不赞同这几个观点的，这个文档没必要认真砍下去了，因为接下来的code就只基于这几个观点的,当然本人的观点未必正确，欢迎大家发表讨论。
a. 按键驱动，必须具备去除噪声的能力，通俗一点，就是必须具备去抖动的能力。
对于这个，我们可以通过定时器实现，本文将提供3种方案，实现该功能，由于处在Linux下，因此因此都是和定时器相关的，但其中有一种并未直接用到定时器，算是个人的一点点创新，有缺点，有优点，也一并附录上，欢迎大家评论。这些都是经过调试通过的---当然这些不会是单片机上这种被人鄙视的延时
  1. uchar i=0xff;
  2. while(i-->0){};
b. 按键驱动，必须能够如实反应按键值
所谓按键值，可以是一组数据结构，包含一些被我们认为有意义的数据成员.个人认为一个典型的按键值VALUE应该包含按键ID,按键事件EV，按键的数据VAR
所谓按键ID很好理解，就是我们给按键设置的代号;按键事件，就是放松或者按下等;按键数据，就是按下去对应的pin脚电平值.在我们的这个文档中，相关定义如下
  1. //00000000稳定的按下的pin value
  2. //00000001稳定的释放状态pin value
  3. #define VAR_KEY_DN (0x00<<0)
  4. #define VAR_KEY_UP (0x01<<0)
  5. //稳定的按下状态
  6. #define EV_KEY_DN (0x01<<2)
  7. //定义按键id
  8. #define ID_KEY_1 (0x01<<4)
  9.  //value=ID_KEY_1 | EV_KEY_DN | VAR_KEY_DN
c. 按键驱动，必须能够记忆按键值的能力
按键驱动，不单要能记录某一次按键的值，还需要记录过去多少次的按键的值，这个，可以通过数组实现，在实现过程中，我们采用了环形数据结构，能够非常轻巧地识别按键值的先后顺序

d. 按键驱动，应该自从加载以后就开始工作，而不是等待调用open方法才开始工作
这个和时下很多按键驱动有写向左，欢迎大家一起参加探讨。个人认为，按键驱动工作，记录按键事件的时间，应该是在从init开始，而不是open
无论打开，还是关闭，这个按键事件在那里，不移不异，所以，按键驱动的工作时间，与open应该无关   o/\o

好了，以上就是基本的观点，现在进入code阶段

二 、 Code

  1. /*

  3. @按键驱动程序

  5. @针对S3C2440的驱动程序

  7. @2011.3.20,keytounix

  9. @hi.baidu.com/andio

  11. */

  13. //包含重要的和常用的头文件

  15. #include <linux/module.h>
  16. #include <linux/kernel.h>
  17. #include <linux/init.h>
  18. #include <linux/sched.h>
  19. #include <linux/poll.h>
  20. #include <linux/timer.h>
  21. #include <linux/irq.h>
  22. #include <linux/cdev.h>
  23. #include <linux/wait.h>//waitqueue
  24. #include <linux/errno.h>
  25. #include <linux/interrupt.h>//irq
  26. #include <linux/io.h>
  27. #include <linux/types.h>
  28. #include <linux/delay.h>
  29. #include <linux/semaphore.h>//sem
  30. #include <linux/fs.h>
  31. #include <linux/platform_device.h>//
  32. #include <linux/miscdevice.h>

  34. #include <linux/device.h>
  35. #include <linux/workqueue.h>//workqueue

  37. #include <asm/uaccess.h>
  38. #include <asm/irq.h>

  40. //soc相关

  42. #include <mach/gpio.h>
  43. #include <mach/regs-clock.h>
  44. #include <mach/regs-gpio.h>
  45. #include <mach/hardware.h>
  46. #include <mach/irqs.h>





  52. //////////////////////////////

  54. #define u8 unsigned char

  56. #define u16 unsigned short

  58. #define uint unsigned int

  60. #define SZ_BUF 16

  62. #define VAR_INIT 0xff

  64. #define CMD_RESET 0xff

  66. #define TM1000MS 100

  68. //这个 宏获得t[n]的n数目
  69. #define get_elem_num(t) (sizeof(t)/sizeof(t[0]))

  71. ////////////////////////////////////
  72. //debug info

  74. //这是一个debug宏，很有意思的

  76. #define _DEBUG_ 1


  79. #if _DEBUG_

  81. #define debug(format,msg...) printk(format,##msg)

  83. #else

  85. #define debug(format,msg...) (void *)(0)

  87. #endif



  91. //定义按键结构体

  93. typedef struct {
  94. //cdev 结构体
  95. struct cdev cdev;
  96. //缓冲区存放键值
  97. u8 buf_var[SZ_BUF];
  98. //当前指针，可以用来表征可用的键值的数目
  99. //初始化为 VAR_INIT_TAIL
  100. u8 tail;
  101. //按键状态，SZ_BUF表示满，满了的操作也不同
  102. u8 buf_status;
  103. } dev_key_t;
  104.  dev_key_t dev_key;


  107. // 定义设备的相关信息

  109. #define KEY_DEV_MAJOR 253

  111. #define DEV_NAME "usr_dev_key"

  113. dev_t dev_id;

  115. struct class *usr_dev_class;

  117. struct key_info

  119. {

  121. uint irq_no;//中断号

  123. uint pin;//管脚值

  125. uint pin_set;//管脚设置
  126. u8 value;    //值

  128. }key_info_tab[]=

  130. {

  132. [0]={

  134.     .irq_no=IRQ_EINT1,

  136.     .pin=S3C2410_GPF(1),
  137.         
  138.     .pin_set = S3C2410_GPF1_EINT1,

  140.     .value=0xff

  142.     },

  144. [1]={

  146.     .irq_no=IRQ_EINT4,

  148.     .pin=S3C2410_GPF(4),
  149.     .pin_set = S3C2410_GPF4_EINT4,

  151.     .value=0xff

  153.     },

  155. [2]={

  157.     .irq_no=IRQ_EINT2,

  159.     .pin=S3C2410_GPF(2),
  160.     .pin_set = S3C2410_GPF2_EINT2,

  162.     .value=0xff

  164.     },

  166. [3]={

  168.     .irq_no=IRQ_EINT0,
  169.     .pin_set = S3C2410_GPF0_EINT0,

  171.     .pin=S3C2410_GPF(0),

  173.     .value=0

  175.     }

  177. };

  179. //设备操作结构体
  180. extern struct file_operations file_ops;

  182. //这个宏直接获得 表x中的irq值
  183. #define irq(x) (key_info_tab[x].irq_no)
  184. //这个宏直接获得 表x中的pin值
  185. #define pin(x) (key_info_tab[x].pin)
  186. //这个宏直接获得 表x中的pin_set值
  187. #define set(x) (key_info_tab[x].pin_set)
  188. //这个宏直接获得 表x中的value值
  189. #define var(x) (key_info_tab[x].value)
  190. //这个宏直接获得dev_key.buf_var[x]的值
  191. #define buf(x) (dev_key.buf_var[x])
  192. //获得tail值得
  193. #define get_tail()     (dev_key.tail)
  194. //设置dev_key.tail=x
  195. #define set_tail_as(x)     dev_key.tail=x
  196. //设置dev_key.buf_var[index]=x
  197. #define set_buf_as(index,x) dev_key.buf_var[index]=x




  202. //dev_key.tail)%(SZ_BUF),保证dev_key.tail处于0到15之间
  203. #define inc_tail() dev_key.tail=((dev_key.tail+1)%(SZ_BUF))
  204. //inc_buf_num确保dev_key.buf_status值在0-SZ_BUF之间
  205.  #define inc_buf_num() dev_key.buf_status=(dev_key.buf_status==SZ_BUF?SZ_BUF:(dev_key.buf_status+1))
  206. //注意上面的inc_tail()这个宏，是实现环形状数据结构的关键


  209. //定义按键事件
  210. //
  211. #define EV_KEY_MASK (0x0f)
  212. //00000001稳定的释放状态
  213. #define EV_KEY_UP (0x01<<0)
  214. //00000010，稳定的按下状态
  215. #define EV_KEY_DN (0x02<<0)
  216. //0000,0011,按下，产生下降沿的那个状态
  217. #define EV_KEY_XIN (0x03<<0)
  218. //0000,0100,释放，产生上升沿的那个状态
  219. #define EV_KEY_XOUT (0x04<<0)
  220. //释放和按下，对应的GPIO的值
  221. #define VAR_KEY_DN 0x00
  222. #define VAR_KEY_UP 0x01

  224. //定义按键id，ID_KEY_MASK是为了获得键值
  225. #define ID_KEY_MASK (0xf0)
  226. //0001，0000
  227. #define ID_KEY_1 (0x01<<4)
  228. //0010，0000
  229. #define ID_KEY_2 (0x02<<4)
  230. //0011，0000
  231. #define ID_KEY_3 (0x03<<4)
  232. //0100，0000
  233. #define ID_KEY_4 (0x04<<4)


  236. //这是一个宏，通过键的值value获得EV
  237. #define get_key_ev(value) (value & EV_KEY_MASK)
  238. //这是一个宏，通过键的值value获得按键id
  239. #define get_key_id(value) (value & ID_KEY_MASK)>>4
  240. //下面这俩个宏，通过id,ev设置key_info_tab
  241. #define set_key_value(id,ev) (key_info_tab[id].value=((id+1) <<4|ev)&0xff)
  242. #define set_key_var(id,ev) (key_info_tab[id].value=(((id+1) <<4)|ev)&0xff)
  243.     
  244.     
  245.     
  246.     
  247. ////////////////////////////////////////////////////////////////////
  248. //@如下是实现中断下半部的机制，包含timer，workqueue,tasklet几种类型

  250. //定时器处理函数
  251. void my_timer_proc(long);
  252. //定义定时器
  253. DEFINE_TIMER(key_timer,my_timer_proc,0,0);

  255. //tasklet处理函数
  256. void my_task_proc(int);
  257. //定义tasklet
  258. DECLARE_TASKLET(my_task_let,my_task_proc,0);

  260. //工作队列结构体
  261. struct work_struct work_wq;
  262. //延时工作队列结构体，在linux/workqueue.h里面定义的
  263. struct delayed_work delayed_work_wq;
  264. //工作队列的处理函数
  265. void my_work_proc(struct work_struct * my_work);

  267. //按键等待队列头，这个是为了实现和等待队列相关的操作的
  268. static DECLARE_WAIT_QUEUE_HEAD(key_waitq);


  271. ///如下表示采用何种方法实现中断下半部
  272. //!=0表示采用此方法，注意，一次只能有一个为1,否则会重复保存数据
  273. //
  274. //采用工作队列的方法
  275. #define METHOD_WORK 0
  276. //采用延时工作队列的方法
  277. #define METHOD_DELAYED_WORK 1
  278. //采用定时器的方法，mod_timer()
  279. #define METHOD_TIMER 0
  280. //采用新旧jiffies的方法，个人原创
  281. #define METHOD_JIFFIES 0
  282. //采用tasklet
  283. #define METHOD_TASKLET 0
  284. //采用msleep()方法,尚未调试成功
  285. #define METHOD_MSLEEP 0

  287. //jiffies2保存最旧的jiffies
  288. //jiffies1保存上一次的jiffies
  289. //jiffies0保存此次中断的jiffies
  290. unsigned long volatile jiffies2=0;
  291. unsigned long volatile jiffies1=0;
  292. unsigned long volatile jiffies0=0;

  294. //注意down1,和down0，这个是为了实现jiffies方法而实现的
  295. int volatile down1 =0;
  296. int volatile down0 =0;

  298. //信号量，实现互斥，潮流，必须的
  299. struct semaphore sem;

  301. //注意这个，这是一个public glob变量，注意不用优化的volatile修饰符
  302. unsigned int volatile active_key;


  305. //采用工作队列的方法
  306. //#define METHOD_WORK 1
  307. void my_work_proc(struct work_struct * my_work)
  308. {
  309.     
  310.      debug("in %s ,do somthing------------[ok]\n",__func__);
  311.       return;
  312.     
  313. }

  315. ////这是一个函数，这个函数实现保存
  316. //按键id到当前可用buf的功能
  317. //当前可用buf是指buf[tail]
  318. void save_to_buf(int id)
  319. {
  320.     if(dev_key.buf_status==VAR_INIT)
  321.         {
  322.             set_tail_as(0);
  323.             dev_key.buf_status=0;
  324.         }
  325.     //set_buf_as(index,x);
  326.     set_buf_as(get_tail(),var(id));
  327.     
  328.     debug("in %s,buf[%d]=%x\n",__func__,get_tail(),buf(get_tail()));
  329.     
  330. //每保存一次都需要自增tail,buf数据量增加一次
  331.     inc_tail();
  332.     inc_buf_num();
  333.     return ;
  334. };
  335. /*
  336. //jiffies方法，个人原创的，
  337. //这个方法的主要特点是对应的
  338. // down0保存最新中断时的按键值
  339. //jiffies0如是
  340. //down1保存上一次中断的按键值，即上一个down0值
  341. //jiffies1如是
  342. //实现该功能的关键在于设置了如下的条件判断 if(jiffies1-jiffies0>TM1000MS/2)
  343. //这个判断是基于一个事实的：IRQ_TYPE_EDGE_BOTH类型的按键中断必然会产生>俩个的按键中断
  344. //一个是下降沿一个是上升边沿
  345. //如果俩个沿的时间差>500毫妙(因为我们认为每次按键的时间一般会大于500ms，低于500ms的我们认为是抖动)
  346. //并且俩个沿之间的电平为VAR_KEY_DN
  347. //我们则认为这是一个有效的按键具体可以
  348. // if(jiffies1-jiffies0>TM1000MS/2)
  349. */
  350. //#define METHOD_JIFFIES 1
  351. void my_jiffies_proc(int id)
  352. {

  354.     jiffies1=jiffies0;
  355.      jiffies0=jiffies;
  356.      down1=down0;
  357.      down0=s3c2410_gpio_getpin(pin(id));
  358.     if(jiffies1-jiffies0>TM1000MS/2){
  359.                  if(down0==VAR_KEY_DN)
  360.                      {
  361.                      set_key_var(id,EV_KEY_DN);
  362.                      save_to_buf(id);
  363.                      
  364.                      debug("in %s save a value [%x]to buf[%d]",__func__,buf(get_tail()-1),get_tail()-1);
  365.                     
  366.                      }
  367.          }

  369.     }
  370. /*
  371. #define METHOD_DELAY_WORK 1
  372. 这实际上是一个定时器，但比定时器有内涵多了
  373. 他的名字叫做延时工作队列方法
  374. 对应调用方式schedule_delayed_work();
  375. */
  376. void my_delay_work_proc(struct work_struct * my_work)
  377. {
  378.      int id= active_key;
  379.         u8 key_real_var=s3c2410_gpio_getpin(pin(id));
  380.          if(key_real_var==VAR_KEY_DN)
  381.          {
  382.     
  383.          set_key_var(id,EV_KEY_DN);
  384.          save_to_buf(id);
  385.  debug("in %s save a value [%x]to buf[%d]",__func__,buf(get_tail()-1),get_tail()-1);
  386.          wake_up_interruptible(&key_waitq);
  387.         
  388.                      
  389.          }
  390.      return;
  391. }

  393. /*
  394. 定时器处理线程，实现延时去抖动
  395. 这个是最经典的方法
  396. */
  397. void my_timer_proc(long key )
  398.     {
  399.      debug("in %s ,do somthing------------[ok]\n",__func__);
  400.       return;
  401.     }
  402.     
  403. /*
  404. tasklet方式，在这里说明一下，
  405. 这种方式虽然好，但是和    work_struct一样不能处理抖动问题
  406. */
  407. void my_task_proc(int key)
  408. {
  409.      debug("in %s ,do somthing------------[ok]\n",__func__);
  410.       return;

  412. }
  413. /*
  414. 利用msleep函数实现延时，调试没有通过
  415. */
  416. void my_msleep_proc(int key,int ms)
  417.     {
  418.         debug("in %s ,do somthing------------[ok]\n",__func__);
  419.         msleep_interruptible(ms);
  420.         return;
  421.     }
  422. /*

  424. @key_open，打开函数

  426. @

  428. */

  430. static int key_open(struct inode * pnode,struct file * pfile)
  431. {

  433.     int ret=0;
  434.     pfile->private_data=(dev_key_t *)&dev_key;
  435.     down(&sem);
  436.     return ret;

  438. };



  442. /*
  443. @key_release，关闭函数
  444. @关闭后
  445. */

  447. static int key_release(struct inode * pnode,struct file * pfile){

  449.     int ret=0;


  452.     //buf(0)=VAR_INIT;
  453.     var(0)=VAR_INIT;
  454.     var(1)=VAR_INIT;
  455.     var(2)=VAR_INIT;
  456.     var(3)=VAR_INIT;
  457.      // set_tail_as(0);
  458.      up(&sem);
  459.     return ret;

  461. };


  464. /*
  465. 这个函数用来干什么的呢？
  466. 这是为了实现一个理念：
  467. 排在列表头的或者列表尾的
  468. 一定要是最新的或者最旧的按键值
  469. 这个适合copy_to_user函数一起使用的
  470. */
  471. static int buf_sort(char a[])
  472. {
  473.     int i;
  474.     int j;
  475.     if(dev_key.buf_status==SZ_BUF)
  476.         {
  477.             for(j=0,i=SZ_BUF+get_tail()-1;j<SZ_BUF;i--,j++)
  478.             {
  479.                 a[j]=buf(i%SZ_BUF);
  480.             }    
  481.         }
  482.     else if(dev_key.buf_status<SZ_BUF)
  483.         {
  484.             for(i=0,j=dev_key.buf_status;j>=0;i++,j--)
  485.             {
  486.                 a[i]=buf(j);
  487.             }    
  488.         }
  489.         return;
  490. }

  492. /*
  493. 这个函数实现阻塞读
  494. */

  496. static int key_read(struct file * pfile,char * buf,size_t count, loff_t *offp)
  497. {

  499.     int ret=0;

  501.     int i=0;
  502.    int my_count=0;
  503.     char *msg;
  504.     u8 my_buf[SZ_BUF];

  506.     dev_key_t *dev=pfile->private_data;


  509.     DECLARE_WAITQUEUE(wq,current);
  510.     if(dev_key.buf_status==VAR_INIT)

  512.         {

  514.     if(pfile->f_flags & O_NONBLOCK)

  516.                 {

  518.             return -EAGAIN;    

  520.                 }

  522.             else

  524.                 {
  525.                 add_wait_queue(&key_waitq,&wq);
  526.                 wait_event_interruptible(key_waitq,buf(0)!=VAR_INIT);
  527.                 }    

  529.         }
  530.         
  531.         buf_sort(my_buf);
  532.         if(dev_key.buf_status==SZ_BUF)
  533.             {
  534.             count    = (count >SZ_BUF ? count :SZ_BUF);    
  535.             }
  536.         else if(dev_key.buf_status <SZ_BUF)
  537.             {
  538.             count = count >dev_key.buf_status ? dev_key.buf_status : count;
  539.             }    
  540.     ret=copy_to_user(buf,my_buf,count);    

  542.     msg=(ret==0?"OK":"NO");

  544.     debug("key_read:-------------------[%s],using count=%d,offp=%d\n",msg,i,(int)*offp);
  545.     remove_wait_queue(&key_waitq,&wq);
  546. return ret;

  548.     

  550.     

  552. };



  556. /*

  558. 中断处理函数，是枢纽

  560. */

  562. static irqreturn_t irq_proc(unsigned int irq,int _id)
  563. {    

  565.         active_key =_id;
  566.         #if METHOD_WORK
  567.         schedule_work(&work_wq);
  568.         #endif

  570.         #if METHOD_DELAYED_WORK
  571.         schedule_delayed_work(&delayed_work_wq,TM1000MS/10);
  572.         #endif


  575.         #if METHOD_TIMER
  576.         /*1HZ=1s=100个jiffies单位*/
  577.          key_timer.data=_id;
  578.         mod_timer(&key_timer,jiffies+TM1000MS/10);
  579.         #endif

  581.         #if METHOD_TASKLET
  582.         my_task_let.data=_id;
  583.         tasklet_schedule(&my_task_let);
  584.         #endif

  586.         #if METHOD_MSLEEP
  587.             my_msleep_proc(_id, TM1000MS/50);
  588.             
  589.         #endif
  590.         
  591.         
  592.     
  593.     
  594.     #if METHOD_JIFFIES
  595.         my_jiffies_proc(_id);
  596.     #endif
  597.      wake_up_interruptible(&key_waitq);
  598.     debug("extern from %s,active_key=%d\n",__func__,active_key);

  600.      return IRQ_RETVAL(IRQ_HANDLED);

  602.     };





  608. /*

  610. @dev_init，设备初始化函数，程式化的东西

  612. @

  614. */
  615. static int dev_init(void)
  616. {

  618.     int ret=0;

  620.     int i;

  622.     char * msg;

  624.     
  625.     
  626.     
  627.     ///cdev

  629.     cdev_init(&(dev_key.cdev),&file_ops);

  631.     dev_key.cdev.owner=THIS_MODULE;

  633.     dev_key.cdev.ops=&file_ops;

  635.     cdev_add(&(dev_key.cdev),dev_id,1);

  637.     

  639.     //register chr dev

  641.     #ifdef DEV_KEY_MAJOR

  643.         dev_id=MKDEV(DEV_KEY_MAJOR,0);

  645.         ret=register_chrdev_region(dev_id,1,DEV_NAME);

  647.         if(ret！=0)//！=0意味着注册失败
  648.     
  649.             goto alloc_method;

  651.         else

  653.             goto print_irq_msg;

  655.     #endif

  657.      alloc_method:

  659.          ret =alloc_chrdev_region(&dev_id,0,1,DEV_NAME);
  660.      
  661.      print_irq_msg:    

  663.          msg=(ret==0?"OK":"ERR");

  665.          debug("register devivice: %s -------[%s],using major=%d\n",DEV_NAME,msg,MAJOR(dev_id));

  667.      if(ret)
  668.           goto unregister_irq_handle;

  670.     

  672. //初始化中断

  674. for(i=0;i<get_elem_num(key_info_tab);i++)

  676.         {
  677.     ret=request_irq(key_info_tab[i].irq_no,irq_proc,IRQ_TYPE_EDGE_BOTH,DEV_NAME,i);

  679.         
  680.         
  681.         msg=(ret==0?"OK":"ERR");

  683.          debug("register %s.ext_irq[%d] -------[%s],using irq_no=%d\n",DEV_NAME,i,msg,key_info_tab[i].irq_no);
  684.         
  685.         if(ret!=0)
  686.             goto unregister_irq_handle;

  688.     
  689.         }
  690.       
  691.      init_MUTEX(&sem);
  692.         INIT_WORK(&work_wq,my_work_proc);
  693.         INIT_DELAYED_WORK(&delayed_work_wq,my_delay_work_proc);
  694.         
  695.         init_waitqueue_head(&key_waitq);
  696.        //setup_timer(&key_timer,&my_timer_proc,0);
  697.        init_timer(&key_timer);
  698.        key_timer.function=&my_timer_proc;
  699.        add_timer(&key_timer);
  700.        jiffies2=VAR_INIT;
  701.         jiffies1=VAR_INIT;
  702.          jiffies0=VAR_INIT;
  703.          
  704.          dev_key.buf_status=0;
  705.          set_tail_as(0);
  706.          usr_dev_class=class_create(THIS_MODULE,"usr_dev");
  707.          device_create(usr_dev_class,NULL,dev_id,NULL,"usr_dev_key");
  708.          
  709.      out:
  710.         
  711.          return ret;

  713. unregister_irq_handle:
  714.         for(i=i-1;i>=0;i--)
  715.         {
  716.             free_irq(key_info_tab[i].irq_no,dev_id);
  717.         }

  719.      return ret;
  720.     

  722. };



  726. /*

  728. @key_poll

  730. */

  732. static int key_poll(struct file *filep,poll_table *wt_poll)
  733. {

  735.     int mask=0;

  737.     dev_key_t *dev = filep->private_data;

  739.     poll_wait(filep,&key_waitq,wt_poll);

  741.     if(buf(0)!=VAR_INIT)
  742.         {
  743.             
  744.         mask=POLLIN    |    POLLRDNORM;
  745.         
  746.         }
  747.     return mask;

  749. };




  754. /*

  756. @dev_exit，exit dev

  758. @

  760. */

  762. static int dev_exit(void)
  763. {

  765.     int i;

  767.         unregister_chrdev(MAJOR(dev_id),DEV_NAME);
  768.         for(i=0;i<get_elem_num(key_info_tab);i++)

  770.         {

  772.         free_irq(irq(i),dev_id);
  773.        
  774.         
  775.         }
  776.         del_timer(&key_timer);
  777.         device_destroy(usr_dev_class,dev_id);
  778.         class_destroy(usr_dev_class);

  780.          return 0;

  782.     

  784.     

  786. };

  788. /*

  790. @key_ioctl

  792. */

  794. static int key_ioctl(struct inode *inodep,struct file *filep,unsigned int cmd, unsigned long arg )
  795. {

  797.     int ret;    
  798.     switch(cmd)
  799.         {

  801.             case CMD_RESET:

  803.                 dev_key.buf_status=0;
  804.                 set_tail_as(0);

  806.                 ret=1;    

  808.                 break;

  810.             default:

  812.                 ret =-EINVAL;

  814.                 break;

  816.                 

  818.         };

  820.     return ret;

  822. };





  828. /*

  830. file_operations结构体

  832. */


  835. struct file_operations file_ops={
  836. .owner     =    THIS_MODULE,

  838. .read        =     key_read,

  840. .ioctl        =    key_ioctl,

  842. .poll            =    key_poll,

  844. .open        =    key_open,

  846. .release    =    key_release

  848. };

  850. MODULE_AUTHOR("keytounix");

  852. MODULE_LICENSE("Dual BSD/GPL");

  854. MODULE_DESCRIPTION("driver for TQ2440 key");

  856. module_init(dev_init);
  857. module_exit(dev_exit);

阅读(2173) | 评论(0) | 转发(0) |
0

上一篇：linux2.6.32.移植到TQ2440

下一篇：TQ2440按键驱动2-作为input子系统

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

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

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

16024965号-6