drivers/input/misc/dm355evm_keys.c

   1 /*
   2  * dm355evm_keys.c - support buttons and IR remote on DM355 EVM board
   3  *
   4  * Copyright (c) 2008 by David Brownell
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License
   8  * as published by the Free Software Foundation; either version
   9  * 2 of the License, or (at your option) any later version.
  10  */
  11 #include <linux/kernel.h>
  12 #include <linux/init.h>
  13 #include <linux/input.h>
  14 #include <linux/platform_device.h>
  15 #include <linux/interrupt.h>
  16
  17 #include <linux/i2c/dm355evm_msp.h>
  18
  19
  20 /*
  21  * The MSP430 firmware on the DM355 EVM monitors on-board pushbuttons
  22  * and an IR receptor used for the remote control.  When any key is
  23  * pressed, or its autorepeat kicks in, an event is sent.  This driver
  24  * read those events from the small (32 event) queue and reports them.
  25  *
  26  * Note that physically there can only be one of these devices.
  27  *
  28  * This driver was tested with firmware revision A4.
  29  */
  30 struct dm355evm_keys {
  31         struct input_dev        *input;
  32         struct device           *dev;
  33         int                     irq;
  34 };
  35
  36 /* These initial keycodes can be remapped by dm355evm_setkeycode(). */
  37 static struct {
  38         u16     event;
  39         u16     keycode;
  40 } dm355evm_keys[] = {
  41
  42         /*
  43          * Pushbuttons on the EVM board ... note that the labels for these
  44          * are SW10/SW11/etc on the PC board.  The left/right orientation
  45          * comes only from the firmware's documentation, and presumes the
  46          * power connector is immediately in front of you and the IR sensor
  47          * is to the right.  (That is, rotate the board counter-clockwise
  48          * by 90 degrees from the SW10/etc and "DM355 EVM" labels.)
  49          */
  50         { 0x00d8, KEY_OK, },            /* SW12 */
  51         { 0x00b8, KEY_UP, },            /* SW13 */
  52         { 0x00e8, KEY_DOWN, },          /* SW11 */
  53         { 0x0078, KEY_LEFT, },          /* SW14 */
  54         { 0x00f0, KEY_RIGHT, },         /* SW10 */
  55
  56         /*
  57          * IR buttons ... codes assigned to match the universal remote
  58          * provided with the EVM (Philips PM4S) using DVD code 0020.
  59          *
  60          * These event codes match firmware documentation, but other
  61          * remote controls could easily send more RC5-encoded events.
  62          * The PM4S manual was used in several cases to help select
  63          * a keycode reflecting the intended usage.
  64          *
  65          * RC5 codes are 14 bits, with two start bits (0x3 prefix)
  66          * and a toggle bit (masked out below).
  67          */
  68         { 0x300c, KEY_POWER, },         /* NOTE: docs omit this */
  69         { 0x3000, KEY_NUMERIC_0, },
  70         { 0x3001, KEY_NUMERIC_1, },
  71         { 0x3002, KEY_NUMERIC_2, },
  72         { 0x3003, KEY_NUMERIC_3, },
  73         { 0x3004, KEY_NUMERIC_4, },
  74         { 0x3005, KEY_NUMERIC_5, },
  75         { 0x3006, KEY_NUMERIC_6, },
  76         { 0x3007, KEY_NUMERIC_7, },
  77         { 0x3008, KEY_NUMERIC_8, },
  78         { 0x3009, KEY_NUMERIC_9, },
  79         { 0x3022, KEY_ENTER, },
  80         { 0x30ec, KEY_MODE, },          /* "tv/vcr/..." */
  81         { 0x300f, KEY_SELECT, },        /* "info" */
  82         { 0x3020, KEY_CHANNELUP, },     /* "up" */
  83         { 0x302e, KEY_MENU, },          /* "in/out" */
  84         { 0x3011, KEY_VOLUMEDOWN, },    /* "left" */
  85         { 0x300d, KEY_MUTE, },          /* "ok" */
  86         { 0x3010, KEY_VOLUMEUP, },      /* "right" */
  87         { 0x301e, KEY_SUBTITLE, },      /* "cc" */
  88         { 0x3021, KEY_CHANNELDOWN, },   /* "down" */
  89         { 0x3022, KEY_PREVIOUS, },
  90         { 0x3026, KEY_SLEEP, },
  91         { 0x3172, KEY_REWIND, },        /* NOTE: docs wrongly say 0x30ca */
  92         { 0x3175, KEY_PLAY, },
  93         { 0x3174, KEY_FASTFORWARD, },
  94         { 0x3177, KEY_RECORD, },
  95         { 0x3176, KEY_STOP, },
  96         { 0x3169, KEY_PAUSE, },
  97 };
  98
  99 /*
 100  * Because we communicate with the MSP430 using I2C, and all I2C calls
 101  * in Linux sleep, we use a threaded IRQ handler.  The IRQ itself is
 102  * active low, but we go through the GPIO controller so we can trigger
 103  * on falling edges and not worry about enabling/disabling the IRQ in
 104  * the keypress handling path.
 105  */
 106 static irqreturn_t dm355evm_keys_irq(int irq, void *_keys)
 107 {
 108         struct dm355evm_keys    *keys = _keys;
 109         int                     status;
 110
 111         /* For simplicity we ignore INPUT_COUNT and just read
 112          * events until we get the "queue empty" indicator.
 113          * Reading INPUT_LOW decrements the count.
 114          */
 115         for (;;) {
 116                 static u16      last_event;
 117                 u16             event;
 118                 int             keycode;
 119                 int             i;
 120
 121                 status = dm355evm_msp_read(DM355EVM_MSP_INPUT_HIGH);
 122                 if (status < 0) {
 123                         dev_dbg(keys->dev, "input high err %d\n",
 124                                         status);
 125                         break;
 126                 }
 127                 event = status << 8;
 128
 129                 status = dm355evm_msp_read(DM355EVM_MSP_INPUT_LOW);
 130                 if (status < 0) {
 131                         dev_dbg(keys->dev, "input low err %d\n",
 132                                         status);
 133                         break;
 134                 }
 135                 event |= status;
 136                 if (event == 0xdead)
 137                         break;
 138
 139                 /* Press and release a button:  two events, same code.
 140                  * Press and hold (autorepeat), then release: N events
 141                  * (N > 2), same code.  For RC5 buttons the toggle bits
 142                  * distinguish (for example) "1-autorepeat" from "1 1";
 143                  * but PCB buttons don't support that bit.
 144                  *
 145                  * So we must synthesize release events.  We do that by
 146                  * mapping events to a press/release event pair; then
 147                  * to avoid adding extra events, skip the second event
 148                  * of each pair.
 149                  */
 150                 if (event == last_event) {
 151                         last_event = 0;
 152                         continue;
 153                 }
 154                 last_event = event;
 155
 156                 /* ignore the RC5 toggle bit */
 157                 event &= ~0x0800;
 158
 159                 /* find the key, or leave it as unknown */
 160                 keycode = KEY_UNKNOWN;
 161                 for (i = 0; i < ARRAY_SIZE(dm355evm_keys); i++) {
 162                         if (dm355evm_keys[i].event != event)
 163                                 continue;
 164                         keycode = dm355evm_keys[i].keycode;
 165                         break;
 166                 }
 167                 dev_dbg(keys->dev,
 168                         "input event 0x%04x--> keycode %d\n",
 169                         event, keycode);
 170
 171                 /* report press + release */
 172                 input_report_key(keys->input, keycode, 1);
 173                 input_sync(keys->input);
 174                 input_report_key(keys->input, keycode, 0);
 175                 input_sync(keys->input);
 176         }
 177         return IRQ_HANDLED;
 178 }
 179
 180 static int dm355evm_setkeycode(struct input_dev *dev, int index, int keycode)
 181 {
 182         u16             old_keycode;
 183         unsigned        i;
 184
 185         if (((unsigned)index) >= ARRAY_SIZE(dm355evm_keys))
 186                 return -EINVAL;
 187
 188         old_keycode = dm355evm_keys[index].keycode;
 189         dm355evm_keys[index].keycode = keycode;
 190         set_bit(keycode, dev->keybit);
 191
 192         for (i = 0; i < ARRAY_SIZE(dm355evm_keys); i++) {
 193                 if (dm355evm_keys[index].keycode == old_keycode)
 194                         goto done;
 195         }
 196         clear_bit(old_keycode, dev->keybit);
 197 done:
 198         return 0;
 199 }
 200
 201 static int dm355evm_getkeycode(struct input_dev *dev, int index, int *keycode)
 202 {
 203         if (((unsigned)index) >= ARRAY_SIZE(dm355evm_keys))
 204                 return -EINVAL;
 205
 206         return dm355evm_keys[index].keycode;
 207 }
 208
 209 /*----------------------------------------------------------------------*/
 210
 211 static int __devinit dm355evm_keys_probe(struct platform_device *pdev)
 212 {
 213         struct dm355evm_keys    *keys;
 214         struct input_dev        *input;
 215         int                     status;
 216         int                     i;
 217
 218         /* allocate instance struct and input dev */
 219         keys = kzalloc(sizeof *keys, GFP_KERNEL);
 220         input = input_allocate_device();
 221         if (!keys || !input) {
 222                 status = -ENOMEM;
 223                 goto fail1;
 224         }
 225
 226         keys->dev = &pdev->dev;
 227         keys->input = input;
 228
 229         /* set up "threaded IRQ handler" */
 230         status = platform_get_irq(pdev, 0);
 231         if (status < 0)
 232                 goto fail1;
 233         keys->irq = status;
 234
 235         input_set_drvdata(input, keys);
 236
 237         input->name = "DM355 EVM Controls";
 238         input->phys = "dm355evm/input0";
 239         input->dev.parent = &pdev->dev;
 240
 241         input->id.bustype = BUS_I2C;
 242         input->id.product = 0x0355;
 243         input->id.version = dm355evm_msp_read(DM355EVM_MSP_FIRMREV);
 244
 245         input->evbit[0] = BIT(EV_KEY);
 246         for (i = 0; i < ARRAY_SIZE(dm355evm_keys); i++)
 247                 __set_bit(dm355evm_keys[i].keycode, input->keybit);
 248
 249         input->setkeycode = dm355evm_setkeycode;
 250         input->getkeycode = dm355evm_getkeycode;
 251
 252         /* REVISIT:  flush the event queue? */
 253
 254         status = request_threaded_irq(keys->irq, NULL, dm355evm_keys_irq,
 255                         IRQF_TRIGGER_FALLING, dev_name(&pdev->dev), keys);
 256         if (status < 0)
 257                 goto fail1;
 258
 259         /* register */
 260         status = input_register_device(input);
 261         if (status < 0)
 262                 goto fail2;
 263
 264         platform_set_drvdata(pdev, keys);
 265
 266         return 0;
 267
 268 fail2:
 269         free_irq(keys->irq, keys);
 270 fail1:
 271         input_free_device(input);
 272         kfree(keys);
 273         dev_err(&pdev->dev, "can't register, err %d\n", status);
 274
 275         return status;
 276 }
 277
 278 static int __devexit dm355evm_keys_remove(struct platform_device *pdev)
 279 {
 280         struct dm355evm_keys    *keys = platform_get_drvdata(pdev);
 281
 282         free_irq(keys->irq, keys);
 283         input_unregister_device(keys->input);
 284         kfree(keys);
 285
 286         return 0;
 287 }
 288
 289 /* REVISIT:  add suspend/resume when DaVinci supports it.  The IRQ should
 290  * be able to wake up the system.  When device_may_wakeup(&pdev->dev), call
 291  * enable_irq_wake() on suspend, and disable_irq_wake() on resume.
 292  */
 293
 294 /*
 295  * I2C is used to talk to the MSP430, but this platform device is
 296  * exposed by an MFD driver that manages I2C communications.
 297  */
 298 static struct platform_driver dm355evm_keys_driver = {
 299         .probe          = dm355evm_keys_probe,
 300         .remove         = __devexit_p(dm355evm_keys_remove),
 301         .driver         = {
 302                 .owner  = THIS_MODULE,
 303                 .name   = "dm355evm_keys",
 304         },
 305 };
 306
 307 static int __init dm355evm_keys_init(void)
 308 {
 309         return platform_driver_register(&dm355evm_keys_driver);
 310 }
 311 module_init(dm355evm_keys_init);
 312
 313 static void __exit dm355evm_keys_exit(void)
 314 {
 315         platform_driver_unregister(&dm355evm_keys_driver);
 316 }
 317 module_exit(dm355evm_keys_exit);
 318
 319 MODULE_LICENSE("GPL");