Linux Audio

Check our new training course

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