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