驱动02.按键

一.以查询方式实现

1.写出驱动框架
　　1.1 仿照其他程序加一些必要的头文件
　　1.2 构造一个结构体file_operations
　　1.3 根据file_operations的所选项写出所需的函数，并构建出来
　　1.4 入口函数、出口函数的注册和卸载
　　1.5 修饰入口函数和出口函数
　　1.6 给sysfs提供更多的信息，并有udev机制自动创建/dev/xxx设备节点
2.硬件操作
　　2.1 sch原理图
　　2.2 2440手册
　　2.3 编程：物理地址到虚拟地址的映射

  1 /*
  2   *以查询的方式实现按键驱动程序
  3   */
  4 
  5 #include <linux/module.h>
  6 #include <linux/kernel.h>
  7 #include <linux/fs.h>
  8 #include <linux/init.h>
  9 #include <linux/delay.h>
 10 #include <asm/uaccess.h>
 11 #include <asm/irq.h>
 12 #include <asm/io.h>
 13 #include <asm/arch/regs-gpio.h>
 14 #include <asm/hardware.h>
 15 
 16 
 17 static struct class *g_ptSeconddrvCls;
 18 static struct class_device *g_ptSeconddrvClsDev;
 19 
 20 volatile unsigned long *gpfcon;
 21 volatile unsigned long *gpfdat;
 22 
 23 volatile unsigned long *gpgcon;
 24 volatile unsigned long *gpgdat;
 25 
 26 static int seconddrv_open(struct inode *inode, struct file *file)
 27 {
 28     /* 配置GPF0,2为输入引脚 */
 29     *gpfcon &= ~((0x3<<(0*2)) | (0x3<<(2*2)));
 30 
 31     /* 配置GPG3,11为输入引脚 */
 32     *gpgcon &= ~((0x3<<(3*2)) | (0x3<<(11*2)));
 33 
 34     return 0;
 35 }
 36 
 37 static ssize_t seconddrv_read(struct file *file, char __user *buf, size_t size, loff_t *ppos)
 38 {
 39     /* 返回4个引脚的电平 */
 40     unsigned char key_vals[4];
 41     int regval;
 42 
 43     if (size != sizeof(key_vals))
 44         return -EINVAL;
 45 
 46     /* 读GPF0,2 */
 47     regval = *gpfdat;
 48     key_vals[0] = (regval & (1<<0)) ? 1 : 0;
 49     key_vals[1] = (regval & (1<<2)) ? 1 : 0;
 50     
 51 
 52     /* 读GPG3,11 */
 53     regval = *gpgdat;
 54     key_vals[2] = (regval & (1<<3)) ? 1 : 0;
 55     key_vals[3] = (regval & (1<<11)) ? 1 : 0;
 56 
 57     copy_to_user(buf, key_vals, sizeof(key_vals));
 58     
 59     return sizeof(key_vals);
 60 }
 61 
 62 static struct file_operations seconddrv_fops = {
 63     .owner = THIS_MODULE,
 64     .open   = seconddrv_open,     
 65     .read   =    seconddrv_read,
 66 };
 67 
 68 
 69 int g_iMajor;
 70 static int seconddrv_init(void)
 71 {
 72     g_iMajor = register_chrdev(0, "second_drv", &seconddrv_fops);
 73 
 74     g_ptSeconddrvCls = class_create(THIS_MODULE, "second_drv");
 75 
 76     g_ptSeconddrvClsDev = class_device_create(g_ptSeconddrvCls, NULL, MKDEV(g_iMajor, 0), NULL, "buttons"); /* /dev/buttons */
 77 
 78     gpfcon = (volatile unsigned long *)ioremap(0x56000050, 16);
 79     gpfdat = gpfcon + 1;
 80 
 81     gpgcon = (volatile unsigned long *)ioremap(0x56000060, 16);
 82     gpgdat = gpgcon + 1;
 83 
 84     return 0;
 85 }
 86 
 87 static int seconddrv_exit(void)
 88 {
 89     unregister_chrdev(g_iMajor, "second_drv");
 90     class_device_unregister(g_ptSeconddrvClsDev);
 91     class_destroy(g_ptSeconddrvCls);
 92     iounmap(gpfcon);
 93     iounmap(gpgcon);
 94     return 0;
 95 }
 96 
 97 module_init(seconddrv_init);
 98 
 99 module_exit(seconddrv_exit);
100 MODULE_LICENSE("GPL");

查询方式的按键驱动程序

 1 #include <sys/types.h>
 2 #include <sys/stat.h>
 3 #include <fcntl.h>
 4 #include <stdio.h>
 5 
 6 /* 2nddrvtest 
 7   */
 8 int main(int argc, char **argv)
 9 {
10     int fd;
11     unsigned char key_vals[4];
12     int cnt = 0;
13     
14     fd = open("/dev/buttons", O_RDWR);
15     if (fd < 0)
16     {
17         printf("can't open!
");
18     }
19 
20     while (1)
21     {
22         read(fd, key_vals, sizeof(key_vals));
23         if (!key_vals[0] || !key_vals[1] || !key_vals[2] || !key_vals[3])
24         {
25             printf("%04d key pressed: %d %d %d %d
", cnt++, key_vals[0], key_vals[1], key_vals[2], key_vals[3]);
26         }
27     }
28     
29     return 0;
30 }

测试程序

二、使用中断方式实现按键驱动程序

使用查询方式实现时，程序一直占用CPU资源，CPU利用率低。

改进的办法：使用中断的方式实现

1.linux中断异常体系分析

　　1.1 异常向量的设置trap_init()
   trap_init被用来设置各种异常的处理向量，trap_init函数将异常向量复制到0xffff0000处
   trap_init
       memcpy((void *)vectors, __vectors_start, __vectors_end - __vectors_start);
           vector_irq
               vector_stub（宏）//计算返回地址，保存一些寄存器
                   __irq_usr     //根据被中断的工作模式进入相应的某个跳转分支->进入管理模式
                       usr_entry(宏)//保存一些寄存器的值
                           .maro irq_handler（宏）
                               asm_do_IRQ //异常处理函数
　　1.2 异常处理函数asm_do_IRQ
　　asm_do_IRQ
   　　定义了一个结构体数组desc[NR_IRQS]
       　　 irq_enter
       　　desc_handle_irq：desc->handle_irq

　　1.3 结构数组desc[NR_IRQS]的构建
　　s3c24xx_init_irq
   　　set_irq_chip    //chip=s3c_irq_eint0t4，可设置触发方式，使能中断，禁止中断等底层芯片相关的操作
   　　set_irq_flags
   　　set_irq_handler(irqno, handle_edge_irq)//handle_irq=handle_edge_irq
       　　 __set_irq_handler
           　　desc_handle_irq
　　

　　中断处理函数handle_edge_irq
　　　　handle_edge_irq
   　　　　desc->chip->ack(irq)//清中断
   　　　　handle_IRQ_event//取出action链表中的成员，执行action->handler
　　1.4 用户注册中断处理函数的过程request_irq
　　request_irq(unsigned int irq, irq_handler_t handler,unsigned long irqflags, const char *devname, void *dev_id)
       　　//用户通过request_irq向内核注册中断处理函数：a.分配了irqaction结构b.调用setup_irq函数
   　　setup_irq(irq,action)//将新建的irqaction结构链入irq_desc[irq]结构的action链表中P405
   　　desc->chip->settype//定义引脚为中断引脚
   　　desc->chip->startup/enable//引脚使能
　　1.5 free_irq(irq,dev_id)//卸载中断服务程序
   　　 a.出链
   　　b.禁止中断

　　1.6 总结：handle_irq是这个中断的处理函数入口，发生中断时，总入口函数asm_do_IRQ函数将根据中断号调用相应irq_desc数组项的handle_irq。handle_irq使用chip结构体中的函数来清除、屏蔽或者重新enable中断，还一一调用用户在action链表中注册的中断处理函数。

2.编写代码

  1 /*
  2   *用中断方式实现按键驱动程序
  3   */
  4 
  5 #include <linux/module.h>
  6 #include <linux/kernel.h>
  7 #include <linux/fs.h>
  8 #include <linux/init.h>
  9 #include <linux/delay.h>
 10 #include <linux/irq.h>
 11 #include <asm/uaccess.h>
 12 #include <asm/irq.h>
 13 #include <asm/io.h>
 14 #include <asm/arch/regs-gpio.h>
 15 #include <asm/hardware.h>
 16 
 17 
 18 static struct class *g_ptThirddrvCls;
 19 static struct class_device *g_ptThirddrvClsDev;
 20 
 21 volatile unsigned long *gpfcon;
 22 volatile unsigned long *gpfdat;
 23 
 24 volatile unsigned long *gpgcon;
 25 volatile unsigned long *gpgdat;
 26 
 27 static DECLARE_WAIT_QUEUE_HEAD(button_waitq);
 28 
 29 /* 中断事件标志, 中断服务程序将它置1，third_drv_read将它清0 */
 30 static volatile int ev_press = 0;
 31 
 32 struct pin_desc{
 33     unsigned int pin;
 34     unsigned int key_val;
 35 };
 36 
 37 static unsigned char key_val;
 38 
 39 struct pin_desc pins_desc[4] = {
 40     {S3C2410_GPF0, 0x01},
 41     {S3C2410_GPF2, 0x02},
 42     {S3C2410_GPG3, 0x03},
 43     {S3C2410_GPG11, 0x04},
 44 };
 45 
 46 
 47 /*
 48   * 确定按键值
 49   */
 50 static irqreturn_t buttons_irq(int irq, void *dev_id)
 51 {
 52     struct pin_desc * pindesc = (struct pin_desc *)dev_id;
 53     unsigned int pinval;
 54     
 55     pinval = s3c2410_gpio_getpin(pindesc->pin);
 56 
 57     if (pinval)
 58     {
 59         /* 松开 */
 60         key_val = 0x80 | pindesc->key_val;
 61     }
 62     else
 63     {
 64         /* 按下 */
 65         key_val = pindesc->key_val;
 66     }
 67 
 68     ev_press = 1;                  /* 表示中断发生了 */
 69     wake_up_interruptible(&button_waitq);   /* 唤醒休眠的进程 */
 70 
 71     
 72     return IRQ_RETVAL(IRQ_HANDLED);
 73 }
 74 
 75 static int thirddrv_open(struct inode *inode, struct file *file)
 76 {
 77     request_irq(IRQ_EINT0,  buttons_irq, IRQT_BOTHEDGE, "S2", &pins_desc[0]);
 78     request_irq(IRQ_EINT2,  buttons_irq, IRQT_BOTHEDGE, "S3", &pins_desc[1]);
 79     request_irq(IRQ_EINT11, buttons_irq, IRQT_BOTHEDGE, "S4", &pins_desc[2]);
 80     request_irq(IRQ_EINT19, buttons_irq, IRQT_BOTHEDGE, "S5", &pins_desc[3]);    
 81 
 82     return 0;
 83 }
 84 
 85 static ssize_t thirddrv_read(struct file *file, char __user *buf, size_t size, loff_t *ppos)
 86 {
 87     
 88     if (size != 1)
 89         return -EINVAL;
 90 
 91     /* 如果没有按键动作, 休眠 */
 92     wait_event_interruptible(button_waitq, ev_press);
 93 
 94     /* 如果有按键动作, 返回键值 */
 95     copy_to_user(buf, &key_val, 1);
 96     ev_press = 0;
 97     
 98     return 1;
 99 }
100 
101 static int thirddrv_close (struct inode * inode, struct file * file)
102 {
103     free_irq(IRQ_EINT0,&pins_desc[0]);
104     free_irq(IRQ_EINT2,&pins_desc[1]);
105     free_irq(IRQ_EINT11,&pins_desc[2]);
106     free_irq(IRQ_EINT19,&pins_desc[3]);
107 
108     return 0;
109 }
110 
111 static struct file_operations thirddrv_fops = {
112     .owner = THIS_MODULE,
113     .open   = thirddrv_open,     
114     .read   =    thirddrv_read,
115     .release = thirddrv_close,
116 };
117 
118 
119 int g_iMajor;
120 static int thirddrv_init(void)
121 {
122     g_iMajor = register_chrdev(0, "third_drv", &thirddrv_fops);
123 
124     g_ptThirddrvCls = class_create(THIS_MODULE, "third_drv");
125 
126     g_ptThirddrvClsDev = class_device_create(g_ptThirddrvCls, NULL, MKDEV(g_iMajor, 0), NULL, "buttons"); /* /dev/buttons */
127 
128     gpfcon = (volatile unsigned long *)ioremap(0x56000050, 16);
129     gpfdat = gpfcon + 1;
130 
131     gpgcon = (volatile unsigned long *)ioremap(0x56000060, 16);
132     gpgdat = gpgcon + 1;
133 
134     return 0;
135 }
136 
137 static int thirddrv_exit(void)
138 {
139     unregister_chrdev(g_iMajor, "third_drv");
140     class_device_unregister(g_ptThirddrvClsDev);
141     class_destroy(g_ptThirddrvCls);
142     iounmap(gpfcon);
143     iounmap(gpgcon);
144     return 0;
145 }
146 
147 module_init(thirddrv_init);
148 
149 module_exit(thirddrv_exit);
150 MODULE_LICENSE("GPL");

驱动程序

 1 #include <sys/types.h>
 2 #include <sys/stat.h>
 3 #include <fcntl.h>
 4 #include <stdio.h>
 5 #include <unistd.h>
 6 
 7 /* thirddrvtest 
 8   */
 9 int main(int argc, char **argv)
10 {
11     int fd;
12     unsigned char key_val;
13     
14     fd = open("/dev/buttons", O_RDWR);
15     if (fd < 0)
16     {
17         printf("can't open!
");
18     }
19 
20     while (1)
21     {
22         //read(fd, &key_val, 1);
23         //printf("key_val = 0x%x
", key_val);
24         sleep(5);
25     }
26     
27     return 0;
28 }

测试程序

三、在上述基础上添加poll机制

　　虽然我们实现了中断式的按键驱动，但是我们发觉，测试程序是一个无限的循环。在实际应用中并不存在这样的情况，所以我们要进一步优化——poll机制。

1.poll机制的分析

1.1 函数原型

int poll(struct pollfd *fds,nfds_t nfds, int timeout)
//Poll机制会判断fds中的文件是否可读，如果可读则会立即返回，返回的值就是可读fd的数量，如果不可读，那么就进程就会
休眠timeout这么长的时间，然后再来判断是否有文件可读，如果有，返回fd的数量，如果没有，则返回0.
1.2 poll机制在内核实现分析：
应用程序调用poll
   sys_poll
       do_sys_poll
           poll_initwait(&table)//table->pt->qproc = qproc = __pollwait
           do_poll(nfds, head, &table, timeout)
               for (;;) {
               if (do_pollfd(pfd, pt)) {     //return mask;mask=file->f_op->poll(file,pwait)
                   count++;
                   pt = NULL;
                   }
               if (count || !*timeout || signal_pending(current))
                       break;//break的条件是：count非0，超时，有信号在等待处理
                   __timeout = schedule_timeout(__timeout)//休眠
                   }
1.3 总结
①poll > sys_poll > do_sys_poll >poll_initwait，poll_initwait函数注册一下回调函数__pollwait，它就是我们的驱动程序执行poll_wait时，真正被调用的函数。
②接下来执行file->f_op->poll，即我们驱动程序里自己实现的poll函数它会调用poll_wait把自己挂入某个队列，这个队列也是我们的驱动自己定义的；它还判断一下设备是否就绪。
③如果设备未就绪，do_sys_poll里会让进程休眠一定时间，这个时间是应用提供的“超时时间”
④进程被唤醒的条件有2：一是上面说的“一定时间”到了，二是被驱动程序唤醒。驱动程序发现条件就绪时，就把“某个队列”上挂着的进程唤醒，这个队列，就是前面通过poll_wait把本进程挂过去的队列。
⑤如果驱动程序没有去唤醒进程，那么schedule_timeout(__timeout)超时后，会重复2、3动作1
次，然后返回。

2.写代码
①在测试程序中加入以下代码
while (1)
   {
       ret = poll(fds, 1, 5000);
       if (ret == 0)
       {
           printf("time out ");
       }
int main（）
{
   int ret;
   struct pollfd fds[1]
}
②在file_operations中增加一行
.poll    = forth_drv_poll
③写函数forth_drv_poll
forth_drv_poll
   poll_wait
       p->qproc(file,wait_address,p)//相当于调用了__pollwait(file,&button_waitq,p)
                                       //把当前进程挂到button_waitq队列里去
④在增加如下代码
if (ev_press)
       mask |= POLLIN | POLLRDNORM;

  1 /*
  2   *使用poll 机制实现按键驱动程序
  3   */
  4 
  5 #include <linux/module.h>
  6 #include <linux/kernel.h>
  7 #include <linux/fs.h>
  8 #include <linux/init.h>
  9 #include <linux/delay.h>
 10 #include <linux/irq.h>
 11 #include <asm/uaccess.h>
 12 #include <asm/irq.h>
 13 #include <asm/io.h>
 14 #include <asm/arch/regs-gpio.h>
 15 #include <asm/hardware.h>
 16 
 17 
 18 static struct class *g_ptForthdrvCls;
 19 static struct class_device *g_ptForthdrvClsDev;
 20 
 21 volatile unsigned long *gpfcon;
 22 volatile unsigned long *gpfdat;
 23 
 24 volatile unsigned long *gpgcon;
 25 volatile unsigned long *gpgdat;
 26 
 27 static DECLARE_WAIT_QUEUE_HEAD(button_waitq);
 28 
 29 /* 中断事件标志, 中断服务程序将它置1，forth_drv_read将它清0 */
 30 static volatile int ev_press = 0;
 31 
 32 struct pin_desc{
 33     unsigned int pin;
 34     unsigned int key_val;
 35 };
 36 
 37 static unsigned char key_val;
 38 
 39 struct pin_desc pins_desc[4] = {
 40     {S3C2410_GPF0, 0x01},
 41     {S3C2410_GPF2, 0x02},
 42     {S3C2410_GPG3, 0x03},
 43     {S3C2410_GPG11, 0x04},
 44 };
 45 
 46 
 47 /*
 48   * 确定按键值
 49   */
 50 static irqreturn_t buttons_irq(int irq, void *dev_id)
 51 {
 52     struct pin_desc * pindesc = (struct pin_desc *)dev_id;
 53     unsigned int pinval;
 54     
 55     pinval = s3c2410_gpio_getpin(pindesc->pin);
 56 
 57     if (pinval)
 58     {
 59         /* 松开 */
 60         key_val = 0x80 | pindesc->key_val;
 61     }
 62     else
 63     {
 64         /* 按下 */
 65         key_val = pindesc->key_val;
 66     }
 67 
 68     ev_press = 1;                  /* 表示中断发生了 */
 69     wake_up_interruptible(&button_waitq);   /* 唤醒休眠的进程 */
 70 
 71     
 72     return IRQ_RETVAL(IRQ_HANDLED);
 73 }
 74 
 75 static int forthdrv_open(struct inode *inode, struct file *file)
 76 {
 77     request_irq(IRQ_EINT0,  buttons_irq, IRQT_BOTHEDGE, "S2", &pins_desc[0]);
 78     request_irq(IRQ_EINT2,  buttons_irq, IRQT_BOTHEDGE, "S3", &pins_desc[1]);
 79     request_irq(IRQ_EINT11, buttons_irq, IRQT_BOTHEDGE, "S4", &pins_desc[2]);
 80     request_irq(IRQ_EINT19, buttons_irq, IRQT_BOTHEDGE, "S5", &pins_desc[3]);    
 81 
 82     return 0;
 83 }
 84 
 85 static ssize_t forthdrv_read(struct file *file, char __user *buf, size_t size, loff_t *ppos)
 86 {
 87     
 88     if (size != 1)
 89         return -EINVAL;
 90 
 91     /* 如果没有按键动作, 休眠 */
 92     wait_event_interruptible(button_waitq, ev_press);
 93 
 94     /* 如果有按键动作, 返回键值 */
 95     copy_to_user(buf, &key_val, 1);
 96     ev_press = 0;
 97     
 98     return 1;
 99 }
100 
101 static int forthdrv_close (struct inode * inode, struct file * file)
102 {
103     free_irq(IRQ_EINT0,&pins_desc[0]);
104     free_irq(IRQ_EINT2,&pins_desc[1]);
105     free_irq(IRQ_EINT11,&pins_desc[2]);
106     free_irq(IRQ_EINT19,&pins_desc[3]);
107 
108     return 0;
109 }
110 
111 static unsigned int forthdrv_poll(struct file *file, struct poll_table_struct *wait)
112 {
113     unsigned int mask = 0;
114     poll_wait(file, &button_waitq, wait); 
115 
116     if (ev_press)
117         mask |= POLLIN | POLLRDNORM;
118 
119     return mask;
120 }
121 
122 static struct file_operations forthdrv_fops = {
123     .owner   = THIS_MODULE,
124     .open    = forthdrv_open,     
125     .read     = forthdrv_read,
126     .release = forthdrv_close,
127     .poll      = forthdrv_poll,
128 };
129 
130 
131 int g_iMajor;
132 static int forthdrv_init(void)
133 {
134     g_iMajor = register_chrdev(0, "forth_drv", &forthdrv_fops);
135 
136     g_ptForthdrvCls = class_create(THIS_MODULE, "forth_drv");
137 
138     g_ptForthdrvClsDev = class_device_create(g_ptForthdrvCls, NULL, MKDEV(g_iMajor, 0), NULL, "buttons"); /* /dev/buttons */
139 
140     gpfcon = (volatile unsigned long *)ioremap(0x56000050, 16);
141     gpfdat = gpfcon + 1;
142 
143     gpgcon = (volatile unsigned long *)ioremap(0x56000060, 16);
144     gpgdat = gpgcon + 1;
145 
146     return 0;
147 }
148 
149 static int forthdrv_exit(void)
150 {
151     unregister_chrdev(g_iMajor, "forth_drv");
152     class_device_unregister(g_ptForthdrvClsDev);
153     class_destroy(g_ptForthdrvCls);
154     iounmap(gpfcon);
155     iounmap(gpgcon);
156     return 0;
157 }
158 
159 module_init(forthdrv_init);
160 
161 module_exit(forthdrv_exit);
162 MODULE_LICENSE("GPL");

使用poll机制实现按键驱动程序

 1 #include <sys/types.h>
 2 #include <sys/stat.h>
 3 #include <fcntl.h>
 4 #include <stdio.h>
 5 #include <poll.h>
 6 /* forthdrvtest 
 7   */
 8 int main(int argc, char **argv)
 9 {
10     int fd;
11     unsigned char key_val;
12     int ret;
13 
14     struct pollfd fds[1];
15     
16     fd = open("/dev/buttons", O_RDWR);
17     if (fd < 0)
18     {
19         printf("can't open!
");
20     }
21 
22     fds[0].fd     = fd;
23     fds[0].events = POLLIN;
24     while (1)
25     {
26         ret = poll(fds, 1, 5000);
27         if (ret == 0)
28         {
29             printf("time out
");
30         }
31         else
32         {
33             read(fd, &key_val, 1);
34             printf("key_val = 0x%x
", key_val);
35         }
36     }
37     return 0;
38 }

测试程序

四、异步通知机制

之前的的驱动都是应用程序主动去读取驱动程序传来的数据；有没有一直机制，就是一旦有数据，驱动程序主动通知应用程序，让应用程序来获取数据。这种机制就是异步通知。

1.异步通知的简介

异步通知是file_operations中的一个设备方法，定义为
int (*fsync) (struct file *, struct dentry *, int datasync)

1.1 四个要点

要点：
注册信号处理函数:由应用程序注册信号处理函数
谁发信号？——驱动
发给谁？——应用程序的进程ID（如何获取应用程序的进程ID？——fasync_helper函数）
怎么发？——kill_fasync函数（在中断服务程序实现）

1.2 总结

为了使设备支持异步通知机制，驱动程序中涉及以下3项工作：
①支持F_SETOWN命令，能在这个控制命令处理中设置filp->f_owner为对应进程ID。（不过此项工作已由内核完成，设备驱动无须处理）
②支持F_SETFL命令的处理，每当FASYNC标志改变时，驱动程序中的fasync()函数将得以执行。
驱动中应该实现fasync()函数。
③在设备资源可获得时，调用kill_fasync()函数激发相应的信号

应用程序：
fcntl(fd, F_SETOWN, getpid()); // 告诉内核，发给谁

Oflags = fcntl(fd, F_GETFL);
fcntl(fd, F_SETFL, Oflags | FASYNC); // 改变fasync标记，最终会调用到驱动的faync > fasync_helper：初始化/释放fasync_struct

  1 /*
  2   *异步通知机制实现按键驱动程序
  3   */
  4 
  5 #include <linux/module.h>
  6 #include <linux/kernel.h>
  7 #include <linux/fs.h>
  8 #include <linux/init.h>
  9 #include <linux/delay.h>
 10 #include <linux/irq.h>
 11 #include <asm/uaccess.h>
 12 #include <asm/irq.h>
 13 #include <asm/io.h>
 14 #include <asm/arch/regs-gpio.h>
 15 #include <asm/hardware.h>
 16 #include <linux/poll.h>
 17 
 18 
 19 static struct class *g_ptFifthdrvCls;
 20 static struct class_device *g_ptFifthdrvClsDev;
 21 
 22 volatile unsigned long *gpfcon;
 23 volatile unsigned long *gpfdat;
 24 
 25 volatile unsigned long *gpgcon;
 26 volatile unsigned long *gpgdat;
 27 
 28 static DECLARE_WAIT_QUEUE_HEAD(button_waitq);
 29 
 30 /* 中断事件标志, 中断服务程序将它置1，forth_drv_read将它清0 */
 31 static volatile int ev_press = 0;
 32 static struct fasync_struct *fifthdrv_async;
 33 
 34 struct pin_desc{
 35     unsigned int pin;
 36     unsigned int key_val;
 37 };
 38 
 39 static unsigned char key_val;
 40 
 41 struct pin_desc pins_desc[4] = {
 42     {S3C2410_GPF0, 0x01},
 43     {S3C2410_GPF2, 0x02},
 44     {S3C2410_GPG3, 0x03},
 45     {S3C2410_GPG11, 0x04},
 46 };
 47 
 48 
 49 /*
 50   * 确定按键值
 51   */
 52 static irqreturn_t buttons_irq(int irq, void *dev_id)
 53 {
 54     struct pin_desc * pindesc = (struct pin_desc *)dev_id;
 55     unsigned int pinval;
 56     
 57     pinval = s3c2410_gpio_getpin(pindesc->pin);
 58 
 59     if (pinval)
 60     {
 61         /* 松开 */
 62         key_val = 0x80 | pindesc->key_val;
 63     }
 64     else
 65     {
 66         /* 按下 */
 67         key_val = pindesc->key_val;
 68     }
 69 
 70     ev_press = 1;                  /* 表示中断发生了 */
 71     wake_up_interruptible(&button_waitq);   /* 唤醒休眠的进程 */
 72 
 73     kill_fasync(&fifthdrv_async,SIGIO, POLL_IN);
 74     return IRQ_RETVAL(IRQ_HANDLED);
 75 }
 76 
 77 static int fifthdrv_open(struct inode *inode, struct file *file)
 78 {
 79     request_irq(IRQ_EINT0,  buttons_irq, IRQT_BOTHEDGE, "S2", &pins_desc[0]);
 80     request_irq(IRQ_EINT2,  buttons_irq, IRQT_BOTHEDGE, "S3", &pins_desc[1]);
 81     request_irq(IRQ_EINT11, buttons_irq, IRQT_BOTHEDGE, "S4", &pins_desc[2]);
 82     request_irq(IRQ_EINT19, buttons_irq, IRQT_BOTHEDGE, "S5", &pins_desc[3]);    
 83 
 84     return 0;
 85 }
 86 
 87 static ssize_t fifthdrv_read(struct file *file, char __user *buf, size_t size, loff_t *ppos)
 88 {
 89     
 90     if (size != 1)
 91         return -EINVAL;
 92 
 93     /* 如果没有按键动作, 休眠 */
 94     wait_event_interruptible(button_waitq, ev_press);
 95     
 96     /* 如果有按键动作, 返回键值 */
 97     copy_to_user(buf, &key_val, 1);
 98     ev_press = 0;
 99     
100     return 1;
101 }
102 
103 static int fifthdrv_close (struct inode * inode, struct file * file)
104 {
105     free_irq(IRQ_EINT0,&pins_desc[0]);
106     free_irq(IRQ_EINT2,&pins_desc[1]);
107     free_irq(IRQ_EINT11,&pins_desc[2]);
108     free_irq(IRQ_EINT19,&pins_desc[3]);
109 
110     return 0;
111 }
112 
113 static unsigned int fifthdrv_poll(struct file *file, struct poll_table_struct *wait)
114 {
115     unsigned int mask = 0;
116     poll_wait(file, &button_waitq, wait); 
117 
118     if (ev_press)
119         mask |= POLLIN | POLLRDNORM;
120 
121     return mask;
122 }
123 
124 static int fifthdrv_fasync(int fd, struct file *file, int on)
125 {    
126     printk("driver: fifthdrv_fasync
");
127     return fasync_helper(fd, file, on, &fifthdrv_async);
128 }
129 
130 
131 static struct file_operations fifthdrv_fops = {
132     .owner   = THIS_MODULE,
133     .open    = fifthdrv_open,     
134     .read     = fifthdrv_read,
135     .release = fifthdrv_close,
136     .poll      = fifthdrv_poll,
137     .fasync  = fifthdrv_fasync,
138 };
139 
140 
141 int g_iMajor;
142 static int fifthdrv_init(void)
143 {
144     g_iMajor = register_chrdev(0, "fifth_drv", &fifthdrv_fops);
145 
146     g_ptFifthdrvCls = class_create(THIS_MODULE, "fifth_drv");
147 
148     g_ptFifthdrvClsDev = class_device_create(g_ptFifthdrvCls, NULL, MKDEV(g_iMajor, 0), NULL, "buttons"); /* /dev/buttons */
149 
150     gpfcon = (volatile unsigned long *)ioremap(0x56000050, 16);
151     gpfdat = gpfcon + 1;
152 
153     gpgcon = (volatile unsigned long *)ioremap(0x56000060, 16);
154     gpgdat = gpgcon + 1;
155 
156     return 0;
157 }
158 
159 static int fifthdrv_exit(void)
160 {
161     unregister_chrdev(g_iMajor, "fifth_drv");
162     class_device_unregister(g_ptFifthdrvClsDev);
163     class_destroy(g_ptFifthdrvCls);
164     iounmap(gpfcon);
165     iounmap(gpgcon);
166     return 0;
167 }
168 
169 module_init(fifthdrv_init);
170 
171 module_exit(fifthdrv_exit);
172 MODULE_LICENSE("GPL");

异步通知机制

 1 #include <sys/types.h>
 2 #include <sys/stat.h>
 3 #include <fcntl.h>
 4 #include <stdio.h>
 5 #include <poll.h>
 6 #include <signal.h>
 7 #include <sys/types.h>
 8 #include <unistd.h>
 9 #include <fcntl.h>
10 
11 
12 /* fifthdrvtest 
13   */
14 int fd;
15 
16 void my_signal_fun(int signum)
17 {
18     unsigned char key_val;
19     read(fd, &key_val, 1);
20     printf("key_val: 0x%x
", key_val);
21 }
22 
23 int main(int argc, char **argv)
24 {
25     unsigned char key_val;
26     int ret;
27     int Oflags;
28 
29     signal(SIGIO, my_signal_fun);
30     
31     fd = open("/dev/buttons", O_RDWR);
32     if (fd < 0)
33     {
34         printf("can't open!
");
35     }
36 
37     fcntl(fd, F_SETOWN, getpid());
38     
39     Oflags = fcntl(fd, F_GETFL); 
40     
41     fcntl(fd, F_SETFL, Oflags | FASYNC);
42 
43 
44     while (1)
45     {
46         sleep(1000);
47     }
48     
49     return 0;
50 }

测试程序

五、同步，互斥，阻塞

linux内核是多线程的内核，当有多个应用程序来访问同一个驱动程序时必将出错，这是系统所不允许的。所以，同一时刻只能有一个应用程序打开驱动程序。

实现原理：

static int canopen = 1;
在open函数内添加如下代码
if(--canopen != 0){
canopen++;
return -EBUSY;
}

在close函数内添加如下代码
canopen++;

但是，linux是多任务系统，进行某一操作的同时有可能被切换，从而导致两进程都打开了设备。

解决方案：

1.把上述步骤设置为原子操作。

open函数：
static atomic_t canopen = ATOMIC_INIT(1);
if(!atomic_desc_and_test(&canopen)){
   atomic_inc(canopen);
   return -EBUSY;
   }

close函数：
atomic_inc(canopen);

2.使用信号量实现。

定义信号量init_MUTEX(button_lock)
获得信号量down(&button_lock)
释放信号量up(&button_lock)

3.阻塞

open函数添加以下代码：

if (file->f_flags & O_NONBLOCK)
   {
       if (down_trylock(&button_lock))
               return -EBUSY;
   }
   else
   {
       /* 获取信号量 */
       down(&button_lock);
   }
在read函数添加以下代码：

　　 if (file->f_flags & O_NONBLOCK)
   {
       if (!ev_press)
           return -EAGAIN;
   }
   else
   {
       /* 如果没有按键动作, 休眠 */
       wait_event_interruptible(button_waitq, ev_press);
   }

测试方法：

当多次执行./sixth_test &时，S即睡眠状态，D即僵死状态

  1 /*
  2   *阻塞方式实现按键驱动程序
  3   */
  4 
  5 #include <linux/module.h>
  6 #include <linux/kernel.h>
  7 #include <linux/fs.h>
  8 #include <linux/init.h>
  9 #include <linux/delay.h>
 10 #include <linux/irq.h>
 11 #include <asm/uaccess.h>
 12 #include <asm/irq.h>
 13 #include <asm/io.h>
 14 #include <asm/arch/regs-gpio.h>
 15 #include <asm/hardware.h>
 16 #include <linux/poll.h>
 17 
 18 
 19 static struct class *g_ptFifthdrvCls;
 20 static struct class_device *g_ptFifthdrvClsDev;
 21 
 22 volatile unsigned long *gpfcon;
 23 volatile unsigned long *gpfdat;
 24 
 25 volatile unsigned long *gpgcon;
 26 volatile unsigned long *gpgdat;
 27 
 28 static DECLARE_WAIT_QUEUE_HEAD(button_waitq);
 29 
 30 /* 中断事件标志, 中断服务程序将它置1，forth_drv_read将它清0 */
 31 static volatile int ev_press = 0;
 32 static struct fasync_struct *fifthdrv_async;
 33 
 34 struct pin_desc{
 35     unsigned int pin;
 36     unsigned int key_val;
 37 };
 38 
 39 static unsigned char key_val;
 40 
 41 struct pin_desc pins_desc[4] = {
 42     {S3C2410_GPF0, 0x01},
 43     {S3C2410_GPF2, 0x02},
 44     {S3C2410_GPG3, 0x03},
 45     {S3C2410_GPG11, 0x04},
 46 };
 47 
 48 static DECLARE_MUTEX(button_lock);  
 49 /*
 50   * 确定按键值
 51   */
 52 static irqreturn_t buttons_irq(int irq, void *dev_id)
 53 {
 54     struct pin_desc * pindesc = (struct pin_desc *)dev_id;
 55     unsigned int pinval;
 56     
 57     pinval = s3c2410_gpio_getpin(pindesc->pin);
 58 
 59     if (pinval)
 60     {
 61         /* 松开 */
 62         key_val = 0x80 | pindesc->key_val;
 63     }
 64     else
 65     {
 66         /* 按下 */
 67         key_val = pindesc->key_val;
 68     }
 69 
 70     ev_press = 1;                  /* 表示中断发生了 */
 71     wake_up_interruptible(&button_waitq);   /* 唤醒休眠的进程 */
 72 
 73     kill_fasync(&fifthdrv_async,SIGIO, POLL_IN);
 74     return IRQ_RETVAL(IRQ_HANDLED);
 75 }
 76 
 77 static int fifthdrv_open(struct inode *inode, struct file *file)
 78 {
 79 
 80 #if 0    
 81     if (!atomic_dec_and_test(&canopen))
 82     {
 83         atomic_inc(&canopen);
 84         return -EBUSY;
 85     }
 86 #endif        
 87 
 88     if (file->f_flags & O_NONBLOCK)
 89     {
 90         if (down_trylock(&button_lock))
 91             return -EBUSY;
 92     }
 93     else
 94     {
 95         /* 获取信号量 */
 96         down(&button_lock);
 97     }
 98     
 99     request_irq(IRQ_EINT0,  buttons_irq, IRQT_BOTHEDGE, "S2", &pins_desc[0]);
100     request_irq(IRQ_EINT2,  buttons_irq, IRQT_BOTHEDGE, "S3", &pins_desc[1]);
101     request_irq(IRQ_EINT11, buttons_irq, IRQT_BOTHEDGE, "S4", &pins_desc[2]);
102     request_irq(IRQ_EINT19, buttons_irq, IRQT_BOTHEDGE, "S5", &pins_desc[3]);    
103 
104     return 0;
105 }
106 
107 static ssize_t fifthdrv_read(struct file *file, char __user *buf, size_t size, loff_t *ppos)
108 {
109     
110     if (size != 1)
111         return -EINVAL;
112 
113     if (file->f_flags & O_NONBLOCK)
114     {
115         if (!ev_press)
116             return -EAGAIN;
117     }
118     else
119     {
120         /* 如果没有按键动作, 休眠 */
121         wait_event_interruptible(button_waitq, ev_press);
122     }
123 
124     /* 如果有按键动作, 返回键值 */
125     copy_to_user(buf, &key_val, 1);
126     ev_press = 0;
127     
128     return 1;
129 }
130 
131 static int fifthdrv_close (struct inode * inode, struct file * file)
132 {
133     free_irq(IRQ_EINT0,&pins_desc[0]);
134     free_irq(IRQ_EINT2,&pins_desc[1]);
135     free_irq(IRQ_EINT11,&pins_desc[2]);
136     free_irq(IRQ_EINT19,&pins_desc[3]);
137     up(&button_lock);
138     return 0;
139 }
140 
141 static unsigned int fifthdrv_poll(struct file *file, struct poll_table_struct *wait)
142 {
143     unsigned int mask = 0;
144     poll_wait(file, &button_waitq, wait); 
145 
146     if (ev_press)
147         mask |= POLLIN | POLLRDNORM;
148 
149     return mask;
150 }
151 
152 static int fifthdrv_fasync(int fd, struct file *file, int on)
153 {    
154     printk("driver: fifthdrv_fasync
");
155     return fasync_helper(fd, file, on, &fifthdrv_async);
156 }
157 
158 
159 static struct file_operations fifthdrv_fops = {
160     .owner   = THIS_MODULE,
161     .open    = fifthdrv_open,     
162     .read     = fifthdrv_read,
163     .release = fifthdrv_close,
164     .poll      = fifthdrv_poll,
165     .fasync  = fifthdrv_fasync,
166 };
167 
168 
169 int g_iMajor;
170 static int fifthdrv_init(void)
171 {
172     g_iMajor = register_chrdev(0, "fifth_drv", &fifthdrv_fops);
173 
174     g_ptFifthdrvCls = class_create(THIS_MODULE, "fifth_drv");
175 
176     g_ptFifthdrvClsDev = class_device_create(g_ptFifthdrvCls, NULL, MKDEV(g_iMajor, 0), NULL, "buttons"); /* /dev/buttons */
177 
178     gpfcon = (volatile unsigned long *)ioremap(0x56000050, 16);
179     gpfdat = gpfcon + 1;
180 
181     gpgcon = (volatile unsigned long *)ioremap(0x56000060, 16);
182     gpgdat = gpgcon + 1;
183 
184     return 0;
185 }
186 
187 static int fifthdrv_exit(void)
188 {
189     unregister_chrdev(g_iMajor, "fifth_drv");
190     class_device_unregister(g_ptFifthdrvClsDev);
191     class_destroy(g_ptFifthdrvCls);
192     iounmap(gpfcon);
193     iounmap(gpgcon);
194     return 0;
195 }
196 
197 module_init(fifthdrv_init);
198 
199 module_exit(fifthdrv_exit);
200 MODULE_LICENSE("GPL");

信号量+阻塞方式

 1 #include <sys/types.h>
 2 #include <sys/stat.h>
 3 #include <fcntl.h>
 4 #include <stdio.h>
 5 #include <poll.h>
 6 #include <signal.h>
 7 #include <sys/types.h>
 8 #include <unistd.h>
 9 #include <fcntl.h>
10 
11 
12 /* sixthdrvtest 
13   */
14 int fd;
15 
16 void my_signal_fun(int signum)
17 {
18     unsigned char key_val;
19     read(fd, &key_val, 1);
20     printf("key_val: 0x%x
", key_val);
21 }
22 
23 int main(int argc, char **argv)
24 {
25     unsigned char key_val;
26     int ret;
27     int Oflags;
28 
29     //signal(SIGIO, my_signal_fun);
30     
31     fd = open("/dev/buttons", O_RDWR | O_NONBLOCK);
32     if (fd < 0)
33     {
34         printf("can't open!
");
35         return -1;
36     }
37 
38     //fcntl(fd, F_SETOWN, getpid());
39     
40     //Oflags = fcntl(fd, F_GETFL); 
41     
42     //fcntl(fd, F_SETFL, Oflags | FASYNC);
43 
44 
45     while (1)
46     {
47         ret = read(fd, &key_val, 1);
48         printf("key_val: 0x%x, ret = %d
", key_val, ret);
49         sleep(5);
50     }
51     
52     return 0;
53 }

测试程序

最后科普一下，异步通知和阻塞的区别：

阻塞和非阻塞关注的是程序在等待调用结果（消息，返回值）时的状态.
阻塞调用是指调用结果返回之前，当前线程会被挂起（休眠）。调用线程只有在得到结果之后才会返回。
非阻塞调用指在不能立刻得到结果之前，该调用不会阻塞当前线程。

异步关注的是消息通信机制，当一个异步过程调用发出后，调用者不会立刻得到结果，
而是在调用发出后，被调用者通过状态、通知来通知调用者，或通过回调函数处理这个调用（主动通知调用者）。

异步通知是相对与同步通知来说的。
这里阻塞与非阻塞与是否同步异步无关

比如：你问朋友问题，如果你是阻塞式调用，你会一直把自己“挂起”，直到得到问题有没有解决的结果，
如果是非阻塞式调用，你不管朋友有没有告诉你，你先去忙其他事，当然你也要偶尔看一下朋友有没有返回结果。

异步通知：朋友看到你问的问题，直接告诉你他想一下，（此时没有返回结果给你），当他想到了，会主动通知你

六、定时器防抖动

1.按键去抖动的方法
   a.硬件电路去抖动
   b.软件延时去抖动，有两种方式，其中一种是什么事都不做，死循环；另一种是利用定时器延时。

本程序采用的的定时器延时的方式。

2.定时器延时的两个要素：超时时间，处理函数。

3.定时器相关的处理函数
   a.初始化定时器init_timer
   b.处理函数timer_list.function
   c.向内核注册一个定时器结构体add_timer
   d.修改定时器时间并启动定时器mod_timer

4.mod_timer(&timer, jiffies+HZ/100)的定时时间为10ms，为什么？
HZ为100，所以HZ/100 = 1,变成了jiffies+1，而jiffies的单位为10ms，所以每次定时的时间自然就为10ms了。

  1 /*
  2   *定时器去抖动
  3   */
  4 
  5 #include <linux/module.h>
  6 #include <linux/kernel.h>
  7 #include <linux/fs.h>
  8 #include <linux/init.h>
  9 #include <linux/delay.h>
 10 #include <linux/irq.h>
 11 #include <asm/uaccess.h>
 12 #include <asm/irq.h>
 13 #include <asm/io.h>
 14 #include <asm/arch/regs-gpio.h>
 15 #include <asm/hardware.h>
 16 #include <linux/poll.h>
 17 
 18 
 19 static struct timer_list timer;
 20 
 21 static struct pin_desc *irq_pd;
 22 
 23 static struct class *g_pbuttonsdrvCls;
 24 static struct class_device *g_pbuttonsdrvClsDev;
 25 
 26 volatile unsigned long *gpfcon;
 27 volatile unsigned long *gpfdat;
 28 
 29 volatile unsigned long *gpgcon;
 30 volatile unsigned long *gpgdat;
 31 
 32 static DECLARE_WAIT_QUEUE_HEAD(button_waitq);
 33 
 34 /* 中断事件标志, 中断服务程序将它置1，forth_drv_read将它清0 */
 35 static volatile int ev_press = 0;
 36 static struct fasync_struct *buttonsdrv_async;
 37 
 38 struct pin_desc{
 39     unsigned int pin;
 40     unsigned int key_val;
 41 };
 42 
 43 static unsigned char key_val;
 44 
 45 struct pin_desc pins_desc[4] = {
 46     {S3C2410_GPF0, 0x01},
 47     {S3C2410_GPF2, 0x02},
 48     {S3C2410_GPG3, 0x03},
 49     {S3C2410_GPG11, 0x04},
 50 };
 51 
 52 static DECLARE_MUTEX(button_lock);  
 53 /*
 54   * 确定按键值
 55   */
 56 static irqreturn_t buttons_irq(int irq, void *dev_id)
 57 {
 58     /* 10ms后启动定时器 */
 59     irq_pd = (struct pin_desc *)dev_id;
 60     mod_timer(&timer, jiffies+HZ/100);
 61     return IRQ_RETVAL(IRQ_HANDLED);
 62 }
 63 
 64 static int buttonsdrv_open(struct inode *inode, struct file *file)
 65 {
 66 
 67 #if 0    
 68     if (!atomic_dec_and_test(&canopen))
 69     {
 70         atomic_inc(&canopen);
 71         return -EBUSY;
 72     }
 73 #endif        
 74 
 75     if (file->f_flags & O_NONBLOCK)
 76     {
 77         if (down_trylock(&button_lock))
 78             return -EBUSY;
 79     }
 80     else
 81     {
 82         /* 获取信号量 */
 83         down(&button_lock);
 84     }
 85     
 86     request_irq(IRQ_EINT0,  buttons_irq, IRQT_BOTHEDGE, "S2", &pins_desc[0]);
 87     request_irq(IRQ_EINT2,  buttons_irq, IRQT_BOTHEDGE, "S3", &pins_desc[1]);
 88     request_irq(IRQ_EINT11, buttons_irq, IRQT_BOTHEDGE, "S4", &pins_desc[2]);
 89     request_irq(IRQ_EINT19, buttons_irq, IRQT_BOTHEDGE, "S5", &pins_desc[3]);    
 90 
 91     return 0;
 92 }
 93 
 94 static ssize_t buttonsdrv_read(struct file *file, char __user *buf, size_t size, loff_t *ppos)
 95 {
 96     
 97     if (size != 1)
 98         return -EINVAL;
 99 
100     if (file->f_flags & O_NONBLOCK)
101     {
102         if (!ev_press)
103             return -EAGAIN;
104     }
105     else
106     {
107         /* 如果没有按键动作, 休眠 */
108         wait_event_interruptible(button_waitq, ev_press);
109     }
110 
111     /* 如果有按键动作, 返回键值 */
112     copy_to_user(buf, &key_val, 1);
113     ev_press = 0;
114     
115     return 1;
116 }
117 
118 static int buttonsdrv_close (struct inode * inode, struct file * file)
119 {
120     free_irq(IRQ_EINT0,&pins_desc[0]);
121     free_irq(IRQ_EINT2,&pins_desc[1]);
122     free_irq(IRQ_EINT11,&pins_desc[2]);
123     free_irq(IRQ_EINT19,&pins_desc[3]);
124     up(&button_lock);
125     return 0;
126 }
127 
128 static unsigned int buttonsdrv_poll(struct file *file, struct poll_table_struct *wait)
129 {
130     unsigned int mask = 0;
131     poll_wait(file, &button_waitq, wait); 
132 
133     if (ev_press)
134         mask |= POLLIN | POLLRDNORM;
135 
136     return mask;
137 }
138 
139 static int buttonsdrv_fasync(int fd, struct file *file, int on)
140 {    
141     printk("driver: buttonsdrv_fasync
");
142     return fasync_helper(fd, file, on, &buttonsdrv_async);
143 }
144 
145 
146 static void buttons_timer_func(unsigned long data)
147 {
148     struct pin_desc * pindesc = irq_pd;
149     unsigned int pinval;
150     
151     pinval = s3c2410_gpio_getpin(pindesc->pin);
152 
153     if (pinval)
154     {
155         /* 松开 */
156         key_val = 0x80 | pindesc->key_val;
157     }
158     else
159     {
160         /* 按下 */
161         key_val = pindesc->key_val;
162     }
163 
164     ev_press = 1;                  /* 表示中断发生了 */
165     wake_up_interruptible(&button_waitq);   /* 唤醒休眠的进程 */
166 
167     kill_fasync(&buttonsdrv_async,SIGIO, POLL_IN);
168 //    return IRQ_RETVAL(IRQ_HANDLED);
169 }
170 
171 static struct file_operations buttonsdrv_fops = {
172     .owner   = THIS_MODULE,
173     .open    = buttonsdrv_open,     
174     .read     = buttonsdrv_read,
175     .release = buttonsdrv_close,
176     .poll      = buttonsdrv_poll,
177     .fasync  = buttonsdrv_fasync,
178 };
179 
180 
181 int g_iMajor;
182 static int buttonsdrv_init(void)
183 {
184 
185     init_timer(&timer);
186 //    timer.expires = jiffies + media_tbl[dev->if_port].wait;
187     timer.function = &buttons_timer_func;    /* timer handler */
188     add_timer(&timer);
189 
190     
191     g_iMajor = register_chrdev(0, "buttons_drv", &buttonsdrv_fops);
192 
193     g_pbuttonsdrvCls = class_create(THIS_MODULE, "buttons_drv");
194 
195     g_pbuttonsdrvClsDev = class_device_create(g_pbuttonsdrvCls, NULL, MKDEV(g_iMajor, 0), NULL, "buttons"); /* /dev/buttons */
196 
197     gpfcon = (volatile unsigned long *)ioremap(0x56000050, 16);
198     gpfdat = gpfcon + 1;
199 
200     gpgcon = (volatile unsigned long *)ioremap(0x56000060, 16);
201     gpgdat = gpgcon + 1;
202 
203     return 0;
204 }
205 
206 static int buttonsdrv_exit(void)
207 {
208     unregister_chrdev(g_iMajor, "buttons_drv");
209     class_device_unregister(g_pbuttonsdrvClsDev);
210     class_destroy(g_pbuttonsdrvCls);
211     iounmap(gpfcon);
212     iounmap(gpgcon);
213     return 0;
214 }
215 
216 module_init(buttonsdrv_init);
217 
218 module_exit(buttonsdrv_exit);
219 MODULE_LICENSE("GPL");

定时器防抖动

 1 #include <sys/types.h>
 2 #include <sys/stat.h>
 3 #include <fcntl.h>
 4 #include <stdio.h>
 5 #include <poll.h>
 6 #include <signal.h>
 7 #include <sys/types.h>
 8 #include <unistd.h>
 9 #include <fcntl.h>
10 
11 
12 /* sixthdrvtest 
13   */
14 int fd;
15 
16 void my_signal_fun(int signum)
17 {
18     unsigned char key_val;
19     read(fd, &key_val, 1);
20     printf("key_val: 0x%x
", key_val);
21 }
22 
23 int main(int argc, char **argv)
24 {
25     unsigned char key_val;
26     int ret;
27     int Oflags;
28 
29     //signal(SIGIO, my_signal_fun);
30     
31     fd = open("/dev/input/event0", O_RDWR);
32     if (fd < 0)
33     {
34         printf("can't open!
");
35         return -1;
36     }
37 
38     //fcntl(fd, F_SETOWN, getpid());
39     
40     //Oflags = fcntl(fd, F_GETFL); 
41     
42     //fcntl(fd, F_SETFL, Oflags | FASYNC);
43 
44 
45     while (1)
46     {
47         ret = read(fd, &key_val, 1);
48         printf("key_val: 0x%x, ret = %d
", key_val, ret);
49         //sleep(5);
50     }
51     
52     return 0;
53 }

测试程序

修改于2017-01-08 21:05:56