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[0];
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  * @input: 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_get_gpiod_from_child(dev, NULL,
498 								child,
499 								GPIOD_IN,
500 								desc);
501 		if (IS_ERR(bdata->gpiod)) {
502 			error = PTR_ERR(bdata->gpiod);
503 			if (error == -ENOENT) {
504 				/*
505 				 * GPIO is optional, we may be dealing with
506 				 * purely interrupt-driven setup.
507 				 */
508 				bdata->gpiod = NULL;
509 			} else {
510 				if (error != -EPROBE_DEFER)
511 					dev_err(dev, "failed to get gpio: %d\n",
512 						error);
513 				return error;
514 			}
515 		}
516 	} else if (gpio_is_valid(button->gpio)) {
517 		/*
518 		 * Legacy GPIO number, so request the GPIO here and
519 		 * convert it to descriptor.
520 		 */
521 		unsigned flags = GPIOF_IN;
522 
523 		if (button->active_low)
524 			flags |= GPIOF_ACTIVE_LOW;
525 
526 		error = devm_gpio_request_one(dev, button->gpio, flags, desc);
527 		if (error < 0) {
528 			dev_err(dev, "Failed to request GPIO %d, error %d\n",
529 				button->gpio, error);
530 			return error;
531 		}
532 
533 		bdata->gpiod = gpio_to_desc(button->gpio);
534 		if (!bdata->gpiod)
535 			return -EINVAL;
536 	}
537 
538 	if (bdata->gpiod) {
539 		bool active_low = gpiod_is_active_low(bdata->gpiod);
540 
541 		if (button->debounce_interval) {
542 			error = gpiod_set_debounce(bdata->gpiod,
543 					button->debounce_interval * 1000);
544 			/* use timer if gpiolib doesn't provide debounce */
545 			if (error < 0)
546 				bdata->software_debounce =
547 						button->debounce_interval;
548 		}
549 
550 		if (button->irq) {
551 			bdata->irq = button->irq;
552 		} else {
553 			irq = gpiod_to_irq(bdata->gpiod);
554 			if (irq < 0) {
555 				error = irq;
556 				dev_err(dev,
557 					"Unable to get irq number for GPIO %d, error %d\n",
558 					button->gpio, error);
559 				return error;
560 			}
561 			bdata->irq = irq;
562 		}
563 
564 		INIT_DELAYED_WORK(&bdata->work, gpio_keys_gpio_work_func);
565 
566 		isr = gpio_keys_gpio_isr;
567 		irqflags = IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING;
568 
569 		switch (button->wakeup_event_action) {
570 		case EV_ACT_ASSERTED:
571 			bdata->wakeup_trigger_type = active_low ?
572 				IRQ_TYPE_EDGE_FALLING : IRQ_TYPE_EDGE_RISING;
573 			break;
574 		case EV_ACT_DEASSERTED:
575 			bdata->wakeup_trigger_type = active_low ?
576 				IRQ_TYPE_EDGE_RISING : IRQ_TYPE_EDGE_FALLING;
577 			break;
578 		case EV_ACT_ANY:
579 			/* fall through */
580 		default:
581 			/*
582 			 * For other cases, we are OK letting suspend/resume
583 			 * not reconfigure the trigger type.
584 			 */
585 			break;
586 		}
587 	} else {
588 		if (!button->irq) {
589 			dev_err(dev, "Found button without gpio or irq\n");
590 			return -EINVAL;
591 		}
592 
593 		bdata->irq = button->irq;
594 
595 		if (button->type && button->type != EV_KEY) {
596 			dev_err(dev, "Only EV_KEY allowed for IRQ buttons.\n");
597 			return -EINVAL;
598 		}
599 
600 		bdata->release_delay = button->debounce_interval;
601 		timer_setup(&bdata->release_timer, gpio_keys_irq_timer, 0);
602 
603 		isr = gpio_keys_irq_isr;
604 		irqflags = 0;
605 
606 		/*
607 		 * For IRQ buttons, there is no interrupt for release.
608 		 * So we don't need to reconfigure the trigger type for wakeup.
609 		 */
610 	}
611 
612 	bdata->code = &ddata->keymap[idx];
613 	*bdata->code = button->code;
614 	input_set_capability(input, button->type ?: EV_KEY, *bdata->code);
615 
616 	/*
617 	 * Install custom action to cancel release timer and
618 	 * workqueue item.
619 	 */
620 	error = devm_add_action(dev, gpio_keys_quiesce_key, bdata);
621 	if (error) {
622 		dev_err(dev, "failed to register quiesce action, error: %d\n",
623 			error);
624 		return error;
625 	}
626 
627 	/*
628 	 * If platform has specified that the button can be disabled,
629 	 * we don't want it to share the interrupt line.
630 	 */
631 	if (!button->can_disable)
632 		irqflags |= IRQF_SHARED;
633 
634 	error = devm_request_any_context_irq(dev, bdata->irq, isr, irqflags,
635 					     desc, bdata);
636 	if (error < 0) {
637 		dev_err(dev, "Unable to claim irq %d; error %d\n",
638 			bdata->irq, error);
639 		return error;
640 	}
641 
642 	return 0;
643 }
644 
645 static void gpio_keys_report_state(struct gpio_keys_drvdata *ddata)
646 {
647 	struct input_dev *input = ddata->input;
648 	int i;
649 
650 	for (i = 0; i < ddata->pdata->nbuttons; i++) {
651 		struct gpio_button_data *bdata = &ddata->data[i];
652 		if (bdata->gpiod)
653 			gpio_keys_gpio_report_event(bdata);
654 	}
655 	input_sync(input);
656 }
657 
658 static int gpio_keys_open(struct input_dev *input)
659 {
660 	struct gpio_keys_drvdata *ddata = input_get_drvdata(input);
661 	const struct gpio_keys_platform_data *pdata = ddata->pdata;
662 	int error;
663 
664 	if (pdata->enable) {
665 		error = pdata->enable(input->dev.parent);
666 		if (error)
667 			return error;
668 	}
669 
670 	/* Report current state of buttons that are connected to GPIOs */
671 	gpio_keys_report_state(ddata);
672 
673 	return 0;
674 }
675 
676 static void gpio_keys_close(struct input_dev *input)
677 {
678 	struct gpio_keys_drvdata *ddata = input_get_drvdata(input);
679 	const struct gpio_keys_platform_data *pdata = ddata->pdata;
680 
681 	if (pdata->disable)
682 		pdata->disable(input->dev.parent);
683 }
684 
685 /*
686  * Handlers for alternative sources of platform_data
687  */
688 
689 /*
690  * Translate properties into platform_data
691  */
692 static struct gpio_keys_platform_data *
693 gpio_keys_get_devtree_pdata(struct device *dev)
694 {
695 	struct gpio_keys_platform_data *pdata;
696 	struct gpio_keys_button *button;
697 	struct fwnode_handle *child;
698 	int nbuttons;
699 
700 	nbuttons = device_get_child_node_count(dev);
701 	if (nbuttons == 0)
702 		return ERR_PTR(-ENODEV);
703 
704 	pdata = devm_kzalloc(dev,
705 			     sizeof(*pdata) + nbuttons * sizeof(*button),
706 			     GFP_KERNEL);
707 	if (!pdata)
708 		return ERR_PTR(-ENOMEM);
709 
710 	button = (struct gpio_keys_button *)(pdata + 1);
711 
712 	pdata->buttons = button;
713 	pdata->nbuttons = nbuttons;
714 
715 	pdata->rep = device_property_read_bool(dev, "autorepeat");
716 
717 	device_property_read_string(dev, "label", &pdata->name);
718 
719 	device_for_each_child_node(dev, child) {
720 		if (is_of_node(child))
721 			button->irq =
722 				irq_of_parse_and_map(to_of_node(child), 0);
723 
724 		if (fwnode_property_read_u32(child, "linux,code",
725 					     &button->code)) {
726 			dev_err(dev, "Button without keycode\n");
727 			fwnode_handle_put(child);
728 			return ERR_PTR(-EINVAL);
729 		}
730 
731 		fwnode_property_read_string(child, "label", &button->desc);
732 
733 		if (fwnode_property_read_u32(child, "linux,input-type",
734 					     &button->type))
735 			button->type = EV_KEY;
736 
737 		button->wakeup =
738 			fwnode_property_read_bool(child, "wakeup-source") ||
739 			/* legacy name */
740 			fwnode_property_read_bool(child, "gpio-key,wakeup");
741 
742 		fwnode_property_read_u32(child, "wakeup-event-action",
743 					 &button->wakeup_event_action);
744 
745 		button->can_disable =
746 			fwnode_property_read_bool(child, "linux,can-disable");
747 
748 		if (fwnode_property_read_u32(child, "debounce-interval",
749 					 &button->debounce_interval))
750 			button->debounce_interval = 5;
751 
752 		button++;
753 	}
754 
755 	return pdata;
756 }
757 
758 static const struct of_device_id gpio_keys_of_match[] = {
759 	{ .compatible = "gpio-keys", },
760 	{ },
761 };
762 MODULE_DEVICE_TABLE(of, gpio_keys_of_match);
763 
764 static int gpio_keys_probe(struct platform_device *pdev)
765 {
766 	struct device *dev = &pdev->dev;
767 	const struct gpio_keys_platform_data *pdata = dev_get_platdata(dev);
768 	struct fwnode_handle *child = NULL;
769 	struct gpio_keys_drvdata *ddata;
770 	struct input_dev *input;
771 	int i, error;
772 	int wakeup = 0;
773 
774 	if (!pdata) {
775 		pdata = gpio_keys_get_devtree_pdata(dev);
776 		if (IS_ERR(pdata))
777 			return PTR_ERR(pdata);
778 	}
779 
780 	ddata = devm_kzalloc(dev, struct_size(ddata, data, pdata->nbuttons),
781 			     GFP_KERNEL);
782 	if (!ddata) {
783 		dev_err(dev, "failed to allocate state\n");
784 		return -ENOMEM;
785 	}
786 
787 	ddata->keymap = devm_kcalloc(dev,
788 				     pdata->nbuttons, sizeof(ddata->keymap[0]),
789 				     GFP_KERNEL);
790 	if (!ddata->keymap)
791 		return -ENOMEM;
792 
793 	input = devm_input_allocate_device(dev);
794 	if (!input) {
795 		dev_err(dev, "failed to allocate input device\n");
796 		return -ENOMEM;
797 	}
798 
799 	ddata->pdata = pdata;
800 	ddata->input = input;
801 	mutex_init(&ddata->disable_lock);
802 
803 	platform_set_drvdata(pdev, ddata);
804 	input_set_drvdata(input, ddata);
805 
806 	input->name = pdata->name ? : pdev->name;
807 	input->phys = "gpio-keys/input0";
808 	input->dev.parent = dev;
809 	input->open = gpio_keys_open;
810 	input->close = gpio_keys_close;
811 
812 	input->id.bustype = BUS_HOST;
813 	input->id.vendor = 0x0001;
814 	input->id.product = 0x0001;
815 	input->id.version = 0x0100;
816 
817 	input->keycode = ddata->keymap;
818 	input->keycodesize = sizeof(ddata->keymap[0]);
819 	input->keycodemax = pdata->nbuttons;
820 
821 	/* Enable auto repeat feature of Linux input subsystem */
822 	if (pdata->rep)
823 		__set_bit(EV_REP, input->evbit);
824 
825 	for (i = 0; i < pdata->nbuttons; i++) {
826 		const struct gpio_keys_button *button = &pdata->buttons[i];
827 
828 		if (!dev_get_platdata(dev)) {
829 			child = device_get_next_child_node(dev, child);
830 			if (!child) {
831 				dev_err(dev,
832 					"missing child device node for entry %d\n",
833 					i);
834 				return -EINVAL;
835 			}
836 		}
837 
838 		error = gpio_keys_setup_key(pdev, input, ddata,
839 					    button, i, child);
840 		if (error) {
841 			fwnode_handle_put(child);
842 			return error;
843 		}
844 
845 		if (button->wakeup)
846 			wakeup = 1;
847 	}
848 
849 	fwnode_handle_put(child);
850 
851 	error = input_register_device(input);
852 	if (error) {
853 		dev_err(dev, "Unable to register input device, error: %d\n",
854 			error);
855 		return error;
856 	}
857 
858 	device_init_wakeup(dev, wakeup);
859 
860 	return 0;
861 }
862 
863 static int __maybe_unused
864 gpio_keys_button_enable_wakeup(struct gpio_button_data *bdata)
865 {
866 	int error;
867 
868 	error = enable_irq_wake(bdata->irq);
869 	if (error) {
870 		dev_err(bdata->input->dev.parent,
871 			"failed to configure IRQ %d as wakeup source: %d\n",
872 			bdata->irq, error);
873 		return error;
874 	}
875 
876 	if (bdata->wakeup_trigger_type) {
877 		error = irq_set_irq_type(bdata->irq,
878 					 bdata->wakeup_trigger_type);
879 		if (error) {
880 			dev_err(bdata->input->dev.parent,
881 				"failed to set wakeup trigger %08x for IRQ %d: %d\n",
882 				bdata->wakeup_trigger_type, bdata->irq, error);
883 			disable_irq_wake(bdata->irq);
884 			return error;
885 		}
886 	}
887 
888 	return 0;
889 }
890 
891 static void __maybe_unused
892 gpio_keys_button_disable_wakeup(struct gpio_button_data *bdata)
893 {
894 	int error;
895 
896 	/*
897 	 * The trigger type is always both edges for gpio-based keys and we do
898 	 * not support changing wakeup trigger for interrupt-based keys.
899 	 */
900 	if (bdata->wakeup_trigger_type) {
901 		error = irq_set_irq_type(bdata->irq, IRQ_TYPE_EDGE_BOTH);
902 		if (error)
903 			dev_warn(bdata->input->dev.parent,
904 				 "failed to restore interrupt trigger for IRQ %d: %d\n",
905 				 bdata->irq, error);
906 	}
907 
908 	error = disable_irq_wake(bdata->irq);
909 	if (error)
910 		dev_warn(bdata->input->dev.parent,
911 			 "failed to disable IRQ %d as wake source: %d\n",
912 			 bdata->irq, error);
913 }
914 
915 static int __maybe_unused
916 gpio_keys_enable_wakeup(struct gpio_keys_drvdata *ddata)
917 {
918 	struct gpio_button_data *bdata;
919 	int error;
920 	int i;
921 
922 	for (i = 0; i < ddata->pdata->nbuttons; i++) {
923 		bdata = &ddata->data[i];
924 		if (bdata->button->wakeup) {
925 			error = gpio_keys_button_enable_wakeup(bdata);
926 			if (error)
927 				goto err_out;
928 		}
929 		bdata->suspended = true;
930 	}
931 
932 	return 0;
933 
934 err_out:
935 	while (i--) {
936 		bdata = &ddata->data[i];
937 		if (bdata->button->wakeup)
938 			gpio_keys_button_disable_wakeup(bdata);
939 		bdata->suspended = false;
940 	}
941 
942 	return error;
943 }
944 
945 static void __maybe_unused
946 gpio_keys_disable_wakeup(struct gpio_keys_drvdata *ddata)
947 {
948 	struct gpio_button_data *bdata;
949 	int i;
950 
951 	for (i = 0; i < ddata->pdata->nbuttons; i++) {
952 		bdata = &ddata->data[i];
953 		bdata->suspended = false;
954 		if (irqd_is_wakeup_set(irq_get_irq_data(bdata->irq)))
955 			gpio_keys_button_disable_wakeup(bdata);
956 	}
957 }
958 
959 static int __maybe_unused gpio_keys_suspend(struct device *dev)
960 {
961 	struct gpio_keys_drvdata *ddata = dev_get_drvdata(dev);
962 	struct input_dev *input = ddata->input;
963 	int error;
964 
965 	if (device_may_wakeup(dev)) {
966 		error = gpio_keys_enable_wakeup(ddata);
967 		if (error)
968 			return error;
969 	} else {
970 		mutex_lock(&input->mutex);
971 		if (input->users)
972 			gpio_keys_close(input);
973 		mutex_unlock(&input->mutex);
974 	}
975 
976 	return 0;
977 }
978 
979 static int __maybe_unused gpio_keys_resume(struct device *dev)
980 {
981 	struct gpio_keys_drvdata *ddata = dev_get_drvdata(dev);
982 	struct input_dev *input = ddata->input;
983 	int error = 0;
984 
985 	if (device_may_wakeup(dev)) {
986 		gpio_keys_disable_wakeup(ddata);
987 	} else {
988 		mutex_lock(&input->mutex);
989 		if (input->users)
990 			error = gpio_keys_open(input);
991 		mutex_unlock(&input->mutex);
992 	}
993 
994 	if (error)
995 		return error;
996 
997 	gpio_keys_report_state(ddata);
998 	return 0;
999 }
1000 
1001 static SIMPLE_DEV_PM_OPS(gpio_keys_pm_ops, gpio_keys_suspend, gpio_keys_resume);
1002 
1003 static void gpio_keys_shutdown(struct platform_device *pdev)
1004 {
1005 	int ret;
1006 
1007 	ret = gpio_keys_suspend(&pdev->dev);
1008 	if (ret)
1009 		dev_err(&pdev->dev, "failed to shutdown\n");
1010 }
1011 
1012 static struct platform_driver gpio_keys_device_driver = {
1013 	.probe		= gpio_keys_probe,
1014 	.shutdown	= gpio_keys_shutdown,
1015 	.driver		= {
1016 		.name	= "gpio-keys",
1017 		.pm	= &gpio_keys_pm_ops,
1018 		.of_match_table = gpio_keys_of_match,
1019 		.dev_groups	= gpio_keys_groups,
1020 	}
1021 };
1022 
1023 static int __init gpio_keys_init(void)
1024 {
1025 	return platform_driver_register(&gpio_keys_device_driver);
1026 }
1027 
1028 static void __exit gpio_keys_exit(void)
1029 {
1030 	platform_driver_unregister(&gpio_keys_device_driver);
1031 }
1032 
1033 late_initcall(gpio_keys_init);
1034 module_exit(gpio_keys_exit);
1035 
1036 MODULE_LICENSE("GPL");
1037 MODULE_AUTHOR("Phil Blundell <pb@handhelds.org>");
1038 MODULE_DESCRIPTION("Keyboard driver for GPIOs");
1039 MODULE_ALIAS("platform:gpio-keys");
1040