drivers/input/misc/gpio_matrix.c

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