Added missing tegra files.HEADmaster

1 files changed, 441 insertions, 0 deletions

diff --git a/drivers/input/misc/gpio_matrix.c b/drivers/input/misc/gpio_matrix.c
new file mode 100644
index 00000000000..eaa9e89d473
--- /dev/null
+++ b/drivers/input/misc/gpio_matrix.c
@@ -0,0 +1,441 @@
+/* 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/gpio.h>
+#include <linux/gpio_event.h>
+#include <linux/hrtimer.h>
+#include <linux/interrupt.h>
+#include <linux/slab.h>
+#include <linux/wakelock.h>
+
+struct gpio_kp {
+        struct gpio_event_input_devs *input_devs;
+        struct gpio_event_matrix_info *keypad_info;
+        struct hrtimer timer;
+        struct wake_lock wake_lock;
+        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 int disabled_irq:1;
+        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 keyentry = mi->keymap[key_index];
+        unsigned short keycode = keyentry & MATRIX_KEY_MASK;
+        unsigned short dev = keyentry >> MATRIX_CODE_BITS;
+
+        if (!test_bit(keycode, kp->input_devs->dev[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 keyentry = mi->keymap[key_index];
+        unsigned short keycode = keyentry & MATRIX_KEY_MASK;
+        unsigned short dev = keyentry >> MATRIX_CODE_BITS;
+
+        if (pressed != test_bit(keycode, kp->input_devs->dev[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_devs->dev[dev], keycode, pressed);
+                }
+        }
+}
+
+static void report_sync(struct gpio_kp *kp)
+{
+        int i;
+
+        for (i = 0; i < kp->input_devs->count; i++)
+                input_sync(kp->input_devs->dev[i]);
+}
+
+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);
+                report_sync(kp);