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>
12 #include <linux/init.h>
14 #include <linux/interrupt.h>
15 #include <linux/irq.h>
16 #include <linux/sched.h>
18 #include <linux/sysctl.h>
19 #include <linux/proc_fs.h>
20 #include <linux/delay.h>
21 #include <linux/platform_device.h>
22 #include <linux/input.h>
23 #include <linux/adc.h>
24 #include <linux/slab.h>
26 #include <linux/iio/iio.h>
27 #include <linux/iio/machine.h>
28 #include <linux/iio/driver.h>
29 #include <linux/iio/consumer.h>
33 #include <linux/of_irq.h>
34 #include <linux/of_gpio.h>
35 #include <linux/of_platform.h>
37 #define EMPTY_ADVALUE 950
38 #define DRIFT_ADVALUE 70
39 #define INVALID_ADVALUE -1
40 #define EV_ENCALL KEY_F4
41 #define EV_MENU KEY_F1
45 #define key_dbg(bdata, format, arg...) \
46 dev_printk(KERN_INFO , &bdata->input->dev , format , ## arg)
48 #define key_dbg(bdata, format, arg...)
51 #define DEFAULT_DEBOUNCE_INTERVAL 10 //10ms
52 #define ADC_SAMPLE_TIME 100
59 struct rk_keys_button {
60 u32 type; //TYPE_GPIO, TYPE_ADC
62 char *desc;//key label
63 u32 state; //key up & down state
65 int adc_value; //adc only
66 int adc_state; //adc only
67 int active_low;//gpio only
68 int wakeup; //gpio only
69 struct timer_list timer;
72 struct rk_keys_drvdata {
74 bool in_suspend; /* Flag to indicate if we're suspending/resuming */
77 struct input_dev *input;
78 struct delayed_work adc_poll_work;
79 struct iio_channel *chan;
80 struct rk_keys_button button[0];
83 static struct input_dev *sinput_dev = NULL;
84 static struct rk_keys_drvdata *spdata = NULL;
85 static void * rk_key_get_drvdata(void)
91 void rk_send_power_key(int state)
97 input_report_key(sinput_dev, KEY_POWER, 1);
98 input_sync(sinput_dev);
102 input_report_key(sinput_dev, KEY_POWER, 0);
103 input_sync(sinput_dev);
106 EXPORT_SYMBOL(rk_send_power_key);
108 void rk_send_wakeup_key(void)
113 input_report_key(sinput_dev, KEY_WAKEUP, 1);
114 input_sync(sinput_dev);
115 input_report_key(sinput_dev, KEY_WAKEUP, 0);
116 input_sync(sinput_dev);
118 EXPORT_SYMBOL(rk_send_wakeup_key);
120 static void keys_timer(unsigned long _data)
122 struct rk_keys_drvdata *pdata = rk_key_get_drvdata();
123 struct rk_keys_button *button = (struct rk_keys_button *)_data;
124 struct input_dev *input = pdata->input;
127 if(button->type == TYPE_GPIO)
128 state = !!((gpio_get_value(button->gpio) ? 1 : 0) ^ button->active_low);
130 state = !!button->adc_state;
132 if(button->state != state) {
133 button->state = state;
134 input_event(input, EV_KEY, button->code, button->state);
135 key_dbg(pdata, "%skey[%s]: report event[%d] state[%d]\n",
136 (button->type == TYPE_ADC)?"adc":"gpio", button->desc, button->code, button->state);
137 input_event(input, EV_KEY, button->code, button->state);
142 mod_timer(&button->timer,
143 jiffies + msecs_to_jiffies(DEFAULT_DEBOUNCE_INTERVAL));
147 static irqreturn_t keys_isr(int irq, void *dev_id)
149 struct rk_keys_drvdata *pdata = rk_key_get_drvdata();
150 struct rk_keys_button *button = (struct rk_keys_button *)dev_id;
151 struct input_dev *input = pdata->input;
152 BUG_ON(irq != gpio_to_irq(button->gpio));
154 if(button->wakeup == 1 && pdata->in_suspend == true){
156 key_dbg(pdata, "wakeup: %skey[%s]: report event[%d] state[%d]\n",
157 (button->type == TYPE_ADC)?"adc":"gpio", button->desc, button->code, button->state);
158 input_event(input, EV_KEY, button->code, button->state);
161 mod_timer(&button->timer,
162 jiffies + msecs_to_jiffies(DEFAULT_DEBOUNCE_INTERVAL));
166 static ssize_t adc_value_show(struct device *dev, struct device_attribute *attr, char *buf)
168 struct rk_keys_drvdata *ddata = dev_get_drvdata(dev);
169 return sprintf(buf, "adc_value: %d\n", ddata->result);
171 static DEVICE_ATTR(get_adc_value, S_IRUGO | S_IWUSR, adc_value_show, NULL);
173 static const struct of_device_id rk_key_match[] = {
174 { .compatible = "rockchip,key", .data = NULL},
177 MODULE_DEVICE_TABLE(of, rk_key_match);
179 static int rk_key_adc_iio_read(struct rk_keys_drvdata *data)
181 struct iio_channel *channel = data->chan;
184 ret = iio_read_channel_raw(channel, &val);
186 pr_err("read channel() error: %d\n", ret);
192 static void adc_key_poll(struct work_struct *work)
194 struct rk_keys_drvdata *ddata;
197 ddata = container_of(work, struct rk_keys_drvdata, adc_poll_work.work);
198 if (!ddata->in_suspend)
200 result = rk_key_adc_iio_read(ddata);
201 if(result > INVALID_ADVALUE && result < EMPTY_ADVALUE)
202 ddata->result = result;
203 for (i = 0; i < ddata->nbuttons; i++)
205 struct rk_keys_button *button = &ddata->button[i];
206 if(!button->adc_value)
208 if(result < button->adc_value + DRIFT_ADVALUE &&
209 result > button->adc_value - DRIFT_ADVALUE)
210 button->adc_state = 1;
212 button->adc_state = 0;
213 if(button->state != button->adc_state)
214 mod_timer(&button->timer,
215 jiffies + msecs_to_jiffies(DEFAULT_DEBOUNCE_INTERVAL));
219 schedule_delayed_work(&ddata->adc_poll_work,
220 msecs_to_jiffies(ADC_SAMPLE_TIME));
223 static int rk_key_type_get(struct device_node *node, struct rk_keys_button *button)
227 if (!of_property_read_u32(node, "rockchip,adc_value", &adc_value))
229 else if(of_get_gpio(node, 0) >= 0)
235 static int rk_keys_parse_dt(struct rk_keys_drvdata *pdata,
236 struct platform_device *pdev)
238 struct device_node *node = pdev->dev.of_node;
239 struct device_node *child_node;
240 struct iio_channel *chan;
242 u32 code, adc_value, flags;;
244 chan = iio_channel_get(&pdev->dev, NULL);
249 for_each_child_of_node(node, child_node) {
250 if(of_property_read_u32(child_node, "linux,code", &code)) {
251 dev_err(&pdev->dev, "Missing linux,code property in the DT.\n");
255 pdata->button[i].code = code;
256 pdata->button[i].desc = of_get_property(child_node, "label", NULL);
257 pdata->button[i].type = rk_key_type_get(child_node, &pdata->button[i]);
258 switch(pdata->button[i].type)
261 gpio = of_get_gpio_flags(child_node, 0, &flags);
264 if (ret != -EPROBE_DEFER)
265 dev_err(&pdev->dev,"Failed to get gpio flags, error: %d\n",
270 pdata->button[i].gpio = gpio;
271 pdata->button[i].active_low = flags & OF_GPIO_ACTIVE_LOW;
272 pdata->button[i].wakeup = !!of_get_property(child_node, "gpio-key,wakeup", NULL);
276 if (of_property_read_u32(child_node, "rockchip,adc_value", &adc_value)) {
277 dev_err(&pdev->dev, "Missing rockchip,adc_value property in the DT.\n");
281 pdata->button[i].adc_value = adc_value;
285 dev_err(&pdev->dev, "Error rockchip,type property in the DT.\n");
299 static int keys_probe(struct platform_device *pdev)
301 struct device *dev = &pdev->dev;
302 struct device_node *np = pdev->dev.of_node;
303 struct rk_keys_drvdata *ddata = NULL;
304 struct input_dev *input = NULL;
306 int wakeup, key_num = 0;
308 key_num = of_get_child_count(np);
314 ddata = devm_kzalloc(dev, sizeof(struct rk_keys_drvdata) +
315 key_num * sizeof(struct rk_keys_button),
318 input = devm_input_allocate_device(dev);
319 if (!ddata || !input) {
323 platform_set_drvdata(pdev, ddata);
325 input->name = "rk29-keypad";//pdev->name;
326 input->phys = "gpio-keys/input0";
327 input->dev.parent = dev;
329 input->id.bustype = BUS_HOST;
330 input->id.vendor = 0x0001;
331 input->id.product = 0x0001;
332 input->id.version = 0x0100;
333 ddata->input = input;
336 ddata->nbuttons = key_num;
337 error = rk_keys_parse_dt(ddata, pdev);
341 /* Enable auto repeat feature of Linux input subsystem */
343 __set_bit(EV_REP, input->evbit);
345 for (i = 0; i < ddata->nbuttons; i++) {
346 struct rk_keys_button *button = &ddata->button[i];
349 setup_timer(&button->timer,
350 keys_timer, (unsigned long)button);}
355 input_set_capability(input, EV_KEY, button->code);
358 for (i = 0; i < ddata->nbuttons; i++) {
359 struct rk_keys_button *button = &ddata->button[i];
361 if(button->type == TYPE_GPIO) {
362 error = devm_gpio_request(dev, button->gpio, button->desc ?: "keys");
364 pr_err("gpio-keys: failed to request GPIO %d,"
365 " error %d\n", button->gpio, error);
369 error = gpio_direction_input(button->gpio);
371 pr_err("gpio-keys: failed to configure input"
372 " direction for GPIO %d, error %d\n",
373 button->gpio, error);
374 gpio_free(button->gpio);
378 int irq = gpio_to_irq(button->gpio);
381 pr_err("gpio-keys: Unable to get irq number"
382 " for GPIO %d, error %d\n",
383 button->gpio, error);
384 gpio_free(button->gpio);
388 error = devm_request_irq(dev, irq, keys_isr,
389 (button->active_low)?IRQF_TRIGGER_FALLING : IRQF_TRIGGER_RISING,
390 button->desc ? button->desc : "keys",
393 pr_err("gpio-keys: Unable to claim irq %d; error %d\n",
395 gpio_free(button->gpio);
401 input_set_capability(input, EV_KEY, KEY_WAKEUP);
402 device_init_wakeup(dev, wakeup);
404 error = input_register_device(input);
406 pr_err("gpio-keys: Unable to register input device, "
407 "error: %d\n", error);
412 INIT_DELAYED_WORK(&ddata->adc_poll_work, adc_key_poll);
413 schedule_delayed_work(&ddata->adc_poll_work,
414 msecs_to_jiffies(ADC_SAMPLE_TIME));
421 device_init_wakeup(dev, 0);
424 del_timer_sync(&ddata->button[i].timer);
427 platform_set_drvdata(pdev, NULL);
432 static int keys_remove(struct platform_device *pdev)
434 struct device *dev = &pdev->dev;
435 struct rk_keys_drvdata *ddata = dev_get_drvdata(dev);
436 struct input_dev *input = ddata->input;
439 device_init_wakeup(dev, 0);
440 for (i = 0; i < ddata->nbuttons; i++) {
441 del_timer_sync(&ddata->button[i].timer);
443 cancel_delayed_work_sync(&ddata->adc_poll_work);
444 input_unregister_device(input);
454 static int keys_suspend(struct device *dev)
456 struct rk_keys_drvdata *ddata = dev_get_drvdata(dev);
459 ddata->in_suspend = true;
460 if (device_may_wakeup(dev)) {
461 for (i = 0; i < ddata->nbuttons; i++) {
462 struct rk_keys_button *button = ddata->button + i;
463 if (button->wakeup) {
464 int irq = gpio_to_irq(button->gpio);
465 enable_irq_wake(irq);
473 static int keys_resume(struct device *dev)
475 struct rk_keys_drvdata *ddata = dev_get_drvdata(dev);
478 if (device_may_wakeup(dev)) {
479 for (i = 0; i < ddata->nbuttons; i++) {
480 struct rk_keys_button *button = ddata->button + i;
481 if (button->wakeup) {
482 int irq = gpio_to_irq(button->gpio);
483 disable_irq_wake(irq);
487 if (local_softirq_pending())
488 do_softirq(); // for call resend_irqs, which may call keys_isr
489 preempt_enable_no_resched();
492 ddata->in_suspend = false;
497 static const struct dev_pm_ops keys_pm_ops = {
498 .suspend = keys_suspend,
499 .resume = keys_resume,
503 static struct platform_driver keys_device_driver = {
505 .remove = keys_remove,
508 .owner = THIS_MODULE,
509 .of_match_table = rk_key_match,
516 module_platform_driver(keys_device_driver);