PageRenderTime 96ms CodeModel.GetById 12ms app.highlight 75ms RepoModel.GetById 1ms app.codeStats 1ms

/drivers/input/keyboard/gpio_keys.c

http://github.com/mirrors/linux
C | 1037 lines | 708 code | 167 blank | 162 comment | 121 complexity | 3dca9ff35b4bab728e4f2ad3d957ac19 MD5 | raw file
   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
  32struct 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
  53struct 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 */
 102static 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 */
 117static 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 */
 138static 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 */
 165static 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 */
 187static 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 */
 231static 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
 283out:
 284	bitmap_free(bits);
 285	return error;
 286}
 287
 288#define ATTR_SHOW_FN(name, type, only_disabled)				\
 289static 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
 300ATTR_SHOW_FN(keys, EV_KEY, false);
 301ATTR_SHOW_FN(switches, EV_SW, false);
 302ATTR_SHOW_FN(disabled_keys, EV_KEY, true);
 303ATTR_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 */
 311static DEVICE_ATTR(keys, S_IRUGO, gpio_keys_show_keys, NULL);
 312static DEVICE_ATTR(switches, S_IRUGO, gpio_keys_show_switches, NULL);
 313
 314#define ATTR_STORE_FN(name, type)					\
 315static 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
 331ATTR_STORE_FN(disabled_keys, EV_KEY);
 332ATTR_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 */
 340static DEVICE_ATTR(disabled_keys, S_IWUSR | S_IRUGO,
 341		   gpio_keys_show_disabled_keys,
 342		   gpio_keys_store_disabled_keys);
 343static DEVICE_ATTR(disabled_switches, S_IWUSR | S_IRUGO,
 344		   gpio_keys_show_disabled_switches,
 345		   gpio_keys_store_disabled_switches);
 346
 347static 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};
 354ATTRIBUTE_GROUPS(gpio_keys);
 355
 356static 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
 379static 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
 390static 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
 418static 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
 433static 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));
 462out:
 463	spin_unlock_irqrestore(&bdata->lock, flags);
 464	return IRQ_HANDLED;
 465}
 466
 467static 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
 477static 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
 643static 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
 656static 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
 674static 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 */
 690static struct gpio_keys_platform_data *
 691gpio_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
 756static const struct of_device_id gpio_keys_of_match[] = {
 757	{ .compatible = "gpio-keys", },
 758	{ },
 759};
 760MODULE_DEVICE_TABLE(of, gpio_keys_of_match);
 761
 762static 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
 861static int __maybe_unused
 862gpio_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
 889static void __maybe_unused
 890gpio_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
 913static int __maybe_unused
 914gpio_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
 932err_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
 943static void __maybe_unused
 944gpio_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
 957static 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
 977static 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
 999static SIMPLE_DEV_PM_OPS(gpio_keys_pm_ops, gpio_keys_suspend, gpio_keys_resume);
1000
1001static 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
1010static 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
1021static int __init gpio_keys_init(void)
1022{
1023	return platform_driver_register(&gpio_keys_device_driver);
1024}
1025
1026static void __exit gpio_keys_exit(void)
1027{
1028	platform_driver_unregister(&gpio_keys_device_driver);
1029}
1030
1031late_initcall(gpio_keys_init);
1032module_exit(gpio_keys_exit);
1033
1034MODULE_LICENSE("GPL");
1035MODULE_AUTHOR("Phil Blundell <pb@handhelds.org>");
1036MODULE_DESCRIPTION("Keyboard driver for GPIOs");
1037MODULE_ALIAS("platform:gpio-keys");