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 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;
186 ret = iio_read_channel_raw(channel, &val);
188 pr_err("read channel() error: %d\n", ret);
194 static void adc_key_poll(struct work_struct *work)
196 struct rk_keys_drvdata *ddata;
199 ddata = container_of(work, struct rk_keys_drvdata, adc_poll_work.work);
200 if (!ddata->in_suspend)
202 result = rk_key_adc_iio_read(ddata);
203 if(result > INVALID_ADVALUE && result < EMPTY_ADVALUE)
204 ddata->result = result;
205 for (i = 0; i < ddata->nbuttons; i++)
207 struct rk_keys_button *button = &ddata->button[i];
208 if(!button->adc_value)
210 if(result < button->adc_value + DRIFT_ADVALUE &&
211 result > button->adc_value - DRIFT_ADVALUE)
212 button->adc_state = 1;
214 button->adc_state = 0;
215 if(button->state != button->adc_state)
216 mod_timer(&button->timer,
217 jiffies + msecs_to_jiffies(DEFAULT_DEBOUNCE_INTERVAL));
221 schedule_delayed_work(&ddata->adc_poll_work,
222 msecs_to_jiffies(ADC_SAMPLE_TIME));
225 static int rk_key_type_get(struct device_node *node, struct rk_keys_button *button)
229 if (!of_property_read_u32(node, "rockchip,adc_value", &adc_value))
231 else if(of_get_gpio(node, 0) >= 0)
237 static int rk_keys_parse_dt(struct rk_keys_drvdata *pdata,
238 struct platform_device *pdev)
240 struct device_node *node = pdev->dev.of_node;
241 struct device_node *child_node;
242 struct iio_channel *chan;
244 u32 code, adc_value, flags;;
246 chan = iio_channel_get(&pdev->dev, NULL);
251 for_each_child_of_node(node, child_node) {
252 if(of_property_read_u32(child_node, "linux,code", &code)) {
253 dev_err(&pdev->dev, "Missing linux,code property in the DT.\n");
257 pdata->button[i].code = code;
258 pdata->button[i].desc = of_get_property(child_node, "label", NULL);
259 pdata->button[i].type = rk_key_type_get(child_node, &pdata->button[i]);
260 switch(pdata->button[i].type)
263 gpio = of_get_gpio_flags(child_node, 0, &flags);
266 if (ret != -EPROBE_DEFER)
267 dev_err(&pdev->dev,"Failed to get gpio flags, error: %d\n",
272 pdata->button[i].gpio = gpio;
273 pdata->button[i].active_low = flags & OF_GPIO_ACTIVE_LOW;
274 pdata->button[i].wakeup = !!of_get_property(child_node, "gpio-key,wakeup", NULL);
278 if (of_property_read_u32(child_node, "rockchip,adc_value", &adc_value)) {
279 dev_err(&pdev->dev, "Missing rockchip,adc_value property in the DT.\n");
283 pdata->button[i].adc_value = adc_value;
287 dev_err(&pdev->dev, "Error rockchip,type property in the DT.\n");
301 static int keys_probe(struct platform_device *pdev)
303 struct device *dev = &pdev->dev;
304 struct device_node *np = pdev->dev.of_node;
305 struct rk_keys_drvdata *ddata = NULL;
306 struct input_dev *input = NULL;
308 int wakeup, key_num = 0;
310 key_num = of_get_child_count(np);
316 ddata = devm_kzalloc(dev, sizeof(struct rk_keys_drvdata) +
317 key_num * sizeof(struct rk_keys_button),
320 input = devm_input_allocate_device(dev);
321 if (!ddata || !input) {
325 platform_set_drvdata(pdev, ddata);
327 input->name = "rk29-keypad";//pdev->name;
328 input->phys = "gpio-keys/input0";
329 input->dev.parent = dev;
331 input->id.bustype = BUS_HOST;
332 input->id.vendor = 0x0001;
333 input->id.product = 0x0001;
334 input->id.version = 0x0100;
335 ddata->input = input;
338 ddata->nbuttons = key_num;
339 error = rk_keys_parse_dt(ddata, pdev);
343 /* Enable auto repeat feature of Linux input subsystem */
345 __set_bit(EV_REP, input->evbit);
347 for (i = 0; i < ddata->nbuttons; i++) {
348 struct rk_keys_button *button = &ddata->button[i];
351 setup_timer(&button->timer,
352 keys_timer, (unsigned long)button);}
357 input_set_capability(input, EV_KEY, button->code);
360 for (i = 0; i < ddata->nbuttons; i++) {
361 struct rk_keys_button *button = &ddata->button[i];
363 if(button->type == TYPE_GPIO) {
366 error = devm_gpio_request(dev, button->gpio, button->desc ?: "keys");
368 pr_err("gpio-keys: failed to request GPIO %d,"
369 " error %d\n", button->gpio, error);
373 error = gpio_direction_input(button->gpio);
375 pr_err("gpio-keys: failed to configure input"
376 " direction for GPIO %d, error %d\n",
377 button->gpio, error);
378 gpio_free(button->gpio);
382 irq = gpio_to_irq(button->gpio);
385 pr_err("gpio-keys: Unable to get irq number"
386 " for GPIO %d, error %d\n",
387 button->gpio, error);
388 gpio_free(button->gpio);
392 error = devm_request_irq(dev, irq, keys_isr,
393 (button->active_low)?IRQF_TRIGGER_FALLING : IRQF_TRIGGER_RISING,
394 button->desc ? button->desc : "keys",
397 pr_err("gpio-keys: Unable to claim irq %d; error %d\n",
399 gpio_free(button->gpio);
405 input_set_capability(input, EV_KEY, KEY_WAKEUP);
406 device_init_wakeup(dev, wakeup);
408 error = input_register_device(input);
410 pr_err("gpio-keys: Unable to register input device, "
411 "error: %d\n", error);
416 INIT_DELAYED_WORK(&ddata->adc_poll_work, adc_key_poll);
417 schedule_delayed_work(&ddata->adc_poll_work,
418 msecs_to_jiffies(ADC_SAMPLE_TIME));
425 device_init_wakeup(dev, 0);
428 del_timer_sync(&ddata->button[i].timer);
431 platform_set_drvdata(pdev, NULL);
436 static int keys_remove(struct platform_device *pdev)
438 struct device *dev = &pdev->dev;
439 struct rk_keys_drvdata *ddata = dev_get_drvdata(dev);
440 struct input_dev *input = ddata->input;
443 device_init_wakeup(dev, 0);
444 for (i = 0; i < ddata->nbuttons; i++) {
445 del_timer_sync(&ddata->button[i].timer);
447 cancel_delayed_work_sync(&ddata->adc_poll_work);
448 input_unregister_device(input);
458 static int keys_suspend(struct device *dev)
460 struct rk_keys_drvdata *ddata = dev_get_drvdata(dev);
463 ddata->in_suspend = true;
464 if (device_may_wakeup(dev)) {
465 for (i = 0; i < ddata->nbuttons; i++) {
466 struct rk_keys_button *button = ddata->button + i;
467 if (button->wakeup) {
468 int irq = gpio_to_irq(button->gpio);
469 enable_irq_wake(irq);
477 static int keys_resume(struct device *dev)
479 struct rk_keys_drvdata *ddata = dev_get_drvdata(dev);
482 if (device_may_wakeup(dev)) {
483 for (i = 0; i < ddata->nbuttons; i++) {
484 struct rk_keys_button *button = ddata->button + i;
485 if (button->wakeup) {
486 int irq = gpio_to_irq(button->gpio);
487 disable_irq_wake(irq);
491 if (local_softirq_pending())
492 do_softirq(); // for call resend_irqs, which may call keys_isr
493 preempt_enable_no_resched();
496 ddata->in_suspend = false;
501 static const struct dev_pm_ops keys_pm_ops = {
502 .suspend = keys_suspend,
503 .resume = keys_resume,
507 static struct platform_driver keys_device_driver = {
509 .remove = keys_remove,
512 .owner = THIS_MODULE,
513 .of_match_table = rk_key_match,
520 module_platform_driver(keys_device_driver);