[net-next-2.6.git] / drivers / staging / dream / gpio_matrix.c

/* drivers/input/misc/gpio_matrix.c
 *
 * Copyright (C) 2007 Google, Inc.
 *
 * This software is licensed under the terms of the GNU General Public
 * License version 2, as published by the Free Software Foundation, and
 * may be copied, distributed, and modified under those terms.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 */

#include <linux/kernel.h>
#include <linux/slab.h>
#include <linux/gpio.h>
#include <linux/gpio_event.h>
#include <linux/hrtimer.h>
#include <linux/interrupt.h>

struct gpio_kp {
	struct input_dev *input_dev;
	struct gpio_event_matrix_info *keypad_info;
	struct hrtimer timer;
	int current_output;
	unsigned int use_irq:1;
	unsigned int key_state_changed:1;
	unsigned int last_key_state_changed:1;
	unsigned int some_keys_pressed:2;
	unsigned long keys_pressed[0];
};

static void clear_phantom_key(struct gpio_kp *kp, int out, int in)
{
	struct gpio_event_matrix_info *mi = kp->keypad_info;
	int key_index = out * mi->ninputs + in;
	unsigned short keycode = mi->keymap[key_index];;

	if (!test_bit(keycode, kp->input_dev->key)) {
		if (mi->flags & GPIOKPF_PRINT_PHANTOM_KEYS)
			pr_info("gpiomatrix: phantom key %x, %d-%d (%d-%d) "
				"cleared\n", keycode, out, in,
				mi->output_gpios[out], mi->input_gpios[in]);
		__clear_bit(key_index, kp->keys_pressed);
	} else {
		if (mi->flags & GPIOKPF_PRINT_PHANTOM_KEYS)
			pr_info("gpiomatrix: phantom key %x, %d-%d (%d-%d) "
				"not cleared\n", keycode, out, in,
				mi->output_gpios[out], mi->input_gpios[in]);
	}
}

static int restore_keys_for_input(struct gpio_kp *kp, int out, int in)
{
	int rv = 0;
	int key_index;

	key_index = out * kp->keypad_info->ninputs + in;
	while (out < kp->keypad_info->noutputs) {
		if (test_bit(key_index, kp->keys_pressed)) {
			rv = 1;
			clear_phantom_key(kp, out, in);
		}
		key_index += kp->keypad_info->ninputs;
		out++;
	}
	return rv;
}

static void remove_phantom_keys(struct gpio_kp *kp)
{
	int out, in, inp;
	int key_index;

	if (kp->some_keys_pressed < 3)
		return;

	for (out = 0; out < kp->keypad_info->noutputs; out++) {
		inp = -1;
		key_index = out * kp->keypad_info->ninputs;
		for (in = 0; in < kp->keypad_info->ninputs; in++, key_index++) {
			if (test_bit(key_index, kp->keys_pressed)) {
				if (inp == -1) {
					inp = in;
					continue;
				}
				if (inp >= 0) {
					if (!restore_keys_for_input(kp, out + 1,
									inp))
						break;
					clear_phantom_key(kp, out, inp);
					inp = -2;
				}
				restore_keys_for_input(kp, out, in);
			}
		}
	}
}

static void report_key(struct gpio_kp *kp, int key_index, int out, int in)
{
	struct gpio_event_matrix_info *mi = kp->keypad_info;
	int pressed = test_bit(key_index, kp->keys_pressed);
	unsigned short keycode = mi->keymap[key_index];
	if (pressed != test_bit(keycode, kp->input_dev->key)) {
		if (keycode == KEY_RESERVED) {
			if (mi->flags & GPIOKPF_PRINT_UNMAPPED_KEYS)
				pr_info("gpiomatrix: unmapped key, %d-%d "
					"(%d-%d) changed to %d\n",
					out, in, mi->output_gpios[out],
					mi->input_gpios[in], pressed);
		} else {
			if (mi->flags & GPIOKPF_PRINT_MAPPED_KEYS)
				pr_info("gpiomatrix: key %x, %d-%d (%d-%d) "
					"changed to %d\n", keycode,
					out, in, mi->output_gpios[out],
					mi->input_gpios[in], pressed);
			input_report_key(kp->input_dev, keycode, pressed);
		}
	}
}

static enum hrtimer_restart gpio_keypad_timer_func(struct hrtimer *timer)
{
	int out, in;
	int key_index;
	int gpio;
	struct gpio_kp *kp = container_of(timer, struct gpio_kp, timer);
	struct gpio_event_matrix_info *mi = kp->keypad_info;
	unsigned gpio_keypad_flags = mi->flags;
	unsigned polarity = !!(gpio_keypad_flags & GPIOKPF_ACTIVE_HIGH);

	out = kp->current_output;
	if (out == mi->noutputs) {
		out = 0;
		kp->last_key_state_changed = kp->key_state_changed;
		kp->key_state_changed = 0;
		kp->some_keys_pressed = 0;
	} else {
		key_index = out * mi->ninputs;
		for (in = 0; in < mi->ninputs; in++, key_index++) {
			gpio = mi->input_gpios[in];
			if (gpio_get_value(gpio) ^ !polarity) {
				if (kp->some_keys_pressed < 3)
					kp->some_keys_pressed++;
				kp->key_state_changed |= !__test_and_set_bit(
						key_index, kp->keys_pressed);
			} else
				kp->key_state_changed |= __test_and_clear_bit(
						key_index, kp->keys_pressed);
		}
		gpio = mi->output_gpios[out];
		if (gpio_keypad_flags & GPIOKPF_DRIVE_INACTIVE)
			gpio_set_value(gpio, !polarity);
		else
			gpio_direction_input(gpio);
		out++;
	}
	kp->current_output = out;
	if (out < mi->noutputs) {
		gpio = mi->output_gpios[out];
		if (gpio_keypad_flags & GPIOKPF_DRIVE_INACTIVE)
			gpio_set_value(gpio, polarity);
		else
			gpio_direction_output(gpio, polarity);
		hrtimer_start(timer, mi->settle_time, HRTIMER_MODE_REL);
		return HRTIMER_NORESTART;
	}
	if (gpio_keypad_flags & GPIOKPF_DEBOUNCE) {
		if (kp->key_state_changed) {
			hrtimer_start(&kp->timer, mi->debounce_delay,
				      HRTIMER_MODE_REL);
			return HRTIMER_NORESTART;
		}
		kp->key_state_changed = kp->last_key_state_changed;
	}
	if (kp->key_state_changed) {
		if (gpio_keypad_flags & GPIOKPF_REMOVE_SOME_PHANTOM_KEYS)
			remove_phantom_keys(kp);
		key_index = 0;
		for (out = 0; out < mi->noutputs; out++)
			for (in = 0; in < mi->ninputs; in++, key_index++)
				report_key(kp, key_index, out, in);
	}
	if (!kp->use_irq || kp->some_keys_pressed) {
		hrtimer_start(timer, mi->poll_time, HRTIMER_MODE_REL);
		return HRTIMER_NORESTART;
	}

	/* No keys are pressed, reenable interrupt */
	for (out = 0; out < mi->noutputs; out++) {
		if (gpio_keypad_flags & GPIOKPF_DRIVE_INACTIVE)
			gpio_set_value(mi->output_gpios[out], polarity);
		else
			gpio_direction_output(mi->output_gpios[out], polarity);
	}
	for (in = 0; in < mi->ninputs; in++)
		enable_irq(gpio_to_irq(mi->input_gpios[in]));
	return HRTIMER_NORESTART;
}

static irqreturn_t gpio_keypad_irq_handler(int irq_in, void *dev_id)
{
	int i;
	struct gpio_kp *kp = dev_id;
	struct gpio_event_matrix_info *mi = kp->keypad_info;
	unsigned gpio_keypad_flags = mi->flags;

	if (!kp->use_irq) /* ignore interrupt while registering the handler */
		return IRQ_HANDLED;

	for (i = 0; i < mi->ninputs; i++)
		disable_irq(gpio_to_irq(mi->input_gpios[i]));
	for (i = 0; i < mi->noutputs; i++) {
		if (gpio_keypad_flags & GPIOKPF_DRIVE_INACTIVE)
			gpio_set_value(mi->output_gpios[i],
				!(gpio_keypad_flags & GPIOKPF_ACTIVE_HIGH));
		else
			gpio_direction_input(mi->output_gpios[i]);
	}
	hrtimer_start(&kp->timer, ktime_set(0, 0), HRTIMER_MODE_REL);
	return IRQ_HANDLED;
}

static int gpio_keypad_request_irqs(struct gpio_kp *kp)
{
	int i;
	int err;
	unsigned int irq;
	unsigned long request_flags;
	struct gpio_event_matrix_info *mi = kp->keypad_info;

	switch (mi->flags & (GPIOKPF_ACTIVE_HIGH|GPIOKPF_LEVEL_TRIGGERED_IRQ)) {
	default:
		request_flags = IRQF_TRIGGER_FALLING;
		break;
	case GPIOKPF_ACTIVE_HIGH:
		request_flags = IRQF_TRIGGER_RISING;
		break;
	case GPIOKPF_LEVEL_TRIGGERED_IRQ:
		request_flags = IRQF_TRIGGER_LOW;
		break;
	case GPIOKPF_LEVEL_TRIGGERED_IRQ | GPIOKPF_ACTIVE_HIGH:
		request_flags = IRQF_TRIGGER_HIGH;
		break;
	}

	for (i = 0; i < mi->ninputs; i++) {
		err = irq = gpio_to_irq(mi->input_gpios[i]);
		if (err < 0)
			goto err_gpio_get_irq_num_failed;
		err = request_irq(irq, gpio_keypad_irq_handler, request_flags,
				  "gpio_kp", kp);
		if (err) {
			pr_err("gpiomatrix: request_irq failed for input %d, "
				"irq %d\n", mi->input_gpios[i], irq);
			goto err_request_irq_failed;
		}
		err = set_irq_wake(irq, 1);
		if (err) {
			pr_err("gpiomatrix: set_irq_wake failed for input %d, "
				"irq %d\n", mi->input_gpios[i], irq);
		}
		disable_irq(irq);
	}
	return 0;

	for (i = mi->noutputs - 1; i >= 0; i--) {
		free_irq(gpio_to_irq(mi->input_gpios[i]), kp);
err_request_irq_failed:
err_gpio_get_irq_num_failed:
		;
	}
	return err;
}

int gpio_event_matrix_func(struct input_dev *input_dev,
	struct gpio_event_info *info, void **data, int func)
{
	int i;
	int err;
	int key_count;
	struct gpio_kp *kp;
	struct gpio_event_matrix_info *mi;

	mi = container_of(info, struct gpio_event_matrix_info, info);
	if (func == GPIO_EVENT_FUNC_SUSPEND || func == GPIO_EVENT_FUNC_RESUME) {
		/* TODO: disable scanning */
		return 0;
	}

	if (func == GPIO_EVENT_FUNC_INIT) {
		if (mi->keymap == NULL ||
		   mi->input_gpios == NULL ||
		   mi->output_gpios == NULL) {
			err = -ENODEV;
			pr_err("gpiomatrix: Incomplete pdata\n");
			goto err_invalid_platform_data;
		}
		key_count = mi->ninputs * mi->noutputs;

		*data = kp = kzalloc(sizeof(*kp) + sizeof(kp->keys_pressed[0]) *
				     BITS_TO_LONGS(key_count), GFP_KERNEL);
		if (kp == NULL) {
			err = -ENOMEM;
			pr_err("gpiomatrix: Failed to allocate private data\n");
			goto err_kp_alloc_failed;
		}
		kp->input_dev = input_dev;
		kp->keypad_info = mi;
		set_bit(EV_KEY, input_dev->evbit);
		for (i = 0; i < key_count; i++) {
			if (mi->keymap[i])
				set_bit(mi->keymap[i] & KEY_MAX,
					input_dev->keybit);
		}

		for (i = 0; i < mi->noutputs; i++) {
			if (gpio_cansleep(mi->output_gpios[i])) {
				pr_err("gpiomatrix: unsupported output gpio %d,"
					" can sleep\n", mi->output_gpios[i]);
				err = -EINVAL;
				goto err_request_output_gpio_failed;
			}
			err = gpio_request(mi->output_gpios[i], "gpio_kp_out");
			if (err) {
				pr_err("gpiomatrix: gpio_request failed for "
					"output %d\n", mi->output_gpios[i]);
				goto err_request_output_gpio_failed;
			}
			if (mi->flags & GPIOKPF_DRIVE_INACTIVE)
				err = gpio_direction_output(mi->output_gpios[i],
					!(mi->flags & GPIOKPF_ACTIVE_HIGH));
			else
				err = gpio_direction_input(mi->output_gpios[i]);
			if (err) {
				pr_err("gpiomatrix: gpio_configure failed for "
					"output %d\n", mi->output_gpios[i]);
				goto err_output_gpio_configure_failed;
			}
		}
		for (i = 0; i < mi->ninputs; i++) {
			err = gpio_request(mi->input_gpios[i], "gpio_kp_in");
			if (err) {
				pr_err("gpiomatrix: gpio_request failed for "
					"input %d\n", mi->input_gpios[i]);
				goto err_request_input_gpio_failed;
			}
			err = gpio_direction_input(mi->input_gpios[i]);
			if (err) {
				pr_err("gpiomatrix: gpio_direction_input failed"
					" for input %d\n", mi->input_gpios[i]);
				goto err_gpio_direction_input_failed;
			}
		}
		kp->current_output = mi->noutputs;
		kp->key_state_changed = 1;

		hrtimer_init(&kp->timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
		kp->timer.function = gpio_keypad_timer_func;
		err = gpio_keypad_request_irqs(kp);
		kp->use_irq = err == 0;

		pr_info("GPIO Matrix Keypad Driver: Start keypad matrix for %s "
			"in %s mode\n", input_dev->name,
			kp->use_irq ? "interrupt" : "polling");

		hrtimer_start(&kp->timer, ktime_set(0, 0), HRTIMER_MODE_REL);

		return 0;
	}

	err = 0;
	kp = *data;

	if (kp->use_irq)
		for (i = mi->noutputs - 1; i >= 0; i--)
			free_irq(gpio_to_irq(mi->input_gpios[i]), kp);

	hrtimer_cancel(&kp->timer);
	for (i = mi->noutputs - 1; i >= 0; i--) {
err_gpio_direction_input_failed:
		gpio_free(mi->input_gpios[i]);
err_request_input_gpio_failed:
		;
	}
	for (i = mi->noutputs - 1; i >= 0; i--) {
err_output_gpio_configure_failed:
		gpio_free(mi->output_gpios[i]);
err_request_output_gpio_failed:
		;
	}
	kfree(kp);
err_kp_alloc_failed:
err_invalid_platform_data:
	return err;
}
Commit	Line	Data
420818f9 AH	1	/* drivers/input/misc/gpio_matrix.c
	2	*
	3	* Copyright (C) 2007 Google, Inc.
	4	*
	5	* This software is licensed under the terms of the GNU General Public
	6	* License version 2, as published by the Free Software Foundation, and
	7	* may be copied, distributed, and modified under those terms.
	8	*
	9	* This program is distributed in the hope that it will be useful,
	10	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	11	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	12	* GNU General Public License for more details.
	13	*
	14	*/
	15
	16	#include <linux/kernel.h>
5a0e3ad6	17	#include <linux/slab.h>
420818f9 AH	18	#include <linux/gpio.h>
	19	#include <linux/gpio_event.h>
	20	#include <linux/hrtimer.h>
	21	#include <linux/interrupt.h>
420818f9 AH	22
	23	struct gpio_kp {
	24	struct input_dev *input_dev;
	25	struct gpio_event_matrix_info *keypad_info;
	26	struct hrtimer timer;
420818f9 AH	27	int current_output;
	28	unsigned int use_irq:1;
	29	unsigned int key_state_changed:1;
	30	unsigned int last_key_state_changed:1;
	31	unsigned int some_keys_pressed:2;
	32	unsigned long keys_pressed[0];
	33	};
	34
	35	static void clear_phantom_key(struct gpio_kp *kp, int out, int in)
	36	{
	37	struct gpio_event_matrix_info *mi = kp->keypad_info;
	38	int key_index = out * mi->ninputs + in;
	39	unsigned short keycode = mi->keymap[key_index];;
	40
	41	if (!test_bit(keycode, kp->input_dev->key)) {
	42	if (mi->flags & GPIOKPF_PRINT_PHANTOM_KEYS)
	43	pr_info("gpiomatrix: phantom key %x, %d-%d (%d-%d) "
	44	"cleared\n", keycode, out, in,
	45	mi->output_gpios[out], mi->input_gpios[in]);
	46	__clear_bit(key_index, kp->keys_pressed);
	47	} else {
	48	if (mi->flags & GPIOKPF_PRINT_PHANTOM_KEYS)
	49	pr_info("gpiomatrix: phantom key %x, %d-%d (%d-%d) "
	50	"not cleared\n", keycode, out, in,
	51	mi->output_gpios[out], mi->input_gpios[in]);
	52	}
	53	}
	54
	55	static int restore_keys_for_input(struct gpio_kp *kp, int out, int in)
	56	{
	57	int rv = 0;
	58	int key_index;
	59
	60	key_index = out * kp->keypad_info->ninputs + in;
	61	while (out < kp->keypad_info->noutputs) {
	62	if (test_bit(key_index, kp->keys_pressed)) {
	63	rv = 1;
	64	clear_phantom_key(kp, out, in);
	65	}
	66	key_index += kp->keypad_info->ninputs;
	67	out++;
	68	}
	69	return rv;
	70	}
	71
	72	static void remove_phantom_keys(struct gpio_kp *kp)
	73	{
	74	int out, in, inp;
	75	int key_index;
	76
	77	if (kp->some_keys_pressed < 3)
	78	return;
	79
	80	for (out = 0; out < kp->keypad_info->noutputs; out++) {
	81	inp = -1;
	82	key_index = out * kp->keypad_info->ninputs;
	83	for (in = 0; in < kp->keypad_info->ninputs; in++, key_index++) {
	84	if (test_bit(key_index, kp->keys_pressed)) {
	85	if (inp == -1) {
	86	inp = in;
	87	continue;
	88	}
	89	if (inp >= 0) {
	90	if (!restore_keys_for_input(kp, out + 1,
91	inp))
92	break;
93	clear_phantom_key(kp, out, inp);
94	inp = -2;
95	}
96	restore_keys_for_input(kp, out, in);
97	}
98	}
99	}
100	}
101
102	static void report_key(struct gpio_kp *kp, int key_index, int out, int in)
103	{
104	struct gpio_event_matrix_info *mi = kp->keypad_info;
105	int pressed = test_bit(key_index, kp->keys_pressed);
106	unsigned short keycode = mi->keymap[key_index];
107	if (pressed != test_bit(keycode, kp->input_dev->key)) {
108	if (keycode == KEY_RESERVED) {
109	if (mi->flags & GPIOKPF_PRINT_UNMAPPED_KEYS)
110	pr_info("gpiomatrix: unmapped key, %d-%d "
111	"(%d-%d) changed to %d\n",
112	out, in, mi->output_gpios[out],
113	mi->input_gpios[in], pressed);
114	} else {
115	if (mi->flags & GPIOKPF_PRINT_MAPPED_KEYS)
116	pr_info("gpiomatrix: key %x, %d-%d (%d-%d) "
117	"changed to %d\n", keycode,
118	out, in, mi->output_gpios[out],
119	mi->input_gpios[in], pressed);
120	input_report_key(kp->input_dev, keycode, pressed);
121	}
122	}
123	}
124
125	static enum hrtimer_restart gpio_keypad_timer_func(struct hrtimer *timer)
126	{
127	int out, in;
128	int key_index;
129	int gpio;
130	struct gpio_kp *kp = container_of(timer, struct gpio_kp, timer);
131	struct gpio_event_matrix_info *mi = kp->keypad_info;
132	unsigned gpio_keypad_flags = mi->flags;
133	unsigned polarity = !!(gpio_keypad_flags & GPIOKPF_ACTIVE_HIGH);
134
135	out = kp->current_output;
136	if (out == mi->noutputs) {
137	out = 0;
138	kp->last_key_state_changed = kp->key_state_changed;
139	kp->key_state_changed = 0;
140	kp->some_keys_pressed = 0;
141	} else {
142	key_index = out * mi->ninputs;
143	for (in = 0; in < mi->ninputs; in++, key_index++) {
144	gpio = mi->input_gpios[in];
145	if (gpio_get_value(gpio) ^ !polarity) {
146	if (kp->some_keys_pressed < 3)
147	kp->some_keys_pressed++;
148	kp->key_state_changed \|= !__test_and_set_bit(
149	key_index, kp->keys_pressed);
150	} else
151	kp->key_state_changed \|= __test_and_clear_bit(
152	key_index, kp->keys_pressed);
153	}
154	gpio = mi->output_gpios[out];
155	if (gpio_keypad_flags & GPIOKPF_DRIVE_INACTIVE)
156	gpio_set_value(gpio, !polarity);
157	else
158	gpio_direction_input(gpio);
159	out++;
160	}
161	kp->current_output = out;
162	if (out < mi->noutputs) {
163	gpio = mi->output_gpios[out];
164	if (gpio_keypad_flags & GPIOKPF_DRIVE_INACTIVE)
165	gpio_set_value(gpio, polarity);
166	else
167	gpio_direction_output(gpio, polarity);
168	hrtimer_start(timer, mi->settle_time, HRTIMER_MODE_REL);
169	return HRTIMER_NORESTART;
170	}
171	if (gpio_keypad_flags & GPIOKPF_DEBOUNCE) {
172	if (kp->key_state_changed) {
173	hrtimer_start(&kp->timer, mi->debounce_delay,
174	HRTIMER_MODE_REL);
175	return HRTIMER_NORESTART;
176	}
177	kp->key_state_changed = kp->last_key_state_changed;
178	}
179	if (kp->key_state_changed) {
180	if (gpio_keypad_flags & GPIOKPF_REMOVE_SOME_PHANTOM_KEYS)
181	remove_phantom_keys(kp);
182	key_index = 0;
183	for (out = 0; out < mi->noutputs; out++)
184	for (in = 0; in < mi->ninputs; in++, key_index++)
185	report_key(kp, key_index, out, in);
186	}
187	if (!kp->use_irq \|\| kp->some_keys_pressed) {
188	hrtimer_start(timer, mi->poll_time, HRTIMER_MODE_REL);
189	return HRTIMER_NORESTART;
190	}
191
192	/* No keys are pressed, reenable interrupt */
193	for (out = 0; out < mi->noutputs; out++) {
194	if (gpio_keypad_flags & GPIOKPF_DRIVE_INACTIVE)
195	gpio_set_value(mi->output_gpios[out], polarity);
196	else
197	gpio_direction_output(mi->output_gpios[out], polarity);
198	}
199	for (in = 0; in < mi->ninputs; in++)
200	enable_irq(gpio_to_irq(mi->input_gpios[in]));
420818f9 AH	201	return HRTIMER_NORESTART;
	202	}
	203
	204	static irqreturn_t gpio_keypad_irq_handler(int irq_in, void *dev_id)
	205	{
	206	int i;
	207	struct gpio_kp *kp = dev_id;
	208	struct gpio_event_matrix_info *mi = kp->keypad_info;
	209	unsigned gpio_keypad_flags = mi->flags;
	210
	211	if (!kp->use_irq) /* ignore interrupt while registering the handler */
	212	return IRQ_HANDLED;
	213
	214	for (i = 0; i < mi->ninputs; i++)
	215	disable_irq(gpio_to_irq(mi->input_gpios[i]));
	216	for (i = 0; i < mi->noutputs; i++) {
	217	if (gpio_keypad_flags & GPIOKPF_DRIVE_INACTIVE)
	218	gpio_set_value(mi->output_gpios[i],
	219	!(gpio_keypad_flags & GPIOKPF_ACTIVE_HIGH));
	220	else
	221	gpio_direction_input(mi->output_gpios[i]);
	222	}
420818f9 AH	223	hrtimer_start(&kp->timer, ktime_set(0, 0), HRTIMER_MODE_REL);
	224	return IRQ_HANDLED;
	225	}
	226
	227	static int gpio_keypad_request_irqs(struct gpio_kp *kp)
	228	{
	229	int i;
	230	int err;
	231	unsigned int irq;
	232	unsigned long request_flags;
	233	struct gpio_event_matrix_info *mi = kp->keypad_info;
	234
	235	switch (mi->flags & (GPIOKPF_ACTIVE_HIGH\|GPIOKPF_LEVEL_TRIGGERED_IRQ)) {
	236	default:
	237	request_flags = IRQF_TRIGGER_FALLING;
	238	break;
	239	case GPIOKPF_ACTIVE_HIGH:
	240	request_flags = IRQF_TRIGGER_RISING;
	241	break;
	242	case GPIOKPF_LEVEL_TRIGGERED_IRQ:
	243	request_flags = IRQF_TRIGGER_LOW;
	244	break;
	245	case GPIOKPF_LEVEL_TRIGGERED_IRQ \| GPIOKPF_ACTIVE_HIGH:
	246	request_flags = IRQF_TRIGGER_HIGH;
	247	break;
	248	}
	249
	250	for (i = 0; i < mi->ninputs; i++) {
	251	err = irq = gpio_to_irq(mi->input_gpios[i]);
	252	if (err < 0)
	253	goto err_gpio_get_irq_num_failed;
	254	err = request_irq(irq, gpio_keypad_irq_handler, request_flags,
	255	"gpio_kp", kp);
	256	if (err) {
	257	pr_err("gpiomatrix: request_irq failed for input %d, "
	258	"irq %d\n", mi->input_gpios[i], irq);
	259	goto err_request_irq_failed;
	260	}
	261	err = set_irq_wake(irq, 1);
	262	if (err) {
	263	pr_err("gpiomatrix: set_irq_wake failed for input %d, "
	264	"irq %d\n", mi->input_gpios[i], irq);
	265	}
	266	disable_irq(irq);
	267	}
	268	return 0;
	269
	270	for (i = mi->noutputs - 1; i >= 0; i--) {
	271	free_irq(gpio_to_irq(mi->input_gpios[i]), kp);
	272	err_request_irq_failed:
	273	err_gpio_get_irq_num_failed:
	274	;
	275	}
	276	return err;
	277	}
	278
	279	int gpio_event_matrix_func(struct input_dev *input_dev,
	280	struct gpio_event_info info, void *data, int func)
	281	{
	282	int i;
	283	int err;
	284	int key_count;
	285	struct gpio_kp *kp;
	286	struct gpio_event_matrix_info *mi;
287
288	mi = container_of(info, struct gpio_event_matrix_info, info);
289	if (func == GPIO_EVENT_FUNC_SUSPEND \|\| func == GPIO_EVENT_FUNC_RESUME) {
290	/* TODO: disable scanning */
291	return 0;
292	}
293
294	if (func == GPIO_EVENT_FUNC_INIT) {
295	if (mi->keymap == NULL \|\|
296	mi->input_gpios == NULL \|\|
297	mi->output_gpios == NULL) {
298	err = -ENODEV;
299	pr_err("gpiomatrix: Incomplete pdata\n");
300	goto err_invalid_platform_data;
301	}
302	key_count = mi->ninputs * mi->noutputs;
303
304	data = kp = kzalloc(sizeof(kp) + sizeof(kp->keys_pressed[0]) *
305	BITS_TO_LONGS(key_count), GFP_KERNEL);
306	if (kp == NULL) {
307	err = -ENOMEM;
308	pr_err("gpiomatrix: Failed to allocate private data\n");
309	goto err_kp_alloc_failed;
310	}
311	kp->input_dev = input_dev;
312	kp->keypad_info = mi;
313	set_bit(EV_KEY, input_dev->evbit);
314	for (i = 0; i < key_count; i++) {
315	if (mi->keymap[i])
316	set_bit(mi->keymap[i] & KEY_MAX,
317	input_dev->keybit);
318	}
319
320	for (i = 0; i < mi->noutputs; i++) {
321	if (gpio_cansleep(mi->output_gpios[i])) {
322	pr_err("gpiomatrix: unsupported output gpio %d,"
323	" can sleep\n", mi->output_gpios[i]);
324	err = -EINVAL;
325	goto err_request_output_gpio_failed;
326	}
327	err = gpio_request(mi->output_gpios[i], "gpio_kp_out");
328	if (err) {
329	pr_err("gpiomatrix: gpio_request failed for "
330	"output %d\n", mi->output_gpios[i]);
331	goto err_request_output_gpio_failed;
332	}
333	if (mi->flags & GPIOKPF_DRIVE_INACTIVE)
334	err = gpio_direction_output(mi->output_gpios[i],
335	!(mi->flags & GPIOKPF_ACTIVE_HIGH));
336	else
337	err = gpio_direction_input(mi->output_gpios[i]);
338	if (err) {
339	pr_err("gpiomatrix: gpio_configure failed for "
340	"output %d\n", mi->output_gpios[i]);
341	goto err_output_gpio_configure_failed;
342	}
343	}
344	for (i = 0; i < mi->ninputs; i++) {
345	err = gpio_request(mi->input_gpios[i], "gpio_kp_in");
346	if (err) {
347	pr_err("gpiomatrix: gpio_request failed for "
348	"input %d\n", mi->input_gpios[i]);
349	goto err_request_input_gpio_failed;
350	}
351	err = gpio_direction_input(mi->input_gpios[i]);
352	if (err) {
353	pr_err("gpiomatrix: gpio_direction_input failed"
354	" for input %d\n", mi->input_gpios[i]);
355	goto err_gpio_direction_input_failed;
356	}
357	}
358	kp->current_output = mi->noutputs;
359	kp->key_state_changed = 1;
360
361	hrtimer_init(&kp->timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
362	kp->timer.function = gpio_keypad_timer_func;
420818f9 AH	363	err = gpio_keypad_request_irqs(kp);
	364	kp->use_irq = err == 0;
	365
	366	pr_info("GPIO Matrix Keypad Driver: Start keypad matrix for %s "
	367	"in %s mode\n", input_dev->name,
	368	kp->use_irq ? "interrupt" : "polling");
	369
420818f9 AH	370	hrtimer_start(&kp->timer, ktime_set(0, 0), HRTIMER_MODE_REL);
	371
	372	return 0;
	373	}
	374
	375	err = 0;
	376	kp = *data;
	377
	378	if (kp->use_irq)
	379	for (i = mi->noutputs - 1; i >= 0; i--)
	380	free_irq(gpio_to_irq(mi->input_gpios[i]), kp);
	381
	382	hrtimer_cancel(&kp->timer);
420818f9 AH	383	for (i = mi->noutputs - 1; i >= 0; i--) {
	384	err_gpio_direction_input_failed:
	385	gpio_free(mi->input_gpios[i]);
	386	err_request_input_gpio_failed:
	387	;
	388	}
	389	for (i = mi->noutputs - 1; i >= 0; i--) {
	390	err_output_gpio_configure_failed:
	391	gpio_free(mi->output_gpios[i]);
	392	err_request_output_gpio_failed:
	393	;
	394	}
	395	kfree(kp);
	396	err_kp_alloc_failed:
	397	err_invalid_platform_data:
	398	return err;
	399	}