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>
31 #include <linux/gpio.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 const 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));
167 static ssize_t adc_value_show(struct device *dev, struct device_attribute *attr, char *buf)
169 struct rk_keys_drvdata *ddata = dev_get_drvdata(dev);
170 return sprintf(buf, "adc_value: %d\n", ddata->result);
172 static DEVICE_ATTR(get_adc_value, S_IRUGO | S_IWUSR, adc_value_show, NULL);
175 static const struct of_device_id rk_key_match[] = {
176 { .compatible = "rockchip,key", .data = NULL},
179 MODULE_DEVICE_TABLE(of, rk_key_match);
181 static int rk_key_adc_iio_read(struct rk_keys_drvdata *data)
183 struct iio_channel *channel = data->chan;
187 return INVALID_ADVALUE;
188 ret = iio_read_channel_raw(channel, &val);
190 pr_err("read channel() error: %d\n", ret);
196 static void adc_key_poll(struct work_struct *work)
198 struct rk_keys_drvdata *ddata;
201 ddata = container_of(work, struct rk_keys_drvdata, adc_poll_work.work);
202 if (!ddata->in_suspend)
204 result = rk_key_adc_iio_read(ddata);
205 if(result > INVALID_ADVALUE && result < EMPTY_ADVALUE)
206 ddata->result = result;
207 for (i = 0; i < ddata->nbuttons; i++)
209 struct rk_keys_button *button = &ddata->button[i];
210 if(!button->adc_value)
212 if(result < button->adc_value + DRIFT_ADVALUE &&
213 result > button->adc_value - DRIFT_ADVALUE)
214 button->adc_state = 1;
216 button->adc_state = 0;
217 if(button->state != button->adc_state)
218 mod_timer(&button->timer,
219 jiffies + msecs_to_jiffies(DEFAULT_DEBOUNCE_INTERVAL));
223 schedule_delayed_work(&ddata->adc_poll_work,
224 msecs_to_jiffies(ADC_SAMPLE_TIME));
227 static int rk_key_type_get(struct device_node *node, struct rk_keys_button *button)
231 if (!of_property_read_u32(node, "rockchip,adc_value", &adc_value))
233 else if(of_get_gpio(node, 0) >= 0)
239 static int rk_keys_parse_dt(struct rk_keys_drvdata *pdata,
240 struct platform_device *pdev)
242 struct device_node *node = pdev->dev.of_node;
243 struct device_node *child_node;
244 struct iio_channel *chan;
246 u32 code, adc_value, flags;;
248 chan = iio_channel_get(&pdev->dev, NULL);
250 dev_info(&pdev->dev, "no io-channels defined\n");
255 for_each_child_of_node(node, child_node) {
256 if(of_property_read_u32(child_node, "linux,code", &code)) {
257 dev_err(&pdev->dev, "Missing linux,code property in the DT.\n");
261 pdata->button[i].code = code;
262 pdata->button[i].desc = of_get_property(child_node, "label", NULL);
263 pdata->button[i].type = rk_key_type_get(child_node, &pdata->button[i]);
264 switch(pdata->button[i].type)
267 gpio = of_get_gpio_flags(child_node, 0, &flags);
270 if (ret != -EPROBE_DEFER)
271 dev_err(&pdev->dev,"Failed to get gpio flags, error: %d\n",
276 pdata->button[i].gpio = gpio;
277 pdata->button[i].active_low = flags & OF_GPIO_ACTIVE_LOW;
278 pdata->button[i].wakeup = !!of_get_property(child_node, "gpio-key,wakeup", NULL);
282 if (of_property_read_u32(child_node, "rockchip,adc_value", &adc_value)) {
283 dev_err(&pdev->dev, "Missing rockchip,adc_value property in the DT.\n");
287 pdata->button[i].adc_value = adc_value;
291 dev_err(&pdev->dev, "Error rockchip,type property in the DT.\n");
305 static int keys_probe(struct platform_device *pdev)
307 struct device *dev = &pdev->dev;
308 struct device_node *np = pdev->dev.of_node;
309 struct rk_keys_drvdata *ddata = NULL;
310 struct input_dev *input = NULL;
312 int wakeup, key_num = 0;
314 key_num = of_get_child_count(np);
316 dev_info(&pdev->dev, "no key defined\n");
318 ddata = devm_kzalloc(dev, sizeof(struct rk_keys_drvdata) +
319 key_num * sizeof(struct rk_keys_button),
322 input = devm_input_allocate_device(dev);
323 if (!ddata || !input) {
327 platform_set_drvdata(pdev, ddata);
329 input->name = "rk29-keypad";//pdev->name;
330 input->phys = "gpio-keys/input0";
331 input->dev.parent = dev;
333 input->id.bustype = BUS_HOST;
334 input->id.vendor = 0x0001;
335 input->id.product = 0x0001;
336 input->id.version = 0x0100;
337 ddata->input = input;
340 ddata->nbuttons = key_num;
341 error = rk_keys_parse_dt(ddata, pdev);
345 /* Enable auto repeat feature of Linux input subsystem */
347 __set_bit(EV_REP, input->evbit);
349 for (i = 0; i < ddata->nbuttons; i++) {
350 struct rk_keys_button *button = &ddata->button[i];
353 setup_timer(&button->timer,
354 keys_timer, (unsigned long)button);}
359 input_set_capability(input, EV_KEY, button->code);
362 for (i = 0; i < ddata->nbuttons; i++) {
363 struct rk_keys_button *button = &ddata->button[i];
365 if(button->type == TYPE_GPIO) {
368 error = devm_gpio_request(dev, button->gpio, button->desc ?: "keys");
370 pr_err("gpio-keys: failed to request GPIO %d,"
371 " error %d\n", button->gpio, error);
375 error = gpio_direction_input(button->gpio);
377 pr_err("gpio-keys: failed to configure input"
378 " direction for GPIO %d, error %d\n",
379 button->gpio, error);
380 gpio_free(button->gpio);
384 irq = gpio_to_irq(button->gpio);
387 pr_err("gpio-keys: Unable to get irq number"
388 " for GPIO %d, error %d\n",
389 button->gpio, error);
390 gpio_free(button->gpio);
394 error = devm_request_irq(dev, irq, keys_isr,
395 (button->active_low)?IRQF_TRIGGER_FALLING : IRQF_TRIGGER_RISING,
396 button->desc ? button->desc : "keys",
399 pr_err("gpio-keys: Unable to claim irq %d; error %d\n",
401 gpio_free(button->gpio);
407 input_set_capability(input, EV_KEY, KEY_WAKEUP);
408 device_init_wakeup(dev, wakeup);
410 error = input_register_device(input);
412 pr_err("gpio-keys: Unable to register input device, "
413 "error: %d\n", error);
419 INIT_DELAYED_WORK(&ddata->adc_poll_work, adc_key_poll);
420 schedule_delayed_work(&ddata->adc_poll_work,
421 msecs_to_jiffies(ADC_SAMPLE_TIME));
429 device_init_wakeup(dev, 0);
432 del_timer_sync(&ddata->button[i].timer);
435 platform_set_drvdata(pdev, NULL);
440 static int keys_remove(struct platform_device *pdev)
442 struct device *dev = &pdev->dev;
443 struct rk_keys_drvdata *ddata = dev_get_drvdata(dev);
444 struct input_dev *input = ddata->input;
447 device_init_wakeup(dev, 0);
448 for (i = 0; i < ddata->nbuttons; i++) {
449 del_timer_sync(&ddata->button[i].timer);
452 cancel_delayed_work_sync(&ddata->adc_poll_work);
453 input_unregister_device(input);
463 static int keys_suspend(struct device *dev)
465 struct rk_keys_drvdata *ddata = dev_get_drvdata(dev);
468 ddata->in_suspend = true;
469 if (device_may_wakeup(dev)) {
470 for (i = 0; i < ddata->nbuttons; i++) {
471 struct rk_keys_button *button = ddata->button + i;
472 if (button->wakeup) {
473 int irq = gpio_to_irq(button->gpio);
474 enable_irq_wake(irq);
482 static int keys_resume(struct device *dev)
484 struct rk_keys_drvdata *ddata = dev_get_drvdata(dev);
487 if (device_may_wakeup(dev)) {
488 for (i = 0; i < ddata->nbuttons; i++) {
489 struct rk_keys_button *button = ddata->button + i;
490 if (button->wakeup) {
491 int irq = gpio_to_irq(button->gpio);
492 disable_irq_wake(irq);
496 if (local_softirq_pending())
497 do_softirq(); // for call resend_irqs, which may call keys_isr
498 preempt_enable_no_resched();
501 ddata->in_suspend = false;
506 static const struct dev_pm_ops keys_pm_ops = {
507 .suspend = keys_suspend,
508 .resume = keys_resume,
512 static struct platform_driver keys_device_driver = {
514 .remove = keys_remove,
517 .owner = THIS_MODULE,
518 .of_match_table = rk_key_match,
525 module_platform_driver(keys_device_driver);