Version:  2.0.40 2.2.26 2.4.37 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18

Linux/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");
861 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us