LXR linux/drivers/hid/hid-icade.c

   1/*
   2 *  ION iCade input driver
   3 *
   4 *  Copyright (c) 2012 Bastien Nocera <hadess@hadess.net>
   5 *  Copyright (c) 2012 Benjamin Tissoires <benjamin.tissoires@gmail.com>
   6 */
   7
   8/*
   9 * This program is free software; you can redistribute it and/or modify it
  10 * under the terms of the GNU General Public License as published by the Free
  11 * Software Foundation; either version 2 of the License, or (at your option)
  12 * any later version.
  13 */
  14
  15#include <linux/device.h>
  16#include <linux/hid.h>
  17#include <linux/module.h>
  18
  19#include "hid-ids.h"
  20
  21/*
  22 *   ↑      A C Y L
  23 *  ← →
  24 *   ↓      B X Z R
  25 *
  26 *
  27 *  UP ON,OFF  = w,e
  28 *  RT ON,OFF  = d,c
  29 *  DN ON,OFF  = x,z
  30 *  LT ON,OFF  = a,q
  31 *  A  ON,OFF  = y,t
  32 *  B  ON,OFF  = h,r
  33 *  C  ON,OFF  = u,f
  34 *  X  ON,OFF  = j,n
  35 *  Y  ON,OFF  = i,m
  36 *  Z  ON,OFF  = k,p
  37 *  L  ON,OFF  = o,g
  38 *  R  ON,OFF  = l,v
  39 */
  40
  41/* The translation code uses HID usage instead of input layer
  42 * keys. This code generates a lookup table that makes
  43 * translation quick.
  44 *
  45 * #include <linux/input.h>
  46 * #include <stdio.h>
  47 * #include <assert.h>
  48 *
  49 * #define unk     KEY_UNKNOWN
  50 *
  51 * < copy of hid_keyboard[] from hid-input.c >
  52 *
  53 * struct icade_key_translation {
  54 *     int         from;
  55 *     const char *to;
  56 *     int         press;
  57 * };
  58 *
  59 * static const struct icade_key_translation icade_keys[] = {
  60 *    { KEY_W,        "KEY_UP",         1 },
  61 *    { KEY_E,        "KEY_UP",         0 },
  62 *    { KEY_D,        "KEY_RIGHT",      1 },
  63 *    { KEY_C,        "KEY_RIGHT",      0 },
  64 *    { KEY_X,        "KEY_DOWN",       1 },
  65 *    { KEY_Z,        "KEY_DOWN",       0 },
  66 *    { KEY_A,        "KEY_LEFT",       1 },
  67 *    { KEY_Q,        "KEY_LEFT",       0 },
  68 *    { KEY_Y,        "BTN_A",          1 },
  69 *    { KEY_T,        "BTN_A",          0 },
  70 *    { KEY_H,        "BTN_B",          1 },
  71 *    { KEY_R,        "BTN_B",          0 },
  72 *    { KEY_U,        "BTN_C",          1 },
  73 *    { KEY_F,        "BTN_C",          0 },
  74 *    { KEY_J,        "BTN_X",          1 },
  75 *    { KEY_N,        "BTN_X",          0 },
  76 *    { KEY_I,        "BTN_Y",          1 },
  77 *    { KEY_M,        "BTN_Y",          0 },
  78 *    { KEY_K,        "BTN_Z",          1 },
  79 *    { KEY_P,        "BTN_Z",          0 },
  80 *    { KEY_O,        "BTN_THUMBL",     1 },
  81 *    { KEY_G,        "BTN_THUMBL",     0 },
  82 *    { KEY_L,        "BTN_THUMBR",     1 },
  83 *    { KEY_V,        "BTN_THUMBR",     0 },
  84 *
  85 *    { }
  86 * };
  87 *
  88 * static int
  89 * usage_for_key (int key)
  90 * {
  91 *     int i;
  92 *     for (i = 0; i < 256; i++) {
  93 *     if (hid_keyboard[i] == key)
  94 *         return i;
  95 *     }
  96 *     assert(0);
  97 * }
  98 *
  99 * int main (int argc, char **argv)
 100 * {
 101 *     const struct icade_key_translation *trans;
 102 *     int max_usage = 0;
 103 *
 104 *     for (trans = icade_keys; trans->from; trans++) {
 105 *         int usage = usage_for_key (trans->from);
 106 *         max_usage = usage > max_usage ? usage : max_usage;
 107 *     }
 108 *
 109 *     printf ("#define ICADE_MAX_USAGE %d\n\n", max_usage);
 110 *     printf ("struct icade_key {\n");
 111 *     printf ("\tu16 to;\n");
 112 *     printf ("\tu8 press:1;\n");
 113 *     printf ("};\n\n");
 114 *     printf ("static const struct icade_key "
 115 *             "icade_usage_table[%d] = {\n", max_usage + 1);
 116 *     for (trans = icade_keys; trans->from; trans++) {
 117 *         printf ("\t[%d] = { %s, %d },\n",
 118 *                 usage_for_key (trans->from), trans->to, trans->press);
 119 *     }
 120 *     printf ("};\n");
 121 *
 122 *     return 0;
 123 * }
 124 */
 125
 126#define ICADE_MAX_USAGE 29
 127
 128struct icade_key {
 129        u16 to;
 130        u8 press:1;
 131};
 132
 133static const struct icade_key icade_usage_table[30] = {
 134        [26] = { KEY_UP, 1 },
 135        [8] = { KEY_UP, 0 },
 136        [7] = { KEY_RIGHT, 1 },
 137        [6] = { KEY_RIGHT, 0 },
 138        [27] = { KEY_DOWN, 1 },
 139        [29] = { KEY_DOWN, 0 },
 140        [4] = { KEY_LEFT, 1 },
 141        [20] = { KEY_LEFT, 0 },
 142        [28] = { BTN_A, 1 },
 143        [23] = { BTN_A, 0 },
 144        [11] = { BTN_B, 1 },
 145        [21] = { BTN_B, 0 },
 146        [24] = { BTN_C, 1 },
 147        [9] = { BTN_C, 0 },
 148        [13] = { BTN_X, 1 },
 149        [17] = { BTN_X, 0 },
 150        [12] = { BTN_Y, 1 },
 151        [16] = { BTN_Y, 0 },
 152        [14] = { BTN_Z, 1 },
 153        [19] = { BTN_Z, 0 },
 154        [18] = { BTN_THUMBL, 1 },
 155        [10] = { BTN_THUMBL, 0 },
 156        [15] = { BTN_THUMBR, 1 },
 157        [25] = { BTN_THUMBR, 0 },
 158};
 159
 160static const struct icade_key *icade_find_translation(u16 from)
 161{
 162        if (from > ICADE_MAX_USAGE)
 163                return NULL;
 164        return &icade_usage_table[from];
 165}
 166
 167static int icade_event(struct hid_device *hdev, struct hid_field *field,
 168                struct hid_usage *usage, __s32 value)
 169{
 170        const struct icade_key *trans;
 171
 172        if (!(hdev->claimed & HID_CLAIMED_INPUT) || !field->hidinput ||
 173                        !usage->type)
 174                return 0;
 175
 176        /* We ignore the fake key up, and act only on key down */
 177        if (!value)
 178                return 1;
 179
 180        trans = icade_find_translation(usage->hid & HID_USAGE);
 181
 182        if (!trans)
 183                return 1;
 184
 185        input_event(field->hidinput->input, usage->type,
 186                        trans->to, trans->press);
 187
 188        return 1;
 189}
 190
 191static int icade_input_mapping(struct hid_device *hdev, struct hid_input *hi,
 192                struct hid_field *field, struct hid_usage *usage,
 193                unsigned long **bit, int *max)
 194{
 195        const struct icade_key *trans;
 196
 197        if ((usage->hid & HID_USAGE_PAGE) == HID_UP_KEYBOARD) {
 198                trans = icade_find_translation(usage->hid & HID_USAGE);
 199
 200                if (!trans)
 201                        return -1;
 202
 203                hid_map_usage(hi, usage, bit, max, EV_KEY, trans->to);
 204                set_bit(trans->to, hi->input->keybit);
 205
 206                return 1;
 207        }
 208
 209        /* ignore others */
 210        return -1;
 211
 212}
 213
 214static int icade_input_mapped(struct hid_device *hdev, struct hid_input *hi,
 215                struct hid_field *field, struct hid_usage *usage,
 216                unsigned long **bit, int *max)
 217{
 218        if (usage->type == EV_KEY)
 219                set_bit(usage->type, hi->input->evbit);
 220
 221        return -1;
 222}
 223
 224static const struct hid_device_id icade_devices[] = {
 225        { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_ION, USB_DEVICE_ID_ICADE) },
 226
 227        { }
 228};
 229MODULE_DEVICE_TABLE(hid, icade_devices);
 230
 231static struct hid_driver icade_driver = {
 232        .name = "icade",
 233        .id_table = icade_devices,
 234        .event = icade_event,
 235        .input_mapped = icade_input_mapped,
 236        .input_mapping = icade_input_mapping,
 237};
 238module_hid_driver(icade_driver);
 239
 240MODULE_LICENSE("GPL");
 241MODULE_AUTHOR("Bastien Nocera <hadess@hadess.net>");
 242MODULE_DESCRIPTION("ION iCade input driver");
 243