drivers/hid/hid-creative-sb0540.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * HID driver for the Creative SB0540 receiver
   4  *
   5  * Copyright (C) 2019 Red Hat Inc. All Rights Reserved
   6  *
   7  */
   8
   9 #include <linux/device.h>
  10 #include <linux/hid.h>
  11 #include <linux/module.h>
  12 #include "hid-ids.h"
  13
  14 MODULE_AUTHOR("Bastien Nocera <hadess@hadess.net>");
  15 MODULE_DESCRIPTION("HID Creative SB0540 receiver");
  16 MODULE_LICENSE("GPL");
  17
  18 static const unsigned short creative_sb0540_key_table[] = {
  19         KEY_POWER,
  20         KEY_RESERVED,           /* text: 24bit */
  21         KEY_RESERVED,           /* 24bit wheel up */
  22         KEY_RESERVED,           /* 24bit wheel down */
  23         KEY_RESERVED,           /* text: CMSS */
  24         KEY_RESERVED,           /* CMSS wheel Up */
  25         KEY_RESERVED,           /* CMSS wheel Down */
  26         KEY_RESERVED,           /* text: EAX */
  27         KEY_RESERVED,           /* EAX wheel up */
  28         KEY_RESERVED,           /* EAX wheel down */
  29         KEY_RESERVED,           /* text: 3D Midi */
  30         KEY_RESERVED,           /* 3D Midi wheel up */
  31         KEY_RESERVED,           /* 3D Midi wheel down */
  32         KEY_MUTE,
  33         KEY_VOLUMEUP,
  34         KEY_VOLUMEDOWN,
  35         KEY_UP,
  36         KEY_LEFT,
  37         KEY_RIGHT,
  38         KEY_REWIND,
  39         KEY_OK,
  40         KEY_FASTFORWARD,
  41         KEY_DOWN,
  42         KEY_AGAIN,              /* text: Return, symbol: Jump to */
  43         KEY_PLAY,               /* text: Start */
  44         KEY_ESC,                /* text: Cancel */
  45         KEY_RECORD,
  46         KEY_OPTION,
  47         KEY_MENU,               /* text: Display */
  48         KEY_PREVIOUS,
  49         KEY_PLAYPAUSE,
  50         KEY_NEXT,
  51         KEY_SLOW,
  52         KEY_STOP,
  53         KEY_NUMERIC_1,
  54         KEY_NUMERIC_2,
  55         KEY_NUMERIC_3,
  56         KEY_NUMERIC_4,
  57         KEY_NUMERIC_5,
  58         KEY_NUMERIC_6,
  59         KEY_NUMERIC_7,
  60         KEY_NUMERIC_8,
  61         KEY_NUMERIC_9,
  62         KEY_NUMERIC_0
  63 };
  64
  65 /*
  66  * Codes and keys from lirc's
  67  * remotes/creative/lircd.conf.alsa_usb
  68  * order and size must match creative_sb0540_key_table[] above
  69  */
  70 static const unsigned short creative_sb0540_codes[] = {
  71         0x619E,
  72         0x916E,
  73         0x926D,
  74         0x936C,
  75         0x718E,
  76         0x946B,
  77         0x956A,
  78         0x8C73,
  79         0x9669,
  80         0x9768,
  81         0x9867,
  82         0x9966,
  83         0x9A65,
  84         0x6E91,
  85         0x629D,
  86         0x639C,
  87         0x7B84,
  88         0x6B94,
  89         0x728D,
  90         0x8778,
  91         0x817E,
  92         0x758A,
  93         0x8D72,
  94         0x8E71,
  95         0x8877,
  96         0x7C83,
  97         0x738C,
  98         0x827D,
  99         0x7689,
 100         0x7F80,
 101         0x7986,
 102         0x7A85,
 103         0x7D82,
 104         0x857A,
 105         0x8B74,
 106         0x8F70,
 107         0x906F,
 108         0x8A75,
 109         0x847B,
 110         0x7887,
 111         0x8976,
 112         0x837C,
 113         0x7788,
 114         0x807F
 115 };
 116
 117 struct creative_sb0540 {
 118         struct input_dev *input_dev;
 119         struct hid_device *hid;
 120         unsigned short keymap[ARRAY_SIZE(creative_sb0540_key_table)];
 121 };
 122
 123 static inline u64 reverse(u64 data, int bits)
 124 {
 125         int i;
 126         u64 c;
 127
 128         c = 0;
 129         for (i = 0; i < bits; i++) {
 130                 c |= (u64) (((data & (((u64) 1) << i)) ? 1 : 0))
 131                         << (bits - 1 - i);
 132         }
 133         return (c);
 134 }
 135
 136 static int get_key(struct creative_sb0540 *creative_sb0540, u64 keycode)
 137 {
 138         int i;
 139
 140         for (i = 0; i < ARRAY_SIZE(creative_sb0540_codes); i++) {
 141                 if (creative_sb0540_codes[i] == keycode)
 142                         return creative_sb0540->keymap[i];
 143         }
 144
 145         return 0;
 146
 147 }
 148
 149 static int creative_sb0540_raw_event(struct hid_device *hid,
 150         struct hid_report *report, u8 *data, int len)
 151 {
 152         struct creative_sb0540 *creative_sb0540 = hid_get_drvdata(hid);
 153         u64 code, main_code;
 154         int key;
 155
 156         if (len != 6)
 157                 return 0;
 158
 159         /* From daemons/hw_hiddev.c sb0540_rec() in lirc */
 160         code = reverse(data[5], 8);
 161         main_code = (code << 8) + ((~code) & 0xff);
 162
 163         /*
 164          * Flip to get values in the same format as
 165          * remotes/creative/lircd.conf.alsa_usb in lirc
 166          */
 167         main_code = ((main_code & 0xff) << 8) +
 168                 ((main_code & 0xff00) >> 8);
 169
 170         key = get_key(creative_sb0540, main_code);
 171         if (key == 0 || key == KEY_RESERVED) {
 172                 hid_err(hid, "Could not get a key for main_code %llX\n",
 173                         main_code);
 174                 return 0;
 175         }
 176
 177         input_report_key(creative_sb0540->input_dev, key, 1);
 178         input_report_key(creative_sb0540->input_dev, key, 0);
 179         input_sync(creative_sb0540->input_dev);
 180
 181         /* let hidraw and hiddev handle the report */
 182         return 0;
 183 }
 184
 185 static int creative_sb0540_input_configured(struct hid_device *hid,
 186                 struct hid_input *hidinput)
 187 {
 188         struct input_dev *input_dev = hidinput->input;
 189         struct creative_sb0540 *creative_sb0540 = hid_get_drvdata(hid);
 190         int i;
 191
 192         creative_sb0540->input_dev = input_dev;
 193
 194         input_dev->keycode = creative_sb0540->keymap;
 195         input_dev->keycodesize = sizeof(unsigned short);
 196         input_dev->keycodemax = ARRAY_SIZE(creative_sb0540->keymap);
 197
 198         input_dev->evbit[0] = BIT(EV_KEY) | BIT(EV_REP);
 199
 200         memcpy(creative_sb0540->keymap, creative_sb0540_key_table,
 201                 sizeof(creative_sb0540->keymap));
 202         for (i = 0; i < ARRAY_SIZE(creative_sb0540_key_table); i++)
 203                 set_bit(creative_sb0540->keymap[i], input_dev->keybit);
 204         clear_bit(KEY_RESERVED, input_dev->keybit);
 205
 206         return 0;
 207 }
 208
 209 static int creative_sb0540_input_mapping(struct hid_device *hid,
 210                 struct hid_input *hi, struct hid_field *field,
 211                 struct hid_usage *usage, unsigned long **bit, int *max)
 212 {
 213         /*
 214          * We are remapping the keys ourselves, so ignore the hid-input
 215          * keymap processing.
 216          */
 217         return -1;
 218 }
 219
 220 static int creative_sb0540_probe(struct hid_device *hid,
 221                 const struct hid_device_id *id)
 222 {
 223         int ret;
 224         struct creative_sb0540 *creative_sb0540;
 225
 226         creative_sb0540 = devm_kzalloc(&hid->dev,
 227                 sizeof(struct creative_sb0540), GFP_KERNEL);
 228
 229         if (!creative_sb0540)
 230                 return -ENOMEM;
 231
 232         creative_sb0540->hid = hid;
 233
 234         /* force input as some remotes bypass the input registration */
 235         hid->quirks |= HID_QUIRK_HIDINPUT_FORCE;
 236
 237         hid_set_drvdata(hid, creative_sb0540);
 238
 239         ret = hid_parse(hid);
 240         if (ret) {
 241                 hid_err(hid, "parse failed\n");
 242                 return ret;
 243         }
 244
 245         ret = hid_hw_start(hid, HID_CONNECT_DEFAULT);
 246         if (ret) {
 247                 hid_err(hid, "hw start failed\n");
 248                 return ret;
 249         }
 250
 251         return ret;
 252 }
 253
 254 static const struct hid_device_id creative_sb0540_devices[] = {
 255         { HID_USB_DEVICE(USB_VENDOR_ID_CREATIVELABS, USB_DEVICE_ID_CREATIVE_SB0540) },
 256         { }
 257 };
 258 MODULE_DEVICE_TABLE(hid, creative_sb0540_devices);
 259
 260 static struct hid_driver creative_sb0540_driver = {
 261         .name = "creative-sb0540",
 262         .id_table = creative_sb0540_devices,
 263         .raw_event = creative_sb0540_raw_event,
 264         .input_configured = creative_sb0540_input_configured,
 265         .probe = creative_sb0540_probe,
 266         .input_mapping = creative_sb0540_input_mapping,
 267 };
 268 module_hid_driver(creative_sb0540_driver);