8c98e97f8e41144a08c53e4c5ee1eefca9ebfb0f
[sfrench/cifs-2.6.git] / drivers / input / keyboard / gpio_keys.c
1 /*
2  * Driver for keys on GPIO lines capable of generating interrupts.
3  *
4  * Copyright 2005 Phil Blundell
5  * Copyright 2010, 2011 David Jander <david@protonic.nl>
6  *
7  * This program is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License version 2 as
9  * published by the Free Software Foundation.
10  */
11
12 #include <linux/module.h>
13
14 #include <linux/init.h>
15 #include <linux/fs.h>
16 #include <linux/interrupt.h>
17 #include <linux/irq.h>
18 #include <linux/sched.h>
19 #include <linux/pm.h>
20 #include <linux/slab.h>
21 #include <linux/sysctl.h>
22 #include <linux/proc_fs.h>
23 #include <linux/delay.h>
24 #include <linux/platform_device.h>
25 #include <linux/input.h>
26 #include <linux/gpio_keys.h>
27 #include <linux/workqueue.h>
28 #include <linux/gpio.h>
29 #include <linux/of.h>
30 #include <linux/of_platform.h>
31 #include <linux/of_gpio.h>
32 #include <linux/spinlock.h>
33
34 struct gpio_button_data {
35         const struct gpio_keys_button *button;
36         struct input_dev *input;
37         struct timer_list timer;
38         struct work_struct work;
39         unsigned int timer_debounce;    /* in msecs */
40         unsigned int irq;
41         spinlock_t lock;
42         bool disabled;
43         bool key_pressed;
44 };
45
46 struct gpio_keys_drvdata {
47         const struct gpio_keys_platform_data *pdata;
48         struct input_dev *input;
49         struct mutex disable_lock;
50         struct gpio_button_data data[0];
51 };
52
53 /*
54  * SYSFS interface for enabling/disabling keys and switches:
55  *
56  * There are 4 attributes under /sys/devices/platform/gpio-keys/
57  *      keys [ro]              - bitmap of keys (EV_KEY) which can be
58  *                               disabled
59  *      switches [ro]          - bitmap of switches (EV_SW) which can be
60  *                               disabled
61  *      disabled_keys [rw]     - bitmap of keys currently disabled
62  *      disabled_switches [rw] - bitmap of switches currently disabled
63  *
64  * Userland can change these values and hence disable event generation
65  * for each key (or switch). Disabling a key means its interrupt line
66  * is disabled.
67  *
68  * For example, if we have following switches set up as gpio-keys:
69  *      SW_DOCK = 5
70  *      SW_CAMERA_LENS_COVER = 9
71  *      SW_KEYPAD_SLIDE = 10
72  *      SW_FRONT_PROXIMITY = 11
73  * This is read from switches:
74  *      11-9,5
75  * Next we want to disable proximity (11) and dock (5), we write:
76  *      11,5
77  * to file disabled_switches. Now proximity and dock IRQs are disabled.
78  * This can be verified by reading the file disabled_switches:
79  *      11,5
80  * If we now want to enable proximity (11) switch we write:
81  *      5
82  * to disabled_switches.
83  *
84  * We can disable only those keys which don't allow sharing the irq.
85  */
86
87 /**
88  * get_n_events_by_type() - returns maximum number of events per @type
89  * @type: type of button (%EV_KEY, %EV_SW)
90  *
91  * Return value of this function can be used to allocate bitmap
92  * large enough to hold all bits for given type.
93  */
94 static inline int get_n_events_by_type(int type)
95 {
96         BUG_ON(type != EV_SW && type != EV_KEY);
97
98         return (type == EV_KEY) ? KEY_CNT : SW_CNT;
99 }
100
101 /**
102  * gpio_keys_disable_button() - disables given GPIO button
103  * @bdata: button data for button to be disabled
104  *
105  * Disables button pointed by @bdata. This is done by masking
106  * IRQ line. After this function is called, button won't generate
107  * input events anymore. Note that one can only disable buttons
108  * that don't share IRQs.
109  *
110  * Make sure that @bdata->disable_lock is locked when entering
111  * this function to avoid races when concurrent threads are
112  * disabling buttons at the same time.
113  */
114 static void gpio_keys_disable_button(struct gpio_button_data *bdata)
115 {
116         if (!bdata->disabled) {
117                 /*
118                  * Disable IRQ and possible debouncing timer.
119                  */
120                 disable_irq(bdata->irq);
121                 if (bdata->timer_debounce)
122                         del_timer_sync(&bdata->timer);
123
124                 bdata->disabled = true;
125         }
126 }
127
128 /**
129  * gpio_keys_enable_button() - enables given GPIO button
130  * @bdata: button data for button to be disabled
131  *
132  * Enables given button pointed by @bdata.
133  *
134  * Make sure that @bdata->disable_lock is locked when entering
135  * this function to avoid races with concurrent threads trying
136  * to enable the same button at the same time.
137  */
138 static void gpio_keys_enable_button(struct gpio_button_data *bdata)
139 {
140         if (bdata->disabled) {
141                 enable_irq(bdata->irq);
142                 bdata->disabled = false;
143         }
144 }
145
146 /**
147  * gpio_keys_attr_show_helper() - fill in stringified bitmap of buttons
148  * @ddata: pointer to drvdata
149  * @buf: buffer where stringified bitmap is written
150  * @type: button type (%EV_KEY, %EV_SW)
151  * @only_disabled: does caller want only those buttons that are
152  *                 currently disabled or all buttons that can be
153  *                 disabled
154  *
155  * This function writes buttons that can be disabled to @buf. If
156  * @only_disabled is true, then @buf contains only those buttons
157  * that are currently disabled. Returns 0 on success or negative
158  * errno on failure.
159  */
160 static ssize_t gpio_keys_attr_show_helper(struct gpio_keys_drvdata *ddata,
161                                           char *buf, unsigned int type,
162                                           bool only_disabled)
163 {
164         int n_events = get_n_events_by_type(type);
165         unsigned long *bits;
166         ssize_t ret;
167         int i;
168
169         bits = kcalloc(BITS_TO_LONGS(n_events), sizeof(*bits), GFP_KERNEL);
170         if (!bits)
171                 return -ENOMEM;
172
173         for (i = 0; i < ddata->pdata->nbuttons; i++) {
174                 struct gpio_button_data *bdata = &ddata->data[i];
175
176                 if (bdata->button->type != type)
177                         continue;
178
179                 if (only_disabled && !bdata->disabled)
180                         continue;
181
182                 __set_bit(bdata->button->code, bits);
183         }
184
185         ret = bitmap_scnlistprintf(buf, PAGE_SIZE - 2, bits, n_events);
186         buf[ret++] = '\n';
187         buf[ret] = '\0';
188
189         kfree(bits);
190
191         return ret;
192 }
193
194 /**
195  * gpio_keys_attr_store_helper() - enable/disable buttons based on given bitmap
196  * @ddata: pointer to drvdata
197  * @buf: buffer from userspace that contains stringified bitmap
198  * @type: button type (%EV_KEY, %EV_SW)
199  *
200  * This function parses stringified bitmap from @buf and disables/enables
201  * GPIO buttons accordingly. Returns 0 on success and negative error
202  * on failure.
203  */
204 static ssize_t gpio_keys_attr_store_helper(struct gpio_keys_drvdata *ddata,
205                                            const char *buf, unsigned int type)
206 {
207         int n_events = get_n_events_by_type(type);
208         unsigned long *bits;
209         ssize_t error;
210         int i;
211
212         bits = kcalloc(BITS_TO_LONGS(n_events), sizeof(*bits), GFP_KERNEL);
213         if (!bits)
214                 return -ENOMEM;
215
216         error = bitmap_parselist(buf, bits, n_events);
217         if (error)
218                 goto out;
219
220         /* First validate */
221         for (i = 0; i < ddata->pdata->nbuttons; i++) {
222                 struct gpio_button_data *bdata = &ddata->data[i];
223
224                 if (bdata->button->type != type)
225                         continue;
226
227                 if (test_bit(bdata->button->code, bits) &&
228                     !bdata->button->can_disable) {
229                         error = -EINVAL;
230                         goto out;
231                 }
232         }
233
234         mutex_lock(&ddata->disable_lock);
235
236         for (i = 0; i < ddata->pdata->nbuttons; i++) {
237                 struct gpio_button_data *bdata = &ddata->data[i];
238
239                 if (bdata->button->type != type)
240                         continue;
241
242                 if (test_bit(bdata->button->code, bits))
243                         gpio_keys_disable_button(bdata);
244                 else
245                         gpio_keys_enable_button(bdata);
246         }
247
248         mutex_unlock(&ddata->disable_lock);
249
250 out:
251         kfree(bits);
252         return error;
253 }
254
255 #define ATTR_SHOW_FN(name, type, only_disabled)                         \
256 static ssize_t gpio_keys_show_##name(struct device *dev,                \
257                                      struct device_attribute *attr,     \
258                                      char *buf)                         \
259 {                                                                       \
260         struct platform_device *pdev = to_platform_device(dev);         \
261         struct gpio_keys_drvdata *ddata = platform_get_drvdata(pdev);   \
262                                                                         \
263         return gpio_keys_attr_show_helper(ddata, buf,                   \
264                                           type, only_disabled);         \
265 }
266
267 ATTR_SHOW_FN(keys, EV_KEY, false);
268 ATTR_SHOW_FN(switches, EV_SW, false);
269 ATTR_SHOW_FN(disabled_keys, EV_KEY, true);
270 ATTR_SHOW_FN(disabled_switches, EV_SW, true);
271
272 /*
273  * ATTRIBUTES:
274  *
275  * /sys/devices/platform/gpio-keys/keys [ro]
276  * /sys/devices/platform/gpio-keys/switches [ro]
277  */
278 static DEVICE_ATTR(keys, S_IRUGO, gpio_keys_show_keys, NULL);
279 static DEVICE_ATTR(switches, S_IRUGO, gpio_keys_show_switches, NULL);
280
281 #define ATTR_STORE_FN(name, type)                                       \
282 static ssize_t gpio_keys_store_##name(struct device *dev,               \
283                                       struct device_attribute *attr,    \
284                                       const char *buf,                  \
285                                       size_t count)                     \
286 {                                                                       \
287         struct platform_device *pdev = to_platform_device(dev);         \
288         struct gpio_keys_drvdata *ddata = platform_get_drvdata(pdev);   \
289         ssize_t error;                                                  \
290                                                                         \
291         error = gpio_keys_attr_store_helper(ddata, buf, type);          \
292         if (error)                                                      \
293                 return error;                                           \
294                                                                         \
295         return count;                                                   \
296 }
297
298 ATTR_STORE_FN(disabled_keys, EV_KEY);
299 ATTR_STORE_FN(disabled_switches, EV_SW);
300
301 /*
302  * ATTRIBUTES:
303  *
304  * /sys/devices/platform/gpio-keys/disabled_keys [rw]
305  * /sys/devices/platform/gpio-keys/disables_switches [rw]
306  */
307 static DEVICE_ATTR(disabled_keys, S_IWUSR | S_IRUGO,
308                    gpio_keys_show_disabled_keys,
309                    gpio_keys_store_disabled_keys);
310 static DEVICE_ATTR(disabled_switches, S_IWUSR | S_IRUGO,
311                    gpio_keys_show_disabled_switches,
312                    gpio_keys_store_disabled_switches);
313
314 static struct attribute *gpio_keys_attrs[] = {
315         &dev_attr_keys.attr,
316         &dev_attr_switches.attr,
317         &dev_attr_disabled_keys.attr,
318         &dev_attr_disabled_switches.attr,
319         NULL,
320 };
321
322 static struct attribute_group gpio_keys_attr_group = {
323         .attrs = gpio_keys_attrs,
324 };
325
326 static void gpio_keys_gpio_report_event(struct gpio_button_data *bdata)
327 {
328         const struct gpio_keys_button *button = bdata->button;
329         struct input_dev *input = bdata->input;
330         unsigned int type = button->type ?: EV_KEY;
331         int state = (gpio_get_value_cansleep(button->gpio) ? 1 : 0) ^ button->active_low;
332
333         if (type == EV_ABS) {
334                 if (state)
335                         input_event(input, type, button->code, button->value);
336         } else {
337                 input_event(input, type, button->code, !!state);
338         }
339         input_sync(input);
340 }
341
342 static void gpio_keys_gpio_work_func(struct work_struct *work)
343 {
344         struct gpio_button_data *bdata =
345                 container_of(work, struct gpio_button_data, work);
346
347         gpio_keys_gpio_report_event(bdata);
348
349         if (bdata->button->wakeup)
350                 pm_relax(bdata->input->dev.parent);
351 }
352
353 static void gpio_keys_gpio_timer(unsigned long _data)
354 {
355         struct gpio_button_data *bdata = (struct gpio_button_data *)_data;
356
357         schedule_work(&bdata->work);
358 }
359
360 static irqreturn_t gpio_keys_gpio_isr(int irq, void *dev_id)
361 {
362         struct gpio_button_data *bdata = dev_id;
363
364         BUG_ON(irq != bdata->irq);
365
366         if (bdata->button->wakeup)
367                 pm_stay_awake(bdata->input->dev.parent);
368         if (bdata->timer_debounce)
369                 mod_timer(&bdata->timer,
370                         jiffies + msecs_to_jiffies(bdata->timer_debounce));
371         else
372                 schedule_work(&bdata->work);
373
374         return IRQ_HANDLED;
375 }
376
377 static void gpio_keys_irq_timer(unsigned long _data)
378 {
379         struct gpio_button_data *bdata = (struct gpio_button_data *)_data;
380         struct input_dev *input = bdata->input;
381         unsigned long flags;
382
383         spin_lock_irqsave(&bdata->lock, flags);
384         if (bdata->key_pressed) {
385                 input_event(input, EV_KEY, bdata->button->code, 0);
386                 input_sync(input);
387                 bdata->key_pressed = false;
388         }
389         spin_unlock_irqrestore(&bdata->lock, flags);
390 }
391
392 static irqreturn_t gpio_keys_irq_isr(int irq, void *dev_id)
393 {
394         struct gpio_button_data *bdata = dev_id;
395         const struct gpio_keys_button *button = bdata->button;
396         struct input_dev *input = bdata->input;
397         unsigned long flags;
398
399         BUG_ON(irq != bdata->irq);
400
401         spin_lock_irqsave(&bdata->lock, flags);
402
403         if (!bdata->key_pressed) {
404                 if (bdata->button->wakeup)
405                         pm_wakeup_event(bdata->input->dev.parent, 0);
406
407                 input_event(input, EV_KEY, button->code, 1);
408                 input_sync(input);
409
410                 if (!bdata->timer_debounce) {
411                         input_event(input, EV_KEY, button->code, 0);
412                         input_sync(input);
413                         goto out;
414                 }
415
416                 bdata->key_pressed = true;
417         }
418
419         if (bdata->timer_debounce)
420                 mod_timer(&bdata->timer,
421                         jiffies + msecs_to_jiffies(bdata->timer_debounce));
422 out:
423         spin_unlock_irqrestore(&bdata->lock, flags);
424         return IRQ_HANDLED;
425 }
426
427 static void gpio_keys_quiesce_key(void *data)
428 {
429         struct gpio_button_data *bdata = data;
430
431         if (bdata->timer_debounce)
432                 del_timer_sync(&bdata->timer);
433
434         cancel_work_sync(&bdata->work);
435 }
436
437 static int gpio_keys_setup_key(struct platform_device *pdev,
438                                 struct input_dev *input,
439                                 struct gpio_button_data *bdata,
440                                 const struct gpio_keys_button *button)
441 {
442         const char *desc = button->desc ? button->desc : "gpio_keys";
443         struct device *dev = &pdev->dev;
444         irq_handler_t isr;
445         unsigned long irqflags;
446         int irq;
447         int error;
448
449         bdata->input = input;
450         bdata->button = button;
451         spin_lock_init(&bdata->lock);
452
453         if (gpio_is_valid(button->gpio)) {
454
455                 error = devm_gpio_request_one(&pdev->dev, button->gpio,
456                                               GPIOF_IN, desc);
457                 if (error < 0) {
458                         dev_err(dev, "Failed to request GPIO %d, error %d\n",
459                                 button->gpio, error);
460                         return error;
461                 }
462
463                 if (button->debounce_interval) {
464                         error = gpio_set_debounce(button->gpio,
465                                         button->debounce_interval * 1000);
466                         /* use timer if gpiolib doesn't provide debounce */
467                         if (error < 0)
468                                 bdata->timer_debounce =
469                                                 button->debounce_interval;
470                 }
471
472                 irq = gpio_to_irq(button->gpio);
473                 if (irq < 0) {
474                         error = irq;
475                         dev_err(dev,
476                                 "Unable to get irq number for GPIO %d, error %d\n",
477                                 button->gpio, error);
478                         return error;
479                 }
480                 bdata->irq = irq;
481
482                 INIT_WORK(&bdata->work, gpio_keys_gpio_work_func);
483                 setup_timer(&bdata->timer,
484                             gpio_keys_gpio_timer, (unsigned long)bdata);
485
486                 isr = gpio_keys_gpio_isr;
487                 irqflags = IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING;
488
489         } else {
490                 if (!button->irq) {
491                         dev_err(dev, "No IRQ specified\n");
492                         return -EINVAL;
493                 }
494                 bdata->irq = button->irq;
495
496                 if (button->type && button->type != EV_KEY) {
497                         dev_err(dev, "Only EV_KEY allowed for IRQ buttons.\n");
498                         return -EINVAL;
499                 }
500
501                 bdata->timer_debounce = button->debounce_interval;
502                 setup_timer(&bdata->timer,
503                             gpio_keys_irq_timer, (unsigned long)bdata);
504
505                 isr = gpio_keys_irq_isr;
506                 irqflags = 0;
507         }
508
509         input_set_capability(input, button->type ?: EV_KEY, button->code);
510
511         /*
512          * Install custom action to cancel debounce timer and
513          * workqueue item.
514          */
515         error = devm_add_action(&pdev->dev, gpio_keys_quiesce_key, bdata);
516         if (error) {
517                 dev_err(&pdev->dev,
518                         "failed to register quiesce action, error: %d\n",
519                         error);
520                 return error;
521         }
522
523         /*
524          * If platform has specified that the button can be disabled,
525          * we don't want it to share the interrupt line.
526          */
527         if (!button->can_disable)
528                 irqflags |= IRQF_SHARED;
529
530         error = devm_request_any_context_irq(&pdev->dev, bdata->irq,
531                                              isr, irqflags, desc, bdata);
532         if (error < 0) {
533                 dev_err(dev, "Unable to claim irq %d; error %d\n",
534                         bdata->irq, error);
535                 return error;
536         }
537
538         return 0;
539 }
540
541 static void gpio_keys_report_state(struct gpio_keys_drvdata *ddata)
542 {
543         struct input_dev *input = ddata->input;
544         int i;
545
546         for (i = 0; i < ddata->pdata->nbuttons; i++) {
547                 struct gpio_button_data *bdata = &ddata->data[i];
548                 if (gpio_is_valid(bdata->button->gpio))
549                         gpio_keys_gpio_report_event(bdata);
550         }
551         input_sync(input);
552 }
553
554 static int gpio_keys_open(struct input_dev *input)
555 {
556         struct gpio_keys_drvdata *ddata = input_get_drvdata(input);
557         const struct gpio_keys_platform_data *pdata = ddata->pdata;
558         int error;
559
560         if (pdata->enable) {
561                 error = pdata->enable(input->dev.parent);
562                 if (error)
563                         return error;
564         }
565
566         /* Report current state of buttons that are connected to GPIOs */
567         gpio_keys_report_state(ddata);
568
569         return 0;
570 }
571
572 static void gpio_keys_close(struct input_dev *input)
573 {
574         struct gpio_keys_drvdata *ddata = input_get_drvdata(input);
575         const struct gpio_keys_platform_data *pdata = ddata->pdata;
576
577         if (pdata->disable)
578                 pdata->disable(input->dev.parent);
579 }
580
581 /*
582  * Handlers for alternative sources of platform_data
583  */
584
585 #ifdef CONFIG_OF
586 /*
587  * Translate OpenFirmware node properties into platform_data
588  */
589 static struct gpio_keys_platform_data *
590 gpio_keys_get_devtree_pdata(struct device *dev)
591 {
592         struct device_node *node, *pp;
593         struct gpio_keys_platform_data *pdata;
594         struct gpio_keys_button *button;
595         int error;
596         int nbuttons;
597         int i;
598
599         node = dev->of_node;
600         if (!node)
601                 return ERR_PTR(-ENODEV);
602
603         nbuttons = of_get_child_count(node);
604         if (nbuttons == 0)
605                 return ERR_PTR(-ENODEV);
606
607         pdata = devm_kzalloc(dev,
608                              sizeof(*pdata) + nbuttons * sizeof(*button),
609                              GFP_KERNEL);
610         if (!pdata)
611                 return ERR_PTR(-ENOMEM);
612
613         pdata->buttons = (struct gpio_keys_button *)(pdata + 1);
614         pdata->nbuttons = nbuttons;
615
616         pdata->rep = !!of_get_property(node, "autorepeat", NULL);
617
618         i = 0;
619         for_each_child_of_node(node, pp) {
620                 int gpio;
621                 enum of_gpio_flags flags;
622
623                 if (!of_find_property(pp, "gpios", NULL)) {
624                         pdata->nbuttons--;
625                         dev_warn(dev, "Found button without gpios\n");
626                         continue;
627                 }
628
629                 gpio = of_get_gpio_flags(pp, 0, &flags);
630                 if (gpio < 0) {
631                         error = gpio;
632                         if (error != -EPROBE_DEFER)
633                                 dev_err(dev,
634                                         "Failed to get gpio flags, error: %d\n",
635                                         error);
636                         return ERR_PTR(error);
637                 }
638
639                 button = &pdata->buttons[i++];
640
641                 button->gpio = gpio;
642                 button->active_low = flags & OF_GPIO_ACTIVE_LOW;
643
644                 if (of_property_read_u32(pp, "linux,code", &button->code)) {
645                         dev_err(dev, "Button without keycode: 0x%x\n",
646                                 button->gpio);
647                         return ERR_PTR(-EINVAL);
648                 }
649
650                 button->desc = of_get_property(pp, "label", NULL);
651
652                 if (of_property_read_u32(pp, "linux,input-type", &button->type))
653                         button->type = EV_KEY;
654
655                 button->wakeup = !!of_get_property(pp, "gpio-key,wakeup", NULL);
656
657                 if (of_property_read_u32(pp, "debounce-interval",
658                                          &button->debounce_interval))
659                         button->debounce_interval = 5;
660         }
661
662         if (pdata->nbuttons == 0)
663                 return ERR_PTR(-EINVAL);
664
665         return pdata;
666 }
667
668 static const struct of_device_id gpio_keys_of_match[] = {
669         { .compatible = "gpio-keys", },
670         { },
671 };
672 MODULE_DEVICE_TABLE(of, gpio_keys_of_match);
673
674 #else
675
676 static inline struct gpio_keys_platform_data *
677 gpio_keys_get_devtree_pdata(struct device *dev)
678 {
679         return ERR_PTR(-ENODEV);
680 }
681
682 #endif
683
684 static int gpio_keys_probe(struct platform_device *pdev)
685 {
686         struct device *dev = &pdev->dev;
687         const struct gpio_keys_platform_data *pdata = dev_get_platdata(dev);
688         struct gpio_keys_drvdata *ddata;
689         struct input_dev *input;
690         size_t size;
691         int i, error;
692         int wakeup = 0;
693
694         if (!pdata) {
695                 pdata = gpio_keys_get_devtree_pdata(dev);
696                 if (IS_ERR(pdata))
697                         return PTR_ERR(pdata);
698         }
699
700         size = sizeof(struct gpio_keys_drvdata) +
701                         pdata->nbuttons * sizeof(struct gpio_button_data);
702         ddata = devm_kzalloc(dev, size, GFP_KERNEL);
703         if (!ddata) {
704                 dev_err(dev, "failed to allocate state\n");
705                 return -ENOMEM;
706         }
707
708         input = devm_input_allocate_device(dev);
709         if (!input) {
710                 dev_err(dev, "failed to allocate input device\n");
711                 return -ENOMEM;
712         }
713
714         ddata->pdata = pdata;
715         ddata->input = input;
716         mutex_init(&ddata->disable_lock);
717
718         platform_set_drvdata(pdev, ddata);
719         input_set_drvdata(input, ddata);
720
721         input->name = pdata->name ? : pdev->name;
722         input->phys = "gpio-keys/input0";
723         input->dev.parent = &pdev->dev;
724         input->open = gpio_keys_open;
725         input->close = gpio_keys_close;
726
727         input->id.bustype = BUS_HOST;
728         input->id.vendor = 0x0001;
729         input->id.product = 0x0001;
730         input->id.version = 0x0100;
731
732         /* Enable auto repeat feature of Linux input subsystem */
733         if (pdata->rep)
734                 __set_bit(EV_REP, input->evbit);
735
736         for (i = 0; i < pdata->nbuttons; i++) {
737                 const struct gpio_keys_button *button = &pdata->buttons[i];
738                 struct gpio_button_data *bdata = &ddata->data[i];
739
740                 error = gpio_keys_setup_key(pdev, input, bdata, button);
741                 if (error)
742                         return error;
743
744                 if (button->wakeup)
745                         wakeup = 1;
746         }
747
748         error = sysfs_create_group(&pdev->dev.kobj, &gpio_keys_attr_group);
749         if (error) {
750                 dev_err(dev, "Unable to export keys/switches, error: %d\n",
751                         error);
752                 return error;
753         }
754
755         error = input_register_device(input);
756         if (error) {
757                 dev_err(dev, "Unable to register input device, error: %d\n",
758                         error);
759                 goto err_remove_group;
760         }
761
762         device_init_wakeup(&pdev->dev, wakeup);
763
764         return 0;
765
766 err_remove_group:
767         sysfs_remove_group(&pdev->dev.kobj, &gpio_keys_attr_group);
768         return error;
769 }
770
771 static int gpio_keys_remove(struct platform_device *pdev)
772 {
773         sysfs_remove_group(&pdev->dev.kobj, &gpio_keys_attr_group);
774
775         device_init_wakeup(&pdev->dev, 0);
776
777         return 0;
778 }
779
780 #ifdef CONFIG_PM_SLEEP
781 static int gpio_keys_suspend(struct device *dev)
782 {
783         struct gpio_keys_drvdata *ddata = dev_get_drvdata(dev);
784         struct input_dev *input = ddata->input;
785         int i;
786
787         if (device_may_wakeup(dev)) {
788                 for (i = 0; i < ddata->pdata->nbuttons; i++) {
789                         struct gpio_button_data *bdata = &ddata->data[i];
790                         if (bdata->button->wakeup)
791                                 enable_irq_wake(bdata->irq);
792                 }
793         } else {
794                 mutex_lock(&input->mutex);
795                 if (input->users)
796                         gpio_keys_close(input);
797                 mutex_unlock(&input->mutex);
798         }
799
800         return 0;
801 }
802
803 static int gpio_keys_resume(struct device *dev)
804 {
805         struct gpio_keys_drvdata *ddata = dev_get_drvdata(dev);
806         struct input_dev *input = ddata->input;
807         int error = 0;
808         int i;
809
810         if (device_may_wakeup(dev)) {
811                 for (i = 0; i < ddata->pdata->nbuttons; i++) {
812                         struct gpio_button_data *bdata = &ddata->data[i];
813                         if (bdata->button->wakeup)
814                                 disable_irq_wake(bdata->irq);
815                 }
816         } else {
817                 mutex_lock(&input->mutex);
818                 if (input->users)
819                         error = gpio_keys_open(input);
820                 mutex_unlock(&input->mutex);
821         }
822
823         if (error)
824                 return error;
825
826         gpio_keys_report_state(ddata);
827         return 0;
828 }
829 #endif
830
831 static SIMPLE_DEV_PM_OPS(gpio_keys_pm_ops, gpio_keys_suspend, gpio_keys_resume);
832
833 static struct platform_driver gpio_keys_device_driver = {
834         .probe          = gpio_keys_probe,
835         .remove         = gpio_keys_remove,
836         .driver         = {
837                 .name   = "gpio-keys",
838                 .owner  = THIS_MODULE,
839                 .pm     = &gpio_keys_pm_ops,
840                 .of_match_table = of_match_ptr(gpio_keys_of_match),
841         }
842 };
843
844 static int __init gpio_keys_init(void)
845 {
846         return platform_driver_register(&gpio_keys_device_driver);
847 }
848
849 static void __exit gpio_keys_exit(void)
850 {
851         platform_driver_unregister(&gpio_keys_device_driver);
852 }
853
854 late_initcall(gpio_keys_init);
855 module_exit(gpio_keys_exit);
856
857 MODULE_LICENSE("GPL");
858 MODULE_AUTHOR("Phil Blundell <pb@handhelds.org>");
859 MODULE_DESCRIPTION("Keyboard driver for GPIOs");
860 MODULE_ALIAS("platform:gpio-keys");