lLinux平台设备驱动 - 按键设备驱动

 1 /*
 2  *    函数名     : button_device_init
 3  *    函数功能: 设备加载
 4  */
 5 
 6 static int __init button_device_init(void)
 7 {
 8     int ret = 0;
 9 
10     /* 注册平台设备 */
11     platform_device_register(&button_platform_device);
12     return ret;
13 }

1 static struct platform_device button_platform_device = 
2 {
3     .name = "button_dev",
4     .id = 0,
5     .num_resources = ARRAY_SIZE(button_resource),
6     .resource = button_resource,
7 };

 1 static struct resource button_resource[] = 
 2 {
 3     [0] = 
 4     {
 5         .start = IRQ_EINT(0),
 6         .end = IRQ_EINT(3),
 7         .flags = IORESOURCE_IRQ,
 8     },
 9     [1] = 
10     {
11         .start = (resource_size_t)S3C64XX_GPNDAT,
12         .end = (resource_size_t)S3C64XX_GPNDAT,
13         .flags = IORESOURCE_MEM,
14     },
15 };

 1 /*
 2  *    函数名     : button_driver_init
 3  *    函数功能: 驱动加载
 4  */
 5 
 6 static int __init button_driver_init(void)
 7 {
 8     int ret = 0;
 9     ret = platform_driver_register(&button_platform_driver);
10     return ret;
11 }

 1 static struct platform_driver button_platform_driver = 
 2 {
 3     .probe = button_platform_probe,
 4     .remove = button_platform_remove,
 5     .driver = 
 6     {
 7         .owner = THIS_MODULE,
 8         .name = "button_dev",
 9     },
10 };

 1 /*
 2  *    函数名     : button_platform_probe
 3  *    函数功能: 匹配驱动与设备
 4  */
 5 
 6 static int button_platform_probe(struct platform_device *button_device)
 7 {
 8     int ret = 0;
 9     int i = 0;
10     int num = 0;
11     struct resource* irq_resource;
12     
13     /* 注册混杂设备驱动 */
14     ret = misc_register(&misc);
15     if(ret)
16     {
17         printk("can‘t register miscdev\n");
18         return ret;
19     }
20 
21     /* 填充数组 */
22     irq_resource = platform_get_resource(button_device,IORESOURCE_IRQ,0);
23     for(num = 0,i = irq_resource->start;i <= irq_resource->end;i++,num++)
24     {
25         button_irq[num].irq = i;
26     }
27     mem_resource = platform_get_resource(button_device,IORESOURCE_MEM,0);
28     
29     /* 申请外部中断 */
30     for(i = 0;i < sizeof(button_irq)/sizeof(button_irq[0]);i++)
31     {
32         ret = request_irq(button_irq[i].irq,button_interrupt,IRQF_TRIGGER_FALLING,button_irq[i].name,(void*)&button_irq[i]);
33         if(ret != 0)
34         {
35             printk("request_irq failure\n");
36         }
37     }
38 
39     /* 初始化工作队列 */
40     INIT_WORK(&button_work,do_buttons);
41 
42     /* 初始化内核定时器 */
43     init_timer(&button_time);
44     button_time.expires = jiffies + HZ/10;    //100ms
45     button_time.function = button_do_time;
46     add_timer(&button_time);
47 
48     return ret;
49 }

 1 /*
 2  *    文件名     : button_device.c
 3  *    功能描述: 通过外部中断实现按键驱动程序,平台设备驱动方式
 4  *    驱动模型: platform
 5  *    设备节点: /dev/buttons6410
 6  *    MCU                : S3C6410
 7  *    端口连接: KEY0-GPN0  KEY1-GPN1  KEY2-GPN2  KEY3-GPN3
 8  */
 9 
10 #include <linux/init.h>
11 #include <linux/module.h>
12 #include <linux/fs.h>
13 #include <linux/device.h>
14 #include <linux/kernel.h>
15 #include <linux/irq.h>
16 #include <linux/platform_device.h>
17 
18 #include <mach/gpio-bank-n.h>
19 #include <mach/regs-gpio.h>
20 #include <mach/map.h>
21 #include <mach/regs-clock.h>
22 #include <plat/gpio-cfg.h>
23 
24 
25 
26 static struct resource button_resource[] = 
27 {
28     [0] = 
29     {
30         .start = IRQ_EINT(0),
31         .end = IRQ_EINT(3),
32         .flags = IORESOURCE_IRQ,
33     },
34     [1] = 
35     {
36         .start = (resource_size_t)S3C64XX_GPNDAT,
37         .end = (resource_size_t)S3C64XX_GPNDAT,
38         .flags = IORESOURCE_MEM,
39     },
40 };
41 
42 static struct platform_device button_platform_device = 
43 {
44     .name = "button_dev",
45     .id = 0,
46     .num_resources = ARRAY_SIZE(button_resource),
47     .resource = button_resource,
48 };
49 
50 /*
51  *    函数名     : button_device_init
52  *    函数功能: 设备加载
53  */
54 
55 static int __init button_device_init(void)
56 {
57     int ret = 0;
58 
59     /* 注册平台设备 */
60     platform_device_register(&button_platform_device);
61     return ret;
62 }
63 
64 /*
65  *    函数名     : button_device_exit
66  *    函数功能: 设备卸载
67  */
68 
69 static void __exit button_device_exit(void)
70 {
71     /* 注销平台设备*/
72     platform_device_unregister(&button_platform_device);
73 }
74 
75 module_init(button_device_init);
76 module_exit(button_device_exit);
77 MODULE_LICENSE("GPL");

  1 /*
  2  *    文件名     : button_driver.c
  3  *    功能描述: 通过外部中断实现按键驱动程序,平台设备驱动方式
  4  *    驱动模型: platform
  5  *    设备节点: /dev/buttons6410
  6  *    MCU                : S3C6410
  7  *    端口连接: KEY0-GPN0  KEY1-GPN1  KEY2-GPN2  KEY3-GPN3
  8  */
  9 
 10 #include <linux/module.h>
 11 #include <linux/kernel.h>
 12 #include <linux/fs.h>
 13 #include <linux/init.h>
 14 #include <linux/delay.h>
 15 #include <linux/poll.h>
 16 #include <linux/irq.h>
 17 #include <asm/irq.h>
 18 #include <asm/io.h>
 19 #include <linux/interrupt.h>
 20 #include <asm/uaccess.h>
 21 #include <mach/hardware.h>
 22 #include <linux/platform_device.h>
 23 #include <linux/cdev.h>
 24 #include <linux/miscdevice.h>
 25 
 26 #include <mach/map.h>
 27 #include <mach/regs-clock.h>
 28 #include <mach/regs-gpio.h>
 29 
 30 #include <plat/gpio-cfg.h>
 31 #include <mach/gpio-bank-n.h>
 32 #include <mach/gpio-bank-l.h>
 33 
 34 
 35 volatile int isKey_Pressed = 0;    // 按键按下标志 
 36 struct work_struct button_work;    //定义工作队列
 37 struct timer_list button_time;
 38 struct resource* mem_resource;
 39 struct button_irqs
 40 {
 41     unsigned int irq;
 42     int id;
 43     char* name;
 44 };
 45 
 46 static struct button_irqs button_irq[] = 
 47 {
 48     {0,0,"KEY0"},
 49     {0,1,"KEY1"},
 50     {0,2,"KEY2"},
 51     {0,3,"KEY3"},
 52 };
 53 
 54 /* 初始化等待队列 */
 55 DECLARE_WAIT_QUEUE_HEAD(q_buttons);
 56 
 57 static volatile int button_press[4] = {0};
 58 
 59 /*
 60  *    函数名     : do_buttons
 61  *    函数功能: 工作队列处理函数,处理按键工作
 62  */
 63 static void do_buttons(struct work_struct *work)
 64 {
 65     mod_timer(&button_time,jiffies + HZ/10);
 66 }
 67 
 68 /*
 69  *    函数名     : button_interrupt
 70  *    函数功能: 外部中断服务程序
 71  */
 72 static irqreturn_t button_interrupt(int irq, void *dev_id)
 73 {
 74     struct button_irqs *button_id = (struct button_irqs*)dev_id;
 75     switch(button_id->id)
 76     {
 77         case 0:
 78         case 1:
 79         case 2:
 80         case 3:
 81         schedule_work(&button_work);
 82         break;
 83         default: break;
 84     }
 85     return IRQ_HANDLED;
 86 }
 87 
 88 /*
 89  *    函数名     : button_do_time
 90  *    函数功能: 内核定时器服务程序
 91  */
 92 
 93 static void button_do_time(unsigned long arg)
 94 {
 95     int i = 0;
 96     unsigned short tmp = 0;
 97     tmp = readw(mem_resource->start) & 0x000F;
 98     switch(tmp)
 99     {
100         case 0x0E:
101             button_press[0] = 1;
102         break;
103         case 0x0D:
104             button_press[1] = 1;
105         break;
106         case 0x0B:
107             button_press[2] = 1;
108         break;
109         case 0x07:
110             button_press[3] = 1;
111         break;
112     }
113     for(i = 0;i < sizeof(button_press)/sizeof(button_press[0]);i++)
114     {
115         if(button_press[i] == 0)
116             continue;
117             
118         isKey_Pressed = 1;
119 
120         /* 唤醒等待队列 */
121         wake_up_interruptible(&q_buttons);
122         break;
123     }
124     
125 }
126 
127 
128 /*
129  *    函数名     : button_open
130  *    函数功能: 文件打开
131  */
132 static int button_open(struct inode *node, struct file *filp)
133 {
134     return 0;
135 }
136 
137 /*
138  *    函数名     : button_read
139  *    函数功能: 文件读
140  */
141 static ssize_t button_read(struct file *file, char __user *buffer, size_t count, loff_t *ppos)
142 {
143     ssize_t ret = 0;
144     size_t size = min(count,sizeof(button_press));
145 
146     /* 等待队列唤醒 */
147     wait_event_interruptible(q_buttons,isKey_Pressed);
148     isKey_Pressed = 0;
149     
150     if(copy_to_user((void*)buffer,(const void*)&button_press,size))
151     {
152         ret = -1;
153         printk("copy to user failure\n");
154     }
155     else
156     {
157         memset((void*)&button_press,0,sizeof(button_press));
158         ret = size;
159     }
160     return ret;
161 }
162 
163 
164 static struct file_operations fops = 
165 {
166     .owner = THIS_MODULE,
167     .open = button_open,
168     .read = button_read,
169 };
170 
171 static struct miscdevice misc = 
172 {
173     .minor = MISC_DYNAMIC_MINOR,
174     .name = "buttons6410",
175     .fops = &fops,
176 };
177 
178 /*
179  *    函数名     : button_platform_probe
180  *    函数功能: 匹配驱动与设备
181  */
182 
183 static int button_platform_probe(struct platform_device *button_device)
184 {
185     int ret = 0;
186     int i = 0;
187     int num = 0;
188     struct resource* irq_resource;
189     
190     /* 注册混杂设备驱动 */
191     ret = misc_register(&misc);
192     if(ret)
193     {
194         printk("can‘t register miscdev\n");
195         return ret;
196     }
197 
198     /* 填充数组 */
199     irq_resource = platform_get_resource(button_device,IORESOURCE_IRQ,0);
200     for(num = 0,i = irq_resource->start;i <= irq_resource->end;i++,num++)
201     {
202         button_irq[num].irq = i;
203     }
204     mem_resource = platform_get_resource(button_device,IORESOURCE_MEM,0);
205     
206     /* 申请外部中断 */
207     for(i = 0;i < sizeof(button_irq)/sizeof(button_irq[0]);i++)
208     {
209         ret = request_irq(button_irq[i].irq,button_interrupt,IRQF_TRIGGER_FALLING,button_irq[i].name,(void*)&button_irq[i]);
210         if(ret != 0)
211         {
212             printk("request_irq failure\n");
213         }
214     }
215 
216     /* 初始化工作队列 */
217     INIT_WORK(&button_work,do_buttons);
218 
219     /* 初始化内核定时器 */
220     init_timer(&button_time);
221     button_time.expires = jiffies + HZ/10;    //100ms
222     button_time.function = button_do_time;
223     add_timer(&button_time);
224 
225     return ret;
226 }
227 
228 /*
229  *    函数名     : button_platform_remove
230  *    函数功能: 删除设备
231  */
232 
233 static int button_platform_remove(struct platform_device *button_device)
234 {
235     int ret = 0;
236     int i = 0;
237 
238     /* 释放中断 */
239     for(i = 0;i < sizeof(button_irq)/sizeof(button_irq[0]);i++)
240     {
241         free_irq(button_irq[i].irq,(void*)&button_irq[i]);
242     }
243 
244     /* 释放内核定时器 */
245     del_timer(&button_time);
246 
247     /* 卸载混杂设备驱动 */
248     misc_deregister(&misc);
249 
250     return ret;
251 }
252 
253 static struct platform_driver button_platform_driver = 
254 {
255     .probe = button_platform_probe,
256     .remove = button_platform_remove,
257     .driver = 
258     {
259         .owner = THIS_MODULE,
260         .name = "button_dev",
261     },
262 };
263 
264 /*
265  *    函数名     : button_driver_init
266  *    函数功能: 驱动加载
267  */
268 
269 static int __init button_driver_init(void)
270 {
271     int ret = 0;
272     ret = platform_driver_register(&button_platform_driver);
273     return ret;
274 }
275 
276 /*
277  *    函数名     : button_driver_exit
278  *    函数功能: 驱动卸载
279  */
280 
281 static void __exit button_driver_exit(void)
282 {
283     platform_driver_unregister(&button_platform_driver);
284 }
285 
286 module_init(button_driver_init);
287 module_exit(button_driver_exit);
288 MODULE_LICENSE("GPL");