1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * Driver for keys on GPIO lines capable of generating interrupts.
4  *
5  * Copyright 2005 Phil Blundell
6  * Copyright 2010, 2011 David Jander <david@protonic.nl>
7  */
8 
9 #include <linux/module.h>
10 
11 #include <linux/init.h>
12 #include <linux/fs.h>
13 #include <linux/interrupt.h>
14 #include <linux/irq.h>
15 #include <linux/sched.h>
16 #include <linux/pm.h>
17 #include <linux/slab.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/gpio_keys.h>
24 #include <linux/workqueue.h>
25 #include <linux/gpio.h>
26 #include <linux/gpio/consumer.h>
27 #include <linux/of.h>
28 #include <linux/of_irq.h>
29 #include <linux/spinlock.h>
30 #include <dt-bindings/input/gpio-keys.h>
31 
32 struct gpio_button_data {
33 	const struct gpio_keys_button *button;
34 	struct input_dev *input;
35 	struct gpio_desc *gpiod;
36 
37 	unsigned short *code;
38 
39 	struct timer_list release_timer;
40 	unsigned int release_delay;	/* in msecs, for IRQ-only buttons */
41 
42 	struct delayed_work work;
43 	unsigned int software_debounce;	/* in msecs, for GPIO-driven buttons */
44 
45 	unsigned int irq;
46 	unsigned int wakeup_trigger_type;
47 	spinlock_t lock;
48 	bool disabled;
49 	bool key_pressed;
50 	bool suspended;
51 };
52 
53 struct gpio_keys_drvdata {
54 	const struct gpio_keys_platform_data *pdata;
55 	struct input_dev *input;
56 	struct mutex disable_lock;
57 	unsigned short *keymap;
58 	struct gpio_button_data data[];
59 };
60 
61 /*
62  * SYSFS interface for enabling/disabling keys and switches:
63  *
64  * There are 4 attributes under /sys/devices/platform/gpio-keys/
65  *	keys [ro]              - bitmap of keys (EV_KEY) which can be
66  *	                         disabled
67  *	switches [ro]          - bitmap of switches (EV_SW) which can be
68  *	                         disabled
69  *	disabled_keys [rw]     - bitmap of keys currently disabled
70  *	disabled_switches [rw] - bitmap of switches currently disabled
71  *
72  * Userland can change these values and hence disable event generation
73  * for each key (or switch). Disabling a key means its interrupt line
74  * is disabled.
75  *
76  * For example, if we have following switches set up as gpio-keys:
77  *	SW_DOCK = 5
78  *	SW_CAMERA_LENS_COVER = 9
79  *	SW_KEYPAD_SLIDE = 10
80  *	SW_FRONT_PROXIMITY = 11
81  * This is read from switches:
82  *	11-9,5
83  * Next we want to disable proximity (11) and dock (5), we write:
84  *	11,5
85  * to file disabled_switches. Now proximity and dock IRQs are disabled.
86  * This can be verified by reading the file disabled_switches:
87  *	11,5
88  * If we now want to enable proximity (11) switch we write:
89  *	5
90  * to disabled_switches.
91  *
92  * We can disable only those keys which don't allow sharing the irq.
93  */
94 
95 /**
96  * get_n_events_by_type() - returns maximum number of events per @type
97  * @type: type of button (%EV_KEY, %EV_SW)
98  *
99  * Return value of this function can be used to allocate bitmap
100  * large enough to hold all bits for given type.
101  */
102 static int get_n_events_by_type(int type)
103 {
104 	BUG_ON(type != EV_SW && type != EV_KEY);
105 
106 	return (type == EV_KEY) ? KEY_CNT : SW_CNT;
107 }
108 
109 /**
110  * get_bm_events_by_type() - returns bitmap of supported events per @type
111  * @dev: input device from which bitmap is retrieved
112  * @type: type of button (%EV_KEY, %EV_SW)
113  *
114  * Return value of this function can be used to allocate bitmap
115  * large enough to hold all bits for given type.
116  */
117 static const unsigned long *get_bm_events_by_type(struct input_dev *dev,
118 						  int type)
119 {
120 	BUG_ON(type != EV_SW && type != EV_KEY);
121 
122 	return (type == EV_KEY) ? dev->keybit : dev->swbit;
123 }
124 
125 /**
126  * gpio_keys_disable_button() - disables given GPIO button
127  * @bdata: button data for button to be disabled
128  *
129  * Disables button pointed by @bdata. This is done by masking
130  * IRQ line. After this function is called, button won't generate
131  * input events anymore. Note that one can only disable buttons
132  * that don't share IRQs.
133  *
134  * Make sure that @bdata->disable_lock is locked when entering
135  * this function to avoid races when concurrent threads are
136  * disabling buttons at the same time.
137  */
138 static void gpio_keys_disable_button(struct gpio_button_data *bdata)
139 {
140 	if (!bdata->disabled) {
141 		/*
142 		 * Disable IRQ and associated timer/work structure.
143 		 */
144 		disable_irq(bdata->irq);
145 
146 		if (bdata->gpiod)
147 			cancel_delayed_work_sync(&bdata->work);
148 		else
149 			del_timer_sync(&bdata->release_timer);
150 
151 		bdata->disabled = true;
152 	}
153 }
154 
155 /**
156  * gpio_keys_enable_button() - enables given GPIO button
157  * @bdata: button data for button to be disabled
158  *
159  * Enables given button pointed by @bdata.
160  *
161  * Make sure that @bdata->disable_lock is locked when entering
162  * this function to avoid races with concurrent threads trying
163  * to enable the same button at the same time.
164  */
165 static void gpio_keys_enable_button(struct gpio_button_data *bdata)
166 {
167 	if (bdata->disabled) {
168 		enable_irq(bdata->irq);
169 		bdata->disabled = false;
170 	}
171 }
172 
173 /**
174  * gpio_keys_attr_show_helper() - fill in stringified bitmap of buttons
175  * @ddata: pointer to drvdata
176  * @buf: buffer where stringified bitmap is written
177  * @type: button type (%EV_KEY, %EV_SW)
178  * @only_disabled: does caller want only those buttons that are
179  *                 currently disabled or all buttons that can be
180  *                 disabled
181  *
182  * This function writes buttons that can be disabled to @buf. If
183  * @only_disabled is true, then @buf contains only those buttons
184  * that are currently disabled. Returns 0 on success or negative
185  * errno on failure.
186  */
187 static ssize_t gpio_keys_attr_show_helper(struct gpio_keys_drvdata *ddata,
188 					  char *buf, unsigned int type,
189 					  bool only_disabled)
190 {
191 	int n_events = get_n_events_by_type(type);
192 	unsigned long *bits;
193 	ssize_t ret;
194 	int i;
195 
196 	bits = bitmap_zalloc(n_events, GFP_KERNEL);
197 	if (!bits)
198 		return -ENOMEM;
199 
200 	for (i = 0; i < ddata->pdata->nbuttons; i++) {
201 		struct gpio_button_data *bdata = &ddata->data[i];
202 
203 		if (bdata->button->type != type)
204 			continue;
205 
206 		if (only_disabled && !bdata->disabled)
207 			continue;
208 
209 		__set_bit(*bdata->code, bits);
210 	}
211 
212 	ret = scnprintf(buf, PAGE_SIZE - 1, "%*pbl", n_events, bits);
213 	buf[ret++] = '\n';
214 	buf[ret] = '\0';
215 
216 	bitmap_free(bits);
217 
218 	return ret;
219 }
220 
221 /**
222  * gpio_keys_attr_store_helper() - enable/disable buttons based on given bitmap
223  * @ddata: pointer to drvdata
224  * @buf: buffer from userspace that contains stringified bitmap
225  * @type: button type (%EV_KEY, %EV_SW)
226  *
227  * This function parses stringified bitmap from @buf and disables/enables
228  * GPIO buttons accordingly. Returns 0 on success and negative error
229  * on failure.
230  */
231 static ssize_t gpio_keys_attr_store_helper(struct gpio_keys_drvdata *ddata,
232 					   const char *buf, unsigned int type)
233 {
234 	int n_events = get_n_events_by_type(type);
235 	const unsigned long *bitmap = get_bm_events_by_type(ddata->input, type);
236 	unsigned long *bits;
237 	ssize_t error;
238 	int i;
239 
240 	bits = bitmap_zalloc(n_events, GFP_KERNEL);
241 	if (!bits)
242 		return -ENOMEM;
243 
244 	error = bitmap_parselist(buf, bits, n_events);
245 	if (error)
246 		goto out;
247 
248 	/* First validate */
249 	if (!bitmap_subset(bits, bitmap, n_events)) {
250 		error = -EINVAL;
251 		goto out;
252 	}
253 
254 	for (i = 0; i < ddata->pdata->nbuttons; i++) {
255 		struct gpio_button_data *bdata = &ddata->data[i];
256 
257 		if (bdata->button->type != type)
258 			continue;
259 
260 		if (test_bit(*bdata->code, bits) &&
261 		    !bdata->button->can_disable) {
262 			error = -EINVAL;
263 			goto out;
264 		}
265 	}
266 
267 	mutex_lock(&ddata->disable_lock);
268 
269 	for (i = 0; i < ddata->pdata->nbuttons; i++) {
270 		struct gpio_button_data *bdata = &ddata->data[i];
271 
272 		if (bdata->button->type != type)
273 			continue;
274 
275 		if (test_bit(*bdata->code, bits))
276 			gpio_keys_disable_button(bdata);
277 		else
278 			gpio_keys_enable_button(bdata);
279 	}
280 
281 	mutex_unlock(&ddata->disable_lock);
282 
283 out:
284 	bitmap_free(bits);
285 	return error;
286 }
287 
288 #define ATTR_SHOW_FN(name, type, only_disabled)				\
289 static ssize_t gpio_keys_show_##name(struct device *dev,		\
290 				     struct device_attribute *attr,	\
291 				     char *buf)				\
292 {									\
293 	struct platform_device *pdev = to_platform_device(dev);		\
294 	struct gpio_keys_drvdata *ddata = platform_get_drvdata(pdev);	\
295 									\
296 	return gpio_keys_attr_show_helper(ddata, buf,			\
297 					  type, only_disabled);		\
298 }
299 
300 ATTR_SHOW_FN(keys, EV_KEY, false);
301 ATTR_SHOW_FN(switches, EV_SW, false);
302 ATTR_SHOW_FN(disabled_keys, EV_KEY, true);
303 ATTR_SHOW_FN(disabled_switches, EV_SW, true);
304 
305 /*
306  * ATTRIBUTES:
307  *
308  * /sys/devices/platform/gpio-keys/keys [ro]
309  * /sys/devices/platform/gpio-keys/switches [ro]
310  */
311 static DEVICE_ATTR(keys, S_IRUGO, gpio_keys_show_keys, NULL);
312 static DEVICE_ATTR(switches, S_IRUGO, gpio_keys_show_switches, NULL);
313 
314 #define ATTR_STORE_FN(name, type)					\
315 static ssize_t gpio_keys_store_##name(struct device *dev,		\
316 				      struct device_attribute *attr,	\
317 				      const char *buf,			\
318 				      size_t count)			\
319 {									\
320 	struct platform_device *pdev = to_platform_device(dev);		\
321 	struct gpio_keys_drvdata *ddata = platform_get_drvdata(pdev);	\
322 	ssize_t error;							\
323 									\
324 	error = gpio_keys_attr_store_helper(ddata, buf, type);		\
325 	if (error)							\
326 		return error;						\
327 									\
328 	return count;							\
329 }
330 
331 ATTR_STORE_FN(disabled_keys, EV_KEY);
332 ATTR_STORE_FN(disabled_switches, EV_SW);
333 
334 /*
335  * ATTRIBUTES:
336  *
337  * /sys/devices/platform/gpio-keys/disabled_keys [rw]
338  * /sys/devices/platform/gpio-keys/disables_switches [rw]
339  */
340 static DEVICE_ATTR(disabled_keys, S_IWUSR | S_IRUGO,
341 		   gpio_keys_show_disabled_keys,
342 		   gpio_keys_store_disabled_keys);
343 static DEVICE_ATTR(disabled_switches, S_IWUSR | S_IRUGO,
344 		   gpio_keys_show_disabled_switches,
345 		   gpio_keys_store_disabled_switches);
346 
347 static struct attribute *gpio_keys_attrs[] = {
348 	&dev_attr_keys.attr,
349 	&dev_attr_switches.attr,
350 	&dev_attr_disabled_keys.attr,
351 	&dev_attr_disabled_switches.attr,
352 	NULL,
353 };
354 ATTRIBUTE_GROUPS(gpio_keys);
355 
356 static void gpio_keys_gpio_report_event(struct gpio_button_data *bdata)
357 {
358 	const struct gpio_keys_button *button = bdata->button;
359 	struct input_dev *input = bdata->input;
360 	unsigned int type = button->type ?: EV_KEY;
361 	int state;
362 
363 	state = gpiod_get_value_cansleep(bdata->gpiod);
364 	if (state < 0) {
365 		dev_err(input->dev.parent,
366 			"failed to get gpio state: %d\n", state);
367 		return;
368 	}
369 
370 	if (type == EV_ABS) {
371 		if (state)
372 			input_event(input, type, button->code, button->value);
373 	} else {
374 		input_event(input, type, *bdata->code, state);
375 	}
376 	input_sync(input);
377 }
378 
379 static void gpio_keys_gpio_work_func(struct work_struct *work)
380 {
381 	struct gpio_button_data *bdata =
382 		container_of(work, struct gpio_button_data, work.work);
383 
384 	gpio_keys_gpio_report_event(bdata);
385 
386 	if (bdata->button->wakeup)
387 		pm_relax(bdata->input->dev.parent);
388 }
389 
390 static irqreturn_t gpio_keys_gpio_isr(int irq, void *dev_id)
391 {
392 	struct gpio_button_data *bdata = dev_id;
393 
394 	BUG_ON(irq != bdata->irq);
395 
396 	if (bdata->button->wakeup) {
397 		const struct gpio_keys_button *button = bdata->button;
398 
399 		pm_stay_awake(bdata->input->dev.parent);
400 		if (bdata->suspended  &&
401 		    (button->type == 0 || button->type == EV_KEY)) {
402 			/*
403 			 * Simulate wakeup key press in case the key has
404 			 * already released by the time we got interrupt
405 			 * handler to run.
406 			 */
407 			input_report_key(bdata->input, button->code, 1);
408 		}
409 	}
410 
411 	mod_delayed_work(system_wq,
412 			 &bdata->work,
413 			 msecs_to_jiffies(bdata->software_debounce));
414 
415 	return IRQ_HANDLED;
416 }
417 
418 static void gpio_keys_irq_timer(struct timer_list *t)
419 {
420 	struct gpio_button_data *bdata = from_timer(bdata, t, release_timer);
421 	struct input_dev *input = bdata->input;
422 	unsigned long flags;
423 
424 	spin_lock_irqsave(&bdata->lock, flags);
425 	if (bdata->key_pressed) {
426 		input_event(input, EV_KEY, *bdata->code, 0);
427 		input_sync(input);
428 		bdata->key_pressed = false;
429 	}
430 	spin_unlock_irqrestore(&bdata->lock, flags);
431 }
432 
433 static irqreturn_t gpio_keys_irq_isr(int irq, void *dev_id)
434 {
435 	struct gpio_button_data *bdata = dev_id;
436 	struct input_dev *input = bdata->input;
437 	unsigned long flags;
438 
439 	BUG_ON(irq != bdata->irq);
440 
441 	spin_lock_irqsave(&bdata->lock, flags);
442 
443 	if (!bdata->key_pressed) {
444 		if (bdata->button->wakeup)
445 			pm_wakeup_event(bdata->input->dev.parent, 0);
446 
447 		input_event(input, EV_KEY, *bdata->code, 1);
448 		input_sync(input);
449 
450 		if (!bdata->release_delay) {
451 			input_event(input, EV_KEY, *bdata->code, 0);
452 			input_sync(input);
453 			goto out;
454 		}
455 
456 		bdata->key_pressed = true;
457 	}
458 
459 	if (bdata->release_delay)
460 		mod_timer(&bdata->release_timer,
461 			jiffies + msecs_to_jiffies(bdata->release_delay));
462 out:
463 	spin_unlock_irqrestore(&bdata->lock, flags);
464 	return IRQ_HANDLED;
465 }
466 
467 static void gpio_keys_quiesce_key(void *data)
468 {
469 	struct gpio_button_data *bdata = data;
470 
471 	if (bdata->gpiod)
472 		cancel_delayed_work_sync(&bdata->work);
473 	else
474 		del_timer_sync(&bdata->release_timer);
475 }
476 
477 static int gpio_keys_setup_key(struct platform_device *pdev,
478 				struct input_dev *input,
479 				struct gpio_keys_drvdata *ddata,
480 				const struct gpio_keys_button *button,
481 				int idx,
482 				struct fwnode_handle *child)
483 {
484 	const char *desc = button->desc ? button->desc : "gpio_keys";
485 	struct device *dev = &pdev->dev;
486 	struct gpio_button_data *bdata = &ddata->data[idx];
487 	irq_handler_t isr;
488 	unsigned long irqflags;
489 	int irq;
490 	int error;
491 
492 	bdata->input = input;
493 	bdata->button = button;
494 	spin_lock_init(&bdata->lock);
495 
496 	if (child) {
497 		bdata->gpiod = devm_fwnode_gpiod_get(dev, child,
498 						     NULL, GPIOD_IN, desc);
499 		if (IS_ERR(bdata->gpiod)) {
500 			error = PTR_ERR(bdata->gpiod);
501 			if (error == -ENOENT) {
502 				/*
503 				 * GPIO is optional, we may be dealing with
504 				 * purely interrupt-driven setup.
505 				 */
506 				bdata->gpiod = NULL;
507 			} else {
508 				if (error != -EPROBE_DEFER)
509 					dev_err(dev, "failed to get gpio: %d\n",
510 						error);
511 				return error;
512 			}
513 		}
514 	} else if (gpio_is_valid(button->gpio)) {
515 		/*
516 		 * Legacy GPIO number, so request the GPIO here and
517 		 * convert it to descriptor.
518 		 */
519 		unsigned flags = GPIOF_IN;
520 
521 		if (button->active_low)
522 			flags |= GPIOF_ACTIVE_LOW;
523 
524 		error = devm_gpio_request_one(dev, button->gpio, flags, desc);
525 		if (error < 0) {
526 			dev_err(dev, "Failed to request GPIO %d, error %d\n",
527 				button->gpio, error);
528 			return error;
529 		}
530 
531 		bdata->gpiod = gpio_to_desc(button->gpio);
532 		if (!bdata->gpiod)
533 			return -EINVAL;
534 	}
535 
536 	if (bdata->gpiod) {
537 		bool active_low = gpiod_is_active_low(bdata->gpiod);
538 
539 		if (button->debounce_interval) {
540 			error = gpiod_set_debounce(bdata->gpiod,
541 					button->debounce_interval * 1000);
542 			/* use timer if gpiolib doesn't provide debounce */
543 			if (error < 0)
544 				bdata->software_debounce =
545 						button->debounce_interval;
546 		}
547 
548 		if (button->irq) {
549 			bdata->irq = button->irq;
550 		} else {
551 			irq = gpiod_to_irq(bdata->gpiod);
552 			if (irq < 0) {
553 				error = irq;
554 				dev_err(dev,
555 					"Unable to get irq number for GPIO %d, error %d\n",
556 					button->gpio, error);
557 				return error;
558 			}
559 			bdata->irq = irq;
560 		}
561 
562 		INIT_DELAYED_WORK(&bdata->work, gpio_keys_gpio_work_func);
563 
564 		isr = gpio_keys_gpio_isr;
565 		irqflags = IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING;
566 
567 		switch (button->wakeup_event_action) {
568 		case EV_ACT_ASSERTED:
569 			bdata->wakeup_trigger_type = active_low ?
570 				IRQ_TYPE_EDGE_FALLING : IRQ_TYPE_EDGE_RISING;
571 			break;
572 		case EV_ACT_DEASSERTED:
573 			bdata->wakeup_trigger_type = active_low ?
574 				IRQ_TYPE_EDGE_RISING : IRQ_TYPE_EDGE_FALLING;
575 			break;
576 		case EV_ACT_ANY:
577 		default:
578 			/*
579 			 * For other cases, we are OK letting suspend/resume
580 			 * not reconfigure the trigger type.
581 			 */
582 			break;
583 		}
584 	} else {
585 		if (!button->irq) {
586 			dev_err(dev, "Found button without gpio or irq\n");
587 			return -EINVAL;
588 		}
589 
590 		bdata->irq = button->irq;
591 
592 		if (button->type && button->type != EV_KEY) {
593 			dev_err(dev, "Only EV_KEY allowed for IRQ buttons.\n");
594 			return -EINVAL;
595 		}
596 
597 		bdata->release_delay = button->debounce_interval;
598 		timer_setup(&bdata->release_timer, gpio_keys_irq_timer, 0);
599 
600 		isr = gpio_keys_irq_isr;
601 		irqflags = 0;
602 
603 		/*
604 		 * For IRQ buttons, there is no interrupt for release.
605 		 * So we don't need to reconfigure the trigger type for wakeup.
606 		 */
607 	}
608 
609 	bdata->code = &ddata->keymap[idx];
610 	*bdata->code = button->code;
611 	input_set_capability(input, button->type ?: EV_KEY, *bdata->code);
612 
613 	/*
614 	 * Install custom action to cancel release timer and
615 	 * workqueue item.
616 	 */
617 	error = devm_add_action(dev, gpio_keys_quiesce_key, bdata);
618 	if (error) {
619 		dev_err(dev, "failed to register quiesce action, error: %d\n",
620 			error);
621 		return error;
622 	}
623 
624 	/*
625 	 * If platform has specified that the button can be disabled,
626 	 * we don't want it to share the interrupt line.
627 	 */
628 	if (!button->can_disable)
629 		irqflags |= IRQF_SHARED;
630 
631 	error = devm_request_any_context_irq(dev, bdata->irq, isr, irqflags,
632 					     desc, bdata);
633 	if (error < 0) {
634 		dev_err(dev, "Unable to claim irq %d; error %d\n",
635 			bdata->irq, error);
636 		return error;
637 	}
638 
639 	return 0;
640 }
641 
642 static void gpio_keys_report_state(struct gpio_keys_drvdata *ddata)
643 {
644 	struct input_dev *input = ddata->input;
645 	int i;
646 
647 	for (i = 0; i < ddata->pdata->nbuttons; i++) {
648 		struct gpio_button_data *bdata = &ddata->data[i];
649 		if (bdata->gpiod)
650 			gpio_keys_gpio_report_event(bdata);
651 	}
652 	input_sync(input);
653 }
654 
655 static int gpio_keys_open(struct input_dev *input)
656 {
657 	struct gpio_keys_drvdata *ddata = input_get_drvdata(input);
658 	const struct gpio_keys_platform_data *pdata = ddata->pdata;
659 	int error;
660 
661 	if (pdata->enable) {
662 		error = pdata->enable(input->dev.parent);
663 		if (error)
664 			return error;
665 	}
666 
667 	/* Report current state of buttons that are connected to GPIOs */
668 	gpio_keys_report_state(ddata);
669 
670 	return 0;
671 }
672 
673 static void gpio_keys_close(struct input_dev *input)
674 {
675 	struct gpio_keys_drvdata *ddata = input_get_drvdata(input);
676 	const struct gpio_keys_platform_data *pdata = ddata->pdata;
677 
678 	if (pdata->disable)
679 		pdata->disable(input->dev.parent);
680 }
681 
682 /*
683  * Handlers for alternative sources of platform_data
684  */
685 
686 /*
687  * Translate properties into platform_data
688  */
689 static struct gpio_keys_platform_data *
690 gpio_keys_get_devtree_pdata(struct device *dev)
691 {
692 	struct gpio_keys_platform_data *pdata;
693 	struct gpio_keys_button *button;
694 	struct fwnode_handle *child;
695 	int nbuttons;
696 
697 	nbuttons = device_get_child_node_count(dev);
698 	if (nbuttons == 0)
699 		return ERR_PTR(-ENODEV);
700 
701 	pdata = devm_kzalloc(dev,
702 			     sizeof(*pdata) + nbuttons * sizeof(*button),
703 			     GFP_KERNEL);
704 	if (!pdata)
705 		return ERR_PTR(-ENOMEM);
706 
707 	button = (struct gpio_keys_button *)(pdata + 1);
708 
709 	pdata->buttons = button;
710 	pdata->nbuttons = nbuttons;
711 
712 	pdata->rep = device_property_read_bool(dev, "autorepeat");
713 
714 	device_property_read_string(dev, "label", &pdata->name);
715 
716 	device_for_each_child_node(dev, child) {
717 		if (is_of_node(child))
718 			button->irq =
719 				irq_of_parse_and_map(to_of_node(child), 0);
720 
721 		if (fwnode_property_read_u32(child, "linux,code",
722 					     &button->code)) {
723 			dev_err(dev, "Button without keycode\n");
724 			fwnode_handle_put(child);
725 			return ERR_PTR(-EINVAL);
726 		}
727 
728 		fwnode_property_read_string(child, "label", &button->desc);
729 
730 		if (fwnode_property_read_u32(child, "linux,input-type",
731 					     &button->type))
732 			button->type = EV_KEY;
733 
734 		button->wakeup =
735 			fwnode_property_read_bool(child, "wakeup-source") ||
736 			/* legacy name */
737 			fwnode_property_read_bool(child, "gpio-key,wakeup");
738 
739 		fwnode_property_read_u32(child, "wakeup-event-action",
740 					 &button->wakeup_event_action);
741 
742 		button->can_disable =
743 			fwnode_property_read_bool(child, "linux,can-disable");
744 
745 		if (fwnode_property_read_u32(child, "debounce-interval",
746 					 &button->debounce_interval))
747 			button->debounce_interval = 5;
748 
749 		button++;
750 	}
751 
752 	return pdata;
753 }
754 
755 static const struct of_device_id gpio_keys_of_match[] = {
756 	{ .compatible = "gpio-keys", },
757 	{ },
758 };
759 MODULE_DEVICE_TABLE(of, gpio_keys_of_match);
760 
761 static int gpio_keys_probe(struct platform_device *pdev)
762 {
763 	struct device *dev = &pdev->dev;
764 	const struct gpio_keys_platform_data *pdata = dev_get_platdata(dev);
765 	struct fwnode_handle *child = NULL;
766 	struct gpio_keys_drvdata *ddata;
767 	struct input_dev *input;
768 	int i, error;
769 	int wakeup = 0;
770 
771 	if (!pdata) {
772 		pdata = gpio_keys_get_devtree_pdata(dev);
773 		if (IS_ERR(pdata))
774 			return PTR_ERR(pdata);
775 	}
776 
777 	ddata = devm_kzalloc(dev, struct_size(ddata, data, pdata->nbuttons),
778 			     GFP_KERNEL);
779 	if (!ddata) {
780 		dev_err(dev, "failed to allocate state\n");
781 		return -ENOMEM;
782 	}
783 
784 	ddata->keymap = devm_kcalloc(dev,
785 				     pdata->nbuttons, sizeof(ddata->keymap[0]),
786 				     GFP_KERNEL);
787 	if (!ddata->keymap)
788 		return -ENOMEM;
789 
790 	input = devm_input_allocate_device(dev);
791 	if (!input) {
792 		dev_err(dev, "failed to allocate input device\n");
793 		return -ENOMEM;
794 	}
795 
796 	ddata->pdata = pdata;
797 	ddata->input = input;
798 	mutex_init(&ddata->disable_lock);
799 
800 	platform_set_drvdata(pdev, ddata);
801 	input_set_drvdata(input, ddata);
802 
803 	input->name = pdata->name ? : pdev->name;
804 	input->phys = "gpio-keys/input0";
805 	input->dev.parent = dev;
806 	input->open = gpio_keys_open;
807 	input->close = gpio_keys_close;
808 
809 	input->id.bustype = BUS_HOST;
810 	input->id.vendor = 0x0001;
811 	input->id.product = 0x0001;
812 	input->id.version = 0x0100;
813 
814 	input->keycode = ddata->keymap;
815 	input->keycodesize = sizeof(ddata->keymap[0]);
816 	input->keycodemax = pdata->nbuttons;
817 
818 	/* Enable auto repeat feature of Linux input subsystem */
819 	if (pdata->rep)
820 		__set_bit(EV_REP, input->evbit);
821 
822 	for (i = 0; i < pdata->nbuttons; i++) {
823 		const struct gpio_keys_button *button = &pdata->buttons[i];
824 
825 		if (!dev_get_platdata(dev)) {
826 			child = device_get_next_child_node(dev, child);
827 			if (!child) {
828 				dev_err(dev,
829 					"missing child device node for entry %d\n",
830 					i);
831 				return -EINVAL;
832 			}
833 		}
834 
835 		error = gpio_keys_setup_key(pdev, input, ddata,
836 					    button, i, child);
837 		if (error) {
838 			fwnode_handle_put(child);
839 			return error;
840 		}
841 
842 		if (button->wakeup)
843 			wakeup = 1;
844 	}
845 
846 	fwnode_handle_put(child);
847 
848 	error = input_register_device(input);
849 	if (error) {
850 		dev_err(dev, "Unable to register input device, error: %d\n",
851 			error);
852 		return error;
853 	}
854 
855 	device_init_wakeup(dev, wakeup);
856 
857 	return 0;
858 }
859 
860 static int __maybe_unused
861 gpio_keys_button_enable_wakeup(struct gpio_button_data *bdata)
862 {
863 	int error;
864 
865 	error = enable_irq_wake(bdata->irq);
866 	if (error) {
867 		dev_err(bdata->input->dev.parent,
868 			"failed to configure IRQ %d as wakeup source: %d\n",
869 			bdata->irq, error);
870 		return error;
871 	}
872 
873 	if (bdata->wakeup_trigger_type) {
874 		error = irq_set_irq_type(bdata->irq,
875 					 bdata->wakeup_trigger_type);
876 		if (error) {
877 			dev_err(bdata->input->dev.parent,
878 				"failed to set wakeup trigger %08x for IRQ %d: %d\n",
879 				bdata->wakeup_trigger_type, bdata->irq, error);
880 			disable_irq_wake(bdata->irq);
881 			return error;
882 		}
883 	}
884 
885 	return 0;
886 }
887 
888 static void __maybe_unused
889 gpio_keys_button_disable_wakeup(struct gpio_button_data *bdata)
890 {
891 	int error;
892 
893 	/*
894 	 * The trigger type is always both edges for gpio-based keys and we do
895 	 * not support changing wakeup trigger for interrupt-based keys.
896 	 */
897 	if (bdata->wakeup_trigger_type) {
898 		error = irq_set_irq_type(bdata->irq, IRQ_TYPE_EDGE_BOTH);
899 		if (error)
900 			dev_warn(bdata->input->dev.parent,
901 				 "failed to restore interrupt trigger for IRQ %d: %d\n",
902 				 bdata->irq, error);
903 	}
904 
905 	error = disable_irq_wake(bdata->irq);
906 	if (error)
907 		dev_warn(bdata->input->dev.parent,
908 			 "failed to disable IRQ %d as wake source: %d\n",
909 			 bdata->irq, error);
910 }
911 
912 static int __maybe_unused
913 gpio_keys_enable_wakeup(struct gpio_keys_drvdata *ddata)
914 {
915 	struct gpio_button_data *bdata;
916 	int error;
917 	int i;
918 
919 	for (i = 0; i < ddata->pdata->nbuttons; i++) {
920 		bdata = &ddata->data[i];
921 		if (bdata->button->wakeup) {
922 			error = gpio_keys_button_enable_wakeup(bdata);
923 			if (error)
924 				goto err_out;
925 		}
926 		bdata->suspended = true;
927 	}
928 
929 	return 0;
930 
931 err_out:
932 	while (i--) {
933 		bdata = &ddata->data[i];
934 		if (bdata->button->wakeup)
935 			gpio_keys_button_disable_wakeup(bdata);
936 		bdata->suspended = false;
937 	}
938 
939 	return error;
940 }
941 
942 static void __maybe_unused
943 gpio_keys_disable_wakeup(struct gpio_keys_drvdata *ddata)
944 {
945 	struct gpio_button_data *bdata;
946 	int i;
947 
948 	for (i = 0; i < ddata->pdata->nbuttons; i++) {
949 		bdata = &ddata->data[i];
950 		bdata->suspended = false;
951 		if (irqd_is_wakeup_set(irq_get_irq_data(bdata->irq)))
952 			gpio_keys_button_disable_wakeup(bdata);
953 	}
954 }
955 
956 static int __maybe_unused gpio_keys_suspend(struct device *dev)
957 {
958 	struct gpio_keys_drvdata *ddata = dev_get_drvdata(dev);
959 	struct input_dev *input = ddata->input;
960 	int error;
961 
962 	if (device_may_wakeup(dev)) {
963 		error = gpio_keys_enable_wakeup(ddata);
964 		if (error)
965 			return error;
966 	} else {
967 		mutex_lock(&input->mutex);
968 		if (input_device_enabled(input))
969 			gpio_keys_close(input);
970 		mutex_unlock(&input->mutex);
971 	}
972 
973 	return 0;
974 }
975 
976 static int __maybe_unused gpio_keys_resume(struct device *dev)
977 {
978 	struct gpio_keys_drvdata *ddata = dev_get_drvdata(dev);
979 	struct input_dev *input = ddata->input;
980 	int error = 0;
981 
982 	if (device_may_wakeup(dev)) {
983 		gpio_keys_disable_wakeup(ddata);
984 	} else {
985 		mutex_lock(&input->mutex);
986 		if (input_device_enabled(input))
987 			error = gpio_keys_open(input);
988 		mutex_unlock(&input->mutex);
989 	}
990 
991 	if (error)
992 		return error;
993 
994 	gpio_keys_report_state(ddata);
995 	return 0;
996 }
997 
998 static SIMPLE_DEV_PM_OPS(gpio_keys_pm_ops, gpio_keys_suspend, gpio_keys_resume);
999 
1000 static void gpio_keys_shutdown(struct platform_device *pdev)
1001 {
1002 	int ret;
1003 
1004 	ret = gpio_keys_suspend(&pdev->dev);
1005 	if (ret)
1006 		dev_err(&pdev->dev, "failed to shutdown\n");
1007 }
1008 
1009 static struct platform_driver gpio_keys_device_driver = {
1010 	.probe		= gpio_keys_probe,
1011 	.shutdown	= gpio_keys_shutdown,
1012 	.driver		= {
1013 		.name	= "gpio-keys",
1014 		.pm	= &gpio_keys_pm_ops,
1015 		.of_match_table = gpio_keys_of_match,
1016 		.dev_groups	= gpio_keys_groups,
1017 	}
1018 };
1019 
1020 static int __init gpio_keys_init(void)
1021 {
1022 	return platform_driver_register(&gpio_keys_device_driver);
1023 }
1024 
1025 static void __exit gpio_keys_exit(void)
1026 {
1027 	platform_driver_unregister(&gpio_keys_device_driver);
1028 }
1029 
1030 late_initcall(gpio_keys_init);
1031 module_exit(gpio_keys_exit);
1032 
1033 MODULE_LICENSE("GPL");
1034 MODULE_AUTHOR("Phil Blundell <pb@handhelds.org>");
1035 MODULE_DESCRIPTION("Keyboard driver for GPIOs");
1036 MODULE_ALIAS("platform:gpio-keys");
1037