2 * Driver for keys on GPIO lines capable of generating interrupts.
4 * Copyright 2005 Phil Blundell
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License version 2 as
8 * published by the Free Software Foundation.
11 #include <linux/module.h>
13 #include <linux/init.h>
15 #include <linux/interrupt.h>
16 #include <linux/irq.h>
17 #include <linux/sched.h>
19 #include <linux/sysctl.h>
20 #include <linux/proc_fs.h>
21 #include <linux/delay.h>
22 #include <linux/platform_device.h>
23 #include <linux/input.h>
24 #include <linux/adc.h>
27 #include <mach/board.h>
30 #define EMPTY_ADVALUE 950
31 #define DRIFT_ADVALUE 70
32 #define INVALID_ADVALUE -1
33 #define EV_MENU KEY_F1
37 #define key_dbg(bdata, format, arg...) \
38 dev_printk(KERN_INFO , &bdata->input->dev , format , ## arg)
40 #define key_dbg(bdata, format, arg...)
43 struct rk29_button_data {
46 struct rk29_keys_button *button;
47 struct input_dev *input;
48 struct timer_list timer;
49 struct rk29_keys_drvdata *ddata;
52 struct rk29_keys_drvdata {
55 bool in_suspend; /* Flag to indicate if we're suspending/resuming */
56 struct input_dev *input;
57 struct adc_client *client;
58 struct timer_list timer;
59 struct rk29_button_data data[0];
62 static struct input_dev *input_dev;
63 struct rk29_keys_Arrary {
67 static ssize_t rk29key_set(struct device *dev,
68 struct device_attribute *attr, const char *buf, size_t count)
70 struct rk29_keys_platform_data *pdata = dev_get_platdata(dev);
72 char rk29keyArrary[400];
73 struct rk29_keys_Arrary Arrary[]={
75 .keyArrary = {"menu"},
78 .keyArrary = {"home"},
84 .keyArrary = {"sensor"},
87 .keyArrary = {"play"},
90 .keyArrary = {"vol+"},
93 .keyArrary = {"vol-"},
101 p = strstr(buf,Arrary[i].keyArrary);
104 dev_dbg(dev," rk29key_set p == 0 error ...............\n");
107 start = strcspn(p,":");
110 end = strcspn(p,",");
112 end = strcspn(p,"}");
114 memset(rk29keyArrary,0,sizeof(rk29keyArrary));
116 strncpy(rk29keyArrary,p+start+1,end-start-1);
120 if(strcmp(pdata->buttons[j].desc,Arrary[i].keyArrary)==0)
122 if(strcmp(rk29keyArrary,"MENU")==0)
123 pdata->buttons[j].code = EV_MENU;
124 else if(strcmp(rk29keyArrary,"HOME")==0)
125 pdata->buttons[j].code = KEY_HOME;
126 else if(strcmp(rk29keyArrary,"ESC")==0)
127 pdata->buttons[j].code = KEY_BACK;
128 else if(strcmp(rk29keyArrary,"sensor")==0)
129 pdata->buttons[j].code = KEY_CAMERA;
130 else if(strcmp(rk29keyArrary,"PLAY")==0)
131 pdata->buttons[j].code = KEY_POWER;
132 else if(strcmp(rk29keyArrary,"VOLUP")==0)
133 pdata->buttons[j].code = KEY_VOLUMEUP;
134 else if(strcmp(rk29keyArrary,"VOLDOWN")==0)
135 pdata->buttons[j].code = KEY_VOLUMEDOWN;
145 dev_dbg(dev, "desc=%s, code=%d\n",pdata->buttons[i].desc,pdata->buttons[i].code);
150 static DEVICE_ATTR(rk29key,0660, NULL, rk29key_set);
152 void rk29_send_power_key(int state)
158 input_report_key(input_dev, KEY_POWER, 1);
159 input_sync(input_dev);
163 input_report_key(input_dev, KEY_POWER, 0);
164 input_sync(input_dev);
168 void rk28_send_wakeup_key(void)
173 input_report_key(input_dev, KEY_WAKEUP, 1);
174 input_sync(input_dev);
175 input_report_key(input_dev, KEY_WAKEUP, 0);
176 input_sync(input_dev);
179 static void keys_long_press_timer(unsigned long _data)
182 struct rk29_button_data *bdata = (struct rk29_button_data *)_data;
183 struct rk29_keys_button *button = bdata->button;
184 struct input_dev *input = bdata->input;
185 unsigned int type = EV_KEY;
186 if(button->gpio != INVALID_GPIO )
187 state = !!((gpio_get_value(button->gpio) ? 1 : 0) ^ button->active_low);
189 state = !!button->adc_state;
191 if(bdata->long_press_count != 0) {
192 if(bdata->long_press_count % (LONG_PRESS_COUNT+ONE_SEC_COUNT) == 0){
193 key_dbg(bdata, "%skey[%s]: report ev[%d] state[0]\n",
194 (button->gpio == INVALID_GPIO)?"ad":"io", button->desc, button->code_long_press);
195 input_event(input, type, button->code_long_press, 0);
198 else if(bdata->long_press_count%LONG_PRESS_COUNT == 0) {
199 key_dbg(bdata, "%skey[%s]: report ev[%d] state[1]\n",
200 (button->gpio == INVALID_GPIO)?"ad":"io", button->desc, button->code_long_press);
201 input_event(input, type, button->code_long_press, 1);
205 bdata->long_press_count++;
206 mod_timer(&bdata->timer,
207 jiffies + msecs_to_jiffies(DEFAULT_DEBOUNCE_INTERVAL));
210 if(bdata->long_press_count <= LONG_PRESS_COUNT) {
211 bdata->long_press_count = 0;
212 key_dbg(bdata, "%skey[%s]: report ev[%d] state[1], report ev[%d] state[0]\n",
213 (button->gpio == INVALID_GPIO)?"ad":"io", button->desc, button->code, button->code);
214 input_event(input, type, button->code, 1);
216 input_event(input, type, button->code, 0);
219 else if(bdata->state != state) {
220 key_dbg(bdata, "%skey[%s]: report ev[%d] state[0]\n",
221 (button->gpio == INVALID_GPIO)?"ad":"io", button->desc, button->code_long_press);
222 input_event(input, type, button->code_long_press, 0);
226 bdata->state = state;
228 static void keys_timer(unsigned long _data)
231 struct rk29_button_data *bdata = (struct rk29_button_data *)_data;
232 struct rk29_keys_button *button = bdata->button;
233 struct input_dev *input = bdata->input;
234 unsigned int type = EV_KEY;
236 if(button->gpio != INVALID_GPIO)
237 state = !!((gpio_get_value(button->gpio) ? 1 : 0) ^ button->active_low);
239 state = !!button->adc_state;
240 if(bdata->state != state) {
241 bdata->state = state;
242 key_dbg(bdata, "%skey[%s]: report ev[%d] state[%d]\n",
243 (button->gpio == INVALID_GPIO)?"ad":"io", button->desc, button->code, bdata->state);
244 input_event(input, type, button->code, bdata->state);
248 mod_timer(&bdata->timer,
249 jiffies + msecs_to_jiffies(DEFAULT_DEBOUNCE_INTERVAL));
252 static irqreturn_t keys_isr(int irq, void *dev_id)
254 struct rk29_button_data *bdata = dev_id;
255 struct rk29_keys_button *button = bdata->button;
256 struct input_dev *input = bdata->input;
257 unsigned int type = EV_KEY;
258 BUG_ON(irq != gpio_to_irq(button->gpio));
260 if(button->wakeup == 1 && bdata->ddata->in_suspend == true){
262 key_dbg(bdata, "wakeup: %skey[%s]: report ev[%d] state[%d]\n",
263 (button->gpio == INVALID_GPIO)?"ad":"io", button->desc, button->code, bdata->state);
264 input_event(input, type, button->code, bdata->state);
267 bdata->long_press_count = 0;
268 mod_timer(&bdata->timer,
269 jiffies + msecs_to_jiffies(DEFAULT_DEBOUNCE_INTERVAL));
273 static void keys_adc_callback(struct adc_client *client, void *client_param, int result)
275 struct rk29_keys_drvdata *ddata = (struct rk29_keys_drvdata *)client_param;
277 if(result > INVALID_ADVALUE && result < EMPTY_ADVALUE)
278 ddata->result = result;
279 for (i = 0; i < ddata->nbuttons; i++) {
280 struct rk29_button_data *bdata = &ddata->data[i];
281 struct rk29_keys_button *button = bdata->button;
282 if(!button->adc_value)
284 if(result < button->adc_value + DRIFT_ADVALUE &&
285 result > button->adc_value - DRIFT_ADVALUE)
286 button->adc_state = 1;
288 button->adc_state = 0;
289 if(bdata->state != button->adc_state)
290 mod_timer(&bdata->timer,
291 jiffies + msecs_to_jiffies(DEFAULT_DEBOUNCE_INTERVAL));
296 static void keys_adc_timer(unsigned long _data)
298 struct rk29_keys_drvdata *ddata = (struct rk29_keys_drvdata *)_data;
300 if (!ddata->in_suspend)
301 adc_async_read(ddata->client);
302 mod_timer(&ddata->timer, jiffies + msecs_to_jiffies(ADC_SAMPLE_TIME));
305 static ssize_t adc_value_show(struct device *dev, struct device_attribute *attr, char *buf)
307 struct rk29_keys_drvdata *ddata = dev_get_drvdata(dev);
309 return sprintf(buf, "adc_value: %d\n", ddata->result);
312 static DEVICE_ATTR(get_adc_value, S_IRUGO | S_IWUSR, adc_value_show, NULL);
314 static int __devinit keys_probe(struct platform_device *pdev)
316 struct device *dev = &pdev->dev;
317 struct rk29_keys_platform_data *pdata = dev_get_platdata(dev);
318 struct rk29_keys_drvdata *ddata;
319 struct input_dev *input;
326 ddata = kzalloc(sizeof(struct rk29_keys_drvdata) +
327 pdata->nbuttons * sizeof(struct rk29_button_data),
329 input = input_allocate_device();
330 if (!ddata || !input) {
335 platform_set_drvdata(pdev, ddata);
337 input->name = pdev->name;
338 input->phys = "gpio-keys/input0";
339 input->dev.parent = dev;
341 input->id.bustype = BUS_HOST;
342 input->id.vendor = 0x0001;
343 input->id.product = 0x0001;
344 input->id.version = 0x0100;
346 /* Enable auto repeat feature of Linux input subsystem */
348 __set_bit(EV_REP, input->evbit);
349 ddata->nbuttons = pdata->nbuttons;
350 ddata->input = input;
352 for (i = 0; i < pdata->nbuttons; i++) {
353 struct rk29_keys_button *button = &pdata->buttons[i];
354 struct rk29_button_data *bdata = &ddata->data[i];
356 bdata->input = input;
357 bdata->button = button;
358 bdata->ddata = ddata;
360 if (button->code_long_press)
361 setup_timer(&bdata->timer,
362 keys_long_press_timer, (unsigned long)bdata);
363 else if (button->code)
364 setup_timer(&bdata->timer,
365 keys_timer, (unsigned long)bdata);
370 input_set_capability(input, EV_KEY, button->code);
373 if (pdata->chn >= 0) {
374 setup_timer(&ddata->timer, keys_adc_timer, (unsigned long)ddata);
375 ddata->client = adc_register(pdata->chn, keys_adc_callback, (void *)ddata);
376 if (!ddata->client) {
380 mod_timer(&ddata->timer, jiffies + msecs_to_jiffies(100));
383 for (i = 0; i < pdata->nbuttons; i++) {
384 struct rk29_keys_button *button = &pdata->buttons[i];
385 struct rk29_button_data *bdata = &ddata->data[i];
388 if(button->gpio != INVALID_GPIO) {
389 error = gpio_request(button->gpio, button->desc ?: "keys");
391 pr_err("gpio-keys: failed to request GPIO %d,"
392 " error %d\n", button->gpio, error);
396 error = gpio_direction_input(button->gpio);
398 pr_err("gpio-keys: failed to configure input"
399 " direction for GPIO %d, error %d\n",
400 button->gpio, error);
401 gpio_free(button->gpio);
405 irq = gpio_to_irq(button->gpio);
408 pr_err("gpio-keys: Unable to get irq number"
409 " for GPIO %d, error %d\n",
410 button->gpio, error);
411 gpio_free(button->gpio);
415 error = request_irq(irq, keys_isr,
416 (button->active_low)?IRQF_TRIGGER_FALLING : IRQF_TRIGGER_RISING,
417 button->desc ? button->desc : "keys",
420 pr_err("gpio-keys: Unable to claim irq %d; error %d\n",
422 gpio_free(button->gpio);
428 input_set_capability(input, EV_KEY, KEY_WAKEUP);
430 error = input_register_device(input);
432 pr_err("gpio-keys: Unable to register input device, "
433 "error: %d\n", error);
437 device_init_wakeup(dev, wakeup);
438 error = device_create_file(dev, &dev_attr_get_adc_value);
440 error = device_create_file(dev, &dev_attr_rk29key);
443 pr_err("failed to create key file error: %d\n", error);
452 free_irq(gpio_to_irq(pdata->buttons[i].gpio), &ddata->data[i]);
453 del_timer_sync(&ddata->data[i].timer);
454 gpio_free(pdata->buttons[i].gpio);
456 if(pdata->chn >= 0 && ddata->client);
457 adc_unregister(ddata->client);
459 del_timer_sync(&ddata->timer);
461 platform_set_drvdata(pdev, NULL);
463 input_free_device(input);
469 static int __devexit keys_remove(struct platform_device *pdev)
471 struct device *dev = &pdev->dev;
472 struct rk29_keys_platform_data *pdata = dev_get_platdata(dev);
473 struct rk29_keys_drvdata *ddata = dev_get_drvdata(dev);
474 struct input_dev *input = ddata->input;
478 device_init_wakeup(dev, 0);
480 for (i = 0; i < pdata->nbuttons; i++) {
481 int irq = gpio_to_irq(pdata->buttons[i].gpio);
482 free_irq(irq, &ddata->data[i]);
483 del_timer_sync(&ddata->data[i].timer);
484 gpio_free(pdata->buttons[i].gpio);
486 if(pdata->chn >= 0 && ddata->client);
487 adc_unregister(ddata->client);
488 input_unregister_device(input);
495 static int keys_suspend(struct device *dev)
497 struct rk29_keys_platform_data *pdata = dev_get_platdata(dev);
498 struct rk29_keys_drvdata *ddata = dev_get_drvdata(dev);
501 ddata->in_suspend = true;
503 if (device_may_wakeup(dev)) {
504 for (i = 0; i < pdata->nbuttons; i++) {
505 struct rk29_keys_button *button = &pdata->buttons[i];
506 if (button->wakeup) {
507 int irq = gpio_to_irq(button->gpio);
508 enable_irq_wake(irq);
516 static int keys_resume(struct device *dev)
518 struct rk29_keys_platform_data *pdata = dev_get_platdata(dev);
519 struct rk29_keys_drvdata *ddata = dev_get_drvdata(dev);
522 if (device_may_wakeup(dev)) {
523 for (i = 0; i < pdata->nbuttons; i++) {
524 struct rk29_keys_button *button = &pdata->buttons[i];
525 if (button->wakeup) {
526 int irq = gpio_to_irq(button->gpio);
527 disable_irq_wake(irq);
531 if (local_softirq_pending())
532 do_softirq(); // for call resend_irqs, which may call keys_isr
533 preempt_enable_no_resched();
536 ddata->in_suspend = false;
541 static const struct dev_pm_ops keys_pm_ops = {
542 .suspend = keys_suspend,
543 .resume = keys_resume,
547 static struct platform_driver keys_device_driver = {
549 .remove = __devexit_p(keys_remove),
551 .name = "rk29-keypad",
552 .owner = THIS_MODULE,
559 static int __init keys_init(void)
561 return platform_driver_register(&keys_device_driver);
564 static void __exit keys_exit(void)
566 platform_driver_unregister(&keys_device_driver);
569 module_init(keys_init);
570 module_exit(keys_exit);
572 MODULE_LICENSE("GPL");
573 MODULE_AUTHOR("Phil Blundell <pb@handhelds.org>");
574 MODULE_DESCRIPTION("Keyboard driver for CPU GPIOs");
575 MODULE_ALIAS("platform:gpio-keys");