drivers/hid/hid-led.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Simple USB RGB LED driver
   4  *
   5  * Copyright 2016 Heiner Kallweit <hkallweit1@gmail.com>
   6  * Based on drivers/hid/hid-thingm.c and
   7  * drivers/usb/misc/usbled.c
   8  */
   9
  10 #include <linux/hid.h>
  11 #include <linux/hidraw.h>
  12 #include <linux/leds.h>
  13 #include <linux/module.h>
  14 #include <linux/mutex.h>
  15
  16 #include "hid-ids.h"
  17
  18 enum hidled_report_type {
  19         RAW_REQUEST,
  20         OUTPUT_REPORT
  21 };
  22
  23 enum hidled_type {
  24         RISO_KAGAKU,
  25         DREAM_CHEEKY,
  26         THINGM,
  27         DELCOM,
  28         LUXAFOR,
  29 };
  30
  31 static unsigned const char riso_kagaku_tbl[] = {
  32 /* R+2G+4B -> riso kagaku color index */
  33         [0] = 0, /* black   */
  34         [1] = 2, /* red     */
  35         [2] = 1, /* green   */
  36         [3] = 5, /* yellow  */
  37         [4] = 3, /* blue    */
  38         [5] = 6, /* magenta */
  39         [6] = 4, /* cyan    */
  40         [7] = 7  /* white   */
  41 };
  42
  43 #define RISO_KAGAKU_IX(r, g, b) riso_kagaku_tbl[((r)?1:0)+((g)?2:0)+((b)?4:0)]
  44
  45 union delcom_packet {
  46         __u8 data[8];
  47         struct {
  48                 __u8 major_cmd;
  49                 __u8 minor_cmd;
  50                 __u8 data_lsb;
  51                 __u8 data_msb;
  52         } tx;
  53         struct {
  54                 __u8 cmd;
  55         } rx;
  56         struct {
  57                 __le16 family_code;
  58                 __le16 security_code;
  59                 __u8 fw_version;
  60         } fw;
  61 };
  62
  63 #define DELCOM_GREEN_LED        0
  64 #define DELCOM_RED_LED          1
  65 #define DELCOM_BLUE_LED         2
  66
  67 struct hidled_device;
  68 struct hidled_rgb;
  69
  70 struct hidled_config {
  71         enum hidled_type        type;
  72         const char              *name;
  73         const char              *short_name;
  74         enum led_brightness     max_brightness;
  75         int                     num_leds;
  76         size_t                  report_size;
  77         enum hidled_report_type report_type;
  78         int (*init)(struct hidled_device *ldev);
  79         int (*write)(struct led_classdev *cdev, enum led_brightness br);
  80 };
  81
  82 struct hidled_led {
  83         struct led_classdev     cdev;
  84         struct hidled_rgb       *rgb;
  85         char                    name[32];
  86 };
  87
  88 struct hidled_rgb {
  89         struct hidled_device    *ldev;
  90         struct hidled_led       red;
  91         struct hidled_led       green;
  92         struct hidled_led       blue;
  93         u8                      num;
  94 };
  95
  96 struct hidled_device {
  97         const struct hidled_config *config;
  98         struct hid_device       *hdev;
  99         struct hidled_rgb       *rgb;
 100         u8                      *buf;
 101         struct mutex            lock;
 102 };
 103
 104 #define MAX_REPORT_SIZE         16
 105
 106 #define to_hidled_led(arg) container_of(arg, struct hidled_led, cdev)
 107
 108 static bool riso_kagaku_switch_green_blue;
 109 module_param(riso_kagaku_switch_green_blue, bool, S_IRUGO | S_IWUSR);
 110 MODULE_PARM_DESC(riso_kagaku_switch_green_blue,
 111         "switch green and blue RGB component for Riso Kagaku devices");
 112
 113 static int hidled_send(struct hidled_device *ldev, __u8 *buf)
 114 {
 115         int ret;
 116
 117         mutex_lock(&ldev->lock);
 118
 119         /*
 120          * buffer provided to hid_hw_raw_request must not be on the stack
 121          * and must not be part of a data structure
 122          */
 123         memcpy(ldev->buf, buf, ldev->config->report_size);
 124
 125         if (ldev->config->report_type == RAW_REQUEST)
 126                 ret = hid_hw_raw_request(ldev->hdev, buf[0], ldev->buf,
 127                                          ldev->config->report_size,
 128                                          HID_FEATURE_REPORT,
 129                                          HID_REQ_SET_REPORT);
 130         else if (ldev->config->report_type == OUTPUT_REPORT)
 131                 ret = hid_hw_output_report(ldev->hdev, ldev->buf,
 132                                            ldev->config->report_size);
 133         else
 134                 ret = -EINVAL;
 135
 136         mutex_unlock(&ldev->lock);
 137
 138         if (ret < 0)
 139                 return ret;
 140
 141         return ret == ldev->config->report_size ? 0 : -EMSGSIZE;
 142 }
 143
 144 /* reading data is supported for report type RAW_REQUEST only */
 145 static int hidled_recv(struct hidled_device *ldev, __u8 *buf)
 146 {
 147         int ret;
 148
 149         if (ldev->config->report_type != RAW_REQUEST)
 150                 return -EINVAL;
 151
 152         mutex_lock(&ldev->lock);
 153
 154         memcpy(ldev->buf, buf, ldev->config->report_size);
 155
 156         ret = hid_hw_raw_request(ldev->hdev, buf[0], ldev->buf,
 157                                  ldev->config->report_size,
 158                                  HID_FEATURE_REPORT,
 159                                  HID_REQ_SET_REPORT);
 160         if (ret < 0)
 161                 goto err;
 162
 163         ret = hid_hw_raw_request(ldev->hdev, buf[0], ldev->buf,
 164                                  ldev->config->report_size,
 165                                  HID_FEATURE_REPORT,
 166                                  HID_REQ_GET_REPORT);
 167
 168         memcpy(buf, ldev->buf, ldev->config->report_size);
 169 err:
 170         mutex_unlock(&ldev->lock);
 171
 172         return ret < 0 ? ret : 0;
 173 }
 174
 175 static u8 riso_kagaku_index(struct hidled_rgb *rgb)
 176 {
 177         enum led_brightness r, g, b;
 178
 179         r = rgb->red.cdev.brightness;
 180         g = rgb->green.cdev.brightness;
 181         b = rgb->blue.cdev.brightness;
 182
 183         if (riso_kagaku_switch_green_blue)
 184                 return RISO_KAGAKU_IX(r, b, g);
 185         else
 186                 return RISO_KAGAKU_IX(r, g, b);
 187 }
 188
 189 static int riso_kagaku_write(struct led_classdev *cdev, enum led_brightness br)
 190 {
 191         struct hidled_led *led = to_hidled_led(cdev);
 192         struct hidled_rgb *rgb = led->rgb;
 193         __u8 buf[MAX_REPORT_SIZE] = {};
 194
 195         buf[1] = riso_kagaku_index(rgb);
 196
 197         return hidled_send(rgb->ldev, buf);
 198 }
 199
 200 static int dream_cheeky_write(struct led_classdev *cdev, enum led_brightness br)
 201 {
 202         struct hidled_led *led = to_hidled_led(cdev);
 203         struct hidled_rgb *rgb = led->rgb;
 204         __u8 buf[MAX_REPORT_SIZE] = {};
 205
 206         buf[1] = rgb->red.cdev.brightness;
 207         buf[2] = rgb->green.cdev.brightness;
 208         buf[3] = rgb->blue.cdev.brightness;
 209         buf[7] = 0x1a;
 210         buf[8] = 0x05;
 211
 212         return hidled_send(rgb->ldev, buf);
 213 }
 214
 215 static int dream_cheeky_init(struct hidled_device *ldev)
 216 {
 217         __u8 buf[MAX_REPORT_SIZE] = {};
 218
 219         /* Dream Cheeky magic */
 220         buf[1] = 0x1f;
 221         buf[2] = 0x02;
 222         buf[4] = 0x5f;
 223         buf[7] = 0x1a;
 224         buf[8] = 0x03;
 225
 226         return hidled_send(ldev, buf);
 227 }
 228
 229 static int _thingm_write(struct led_classdev *cdev, enum led_brightness br,
 230                          u8 offset)
 231 {
 232         struct hidled_led *led = to_hidled_led(cdev);
 233         __u8 buf[MAX_REPORT_SIZE] = { 1, 'c' };
 234
 235         buf[2] = led->rgb->red.cdev.brightness;
 236         buf[3] = led->rgb->green.cdev.brightness;
 237         buf[4] = led->rgb->blue.cdev.brightness;
 238         buf[7] = led->rgb->num + offset;
 239
 240         return hidled_send(led->rgb->ldev, buf);
 241 }
 242
 243 static int thingm_write_v1(struct led_classdev *cdev, enum led_brightness br)
 244 {
 245         return _thingm_write(cdev, br, 0);
 246 }
 247
 248 static int thingm_write(struct led_classdev *cdev, enum led_brightness br)
 249 {
 250         return _thingm_write(cdev, br, 1);
 251 }
 252
 253 static const struct hidled_config hidled_config_thingm_v1 = {
 254         .name = "ThingM blink(1) v1",
 255         .short_name = "thingm",
 256         .max_brightness = 255,
 257         .num_leds = 1,
 258         .report_size = 9,
 259         .report_type = RAW_REQUEST,
 260         .write = thingm_write_v1,
 261 };
 262
 263 static int thingm_init(struct hidled_device *ldev)
 264 {
 265         __u8 buf[MAX_REPORT_SIZE] = { 1, 'v' };
 266         int ret;
 267
 268         ret = hidled_recv(ldev, buf);
 269         if (ret)
 270                 return ret;
 271
 272         /* Check for firmware major version 1 */
 273         if (buf[3] == '1')
 274                 ldev->config = &hidled_config_thingm_v1;
 275
 276         return 0;
 277 }
 278
 279 static inline int delcom_get_lednum(const struct hidled_led *led)
 280 {
 281         if (led == &led->rgb->red)
 282                 return DELCOM_RED_LED;
 283         else if (led == &led->rgb->green)
 284                 return DELCOM_GREEN_LED;
 285         else
 286                 return DELCOM_BLUE_LED;
 287 }
 288
 289 static int delcom_enable_led(struct hidled_led *led)
 290 {
 291         union delcom_packet dp = { .tx.major_cmd = 101, .tx.minor_cmd = 12 };
 292
 293         dp.tx.data_lsb = 1 << delcom_get_lednum(led);
 294         dp.tx.data_msb = 0;
 295
 296         return hidled_send(led->rgb->ldev, dp.data);
 297 }
 298
 299 static int delcom_set_pwm(struct hidled_led *led)
 300 {
 301         union delcom_packet dp = { .tx.major_cmd = 101, .tx.minor_cmd = 34 };
 302
 303         dp.tx.data_lsb = delcom_get_lednum(led);
 304         dp.tx.data_msb = led->cdev.brightness;
 305
 306         return hidled_send(led->rgb->ldev, dp.data);
 307 }
 308
 309 static int delcom_write(struct led_classdev *cdev, enum led_brightness br)
 310 {
 311         struct hidled_led *led = to_hidled_led(cdev);
 312         int ret;
 313
 314         /*
 315          * enable LED
 316          * We can't do this in the init function already because the device
 317          * is internally reset later.
 318          */
 319         ret = delcom_enable_led(led);
 320         if (ret)
 321                 return ret;
 322
 323         return delcom_set_pwm(led);
 324 }
 325
 326 static int delcom_init(struct hidled_device *ldev)
 327 {
 328         union delcom_packet dp = { .rx.cmd = 104 };
 329         int ret;
 330
 331         ret = hidled_recv(ldev, dp.data);
 332         if (ret)
 333                 return ret;
 334         /*
 335          * Several Delcom devices share the same USB VID/PID
 336          * Check for family id 2 for Visual Signal Indicator
 337          */
 338         return le16_to_cpu(dp.fw.family_code) == 2 ? 0 : -ENODEV;
 339 }
 340
 341 static int luxafor_write(struct led_classdev *cdev, enum led_brightness br)
 342 {
 343         struct hidled_led *led = to_hidled_led(cdev);
 344         __u8 buf[MAX_REPORT_SIZE] = { [1] = 1 };
 345
 346         buf[2] = led->rgb->num + 1;
 347         buf[3] = led->rgb->red.cdev.brightness;
 348         buf[4] = led->rgb->green.cdev.brightness;
 349         buf[5] = led->rgb->blue.cdev.brightness;
 350
 351         return hidled_send(led->rgb->ldev, buf);
 352 }
 353
 354 static const struct hidled_config hidled_configs[] = {
 355         {
 356                 .type = RISO_KAGAKU,
 357                 .name = "Riso Kagaku Webmail Notifier",
 358                 .short_name = "riso_kagaku",
 359                 .max_brightness = 1,
 360                 .num_leds = 1,
 361                 .report_size = 6,
 362                 .report_type = OUTPUT_REPORT,
 363                 .write = riso_kagaku_write,
 364         },
 365         {
 366                 .type = DREAM_CHEEKY,
 367                 .name = "Dream Cheeky Webmail Notifier",
 368                 .short_name = "dream_cheeky",
 369                 .max_brightness = 31,
 370                 .num_leds = 1,
 371                 .report_size = 9,
 372                 .report_type = RAW_REQUEST,
 373                 .init = dream_cheeky_init,
 374                 .write = dream_cheeky_write,
 375         },
 376         {
 377                 .type = THINGM,
 378                 .name = "ThingM blink(1)",
 379                 .short_name = "thingm",
 380                 .max_brightness = 255,
 381                 .num_leds = 2,
 382                 .report_size = 9,
 383                 .report_type = RAW_REQUEST,
 384                 .init = thingm_init,
 385                 .write = thingm_write,
 386         },
 387         {
 388                 .type = DELCOM,
 389                 .name = "Delcom Visual Signal Indicator G2",
 390                 .short_name = "delcom",
 391                 .max_brightness = 100,
 392                 .num_leds = 1,
 393                 .report_size = 8,
 394                 .report_type = RAW_REQUEST,
 395                 .init = delcom_init,
 396                 .write = delcom_write,
 397         },
 398         {
 399                 .type = LUXAFOR,
 400                 .name = "Greynut Luxafor",
 401                 .short_name = "luxafor",
 402                 .max_brightness = 255,
 403                 .num_leds = 6,
 404                 .report_size = 9,
 405                 .report_type = OUTPUT_REPORT,
 406                 .write = luxafor_write,
 407         },
 408 };
 409
 410 static int hidled_init_led(struct hidled_led *led, const char *color_name,
 411                            struct hidled_rgb *rgb, unsigned int minor)
 412 {
 413         const struct hidled_config *config = rgb->ldev->config;
 414
 415         if (config->num_leds > 1)
 416                 snprintf(led->name, sizeof(led->name), "%s%u:%s:led%u",
 417                          config->short_name, minor, color_name, rgb->num);
 418         else
 419                 snprintf(led->name, sizeof(led->name), "%s%u:%s",
 420                          config->short_name, minor, color_name);
 421         led->cdev.name = led->name;
 422         led->cdev.max_brightness = config->max_brightness;
 423         led->cdev.brightness_set_blocking = config->write;
 424         led->cdev.flags = LED_HW_PLUGGABLE;
 425         led->rgb = rgb;
 426
 427         return devm_led_classdev_register(&rgb->ldev->hdev->dev, &led->cdev);
 428 }
 429
 430 static int hidled_init_rgb(struct hidled_rgb *rgb, unsigned int minor)
 431 {
 432         int ret;
 433
 434         /* Register the red diode */
 435         ret = hidled_init_led(&rgb->red, "red", rgb, minor);
 436         if (ret)
 437                 return ret;
 438
 439         /* Register the green diode */
 440         ret = hidled_init_led(&rgb->green, "green", rgb, minor);
 441         if (ret)
 442                 return ret;
 443
 444         /* Register the blue diode */
 445         return hidled_init_led(&rgb->blue, "blue", rgb, minor);
 446 }
 447
 448 static int hidled_probe(struct hid_device *hdev, const struct hid_device_id *id)
 449 {
 450         struct hidled_device *ldev;
 451         unsigned int minor;
 452         int ret, i;
 453
 454         ldev = devm_kzalloc(&hdev->dev, sizeof(*ldev), GFP_KERNEL);
 455         if (!ldev)
 456                 return -ENOMEM;
 457
 458         ldev->buf = devm_kmalloc(&hdev->dev, MAX_REPORT_SIZE, GFP_KERNEL);
 459         if (!ldev->buf)
 460                 return -ENOMEM;
 461
 462         ret = hid_parse(hdev);
 463         if (ret)
 464                 return ret;
 465
 466         ldev->hdev = hdev;
 467         mutex_init(&ldev->lock);
 468
 469         for (i = 0; !ldev->config && i < ARRAY_SIZE(hidled_configs); i++)
 470                 if (hidled_configs[i].type == id->driver_data)
 471                         ldev->config = &hidled_configs[i];
 472
 473         if (!ldev->config)
 474                 return -EINVAL;
 475
 476         if (ldev->config->init) {
 477                 ret = ldev->config->init(ldev);
 478                 if (ret)
 479                         return ret;
 480         }
 481
 482         ldev->rgb = devm_kcalloc(&hdev->dev, ldev->config->num_leds,
 483                                  sizeof(struct hidled_rgb), GFP_KERNEL);
 484         if (!ldev->rgb)
 485                 return -ENOMEM;
 486
 487         ret = hid_hw_start(hdev, HID_CONNECT_HIDRAW);
 488         if (ret)
 489                 return ret;
 490
 491         minor = ((struct hidraw *) hdev->hidraw)->minor;
 492
 493         for (i = 0; i < ldev->config->num_leds; i++) {
 494                 ldev->rgb[i].ldev = ldev;
 495                 ldev->rgb[i].num = i;
 496                 ret = hidled_init_rgb(&ldev->rgb[i], minor);
 497                 if (ret) {
 498                         hid_hw_stop(hdev);
 499                         return ret;
 500                 }
 501         }
 502
 503         hid_info(hdev, "%s initialized\n", ldev->config->name);
 504
 505         return 0;
 506 }
 507
 508 static const struct hid_device_id hidled_table[] = {
 509         { HID_USB_DEVICE(USB_VENDOR_ID_RISO_KAGAKU,
 510           USB_DEVICE_ID_RI_KA_WEBMAIL), .driver_data = RISO_KAGAKU },
 511         { HID_USB_DEVICE(USB_VENDOR_ID_DREAM_CHEEKY,
 512           USB_DEVICE_ID_DREAM_CHEEKY_WN), .driver_data = DREAM_CHEEKY },
 513         { HID_USB_DEVICE(USB_VENDOR_ID_DREAM_CHEEKY,
 514           USB_DEVICE_ID_DREAM_CHEEKY_FA), .driver_data = DREAM_CHEEKY },
 515         { HID_USB_DEVICE(USB_VENDOR_ID_THINGM,
 516           USB_DEVICE_ID_BLINK1), .driver_data = THINGM },
 517         { HID_USB_DEVICE(USB_VENDOR_ID_DELCOM,
 518           USB_DEVICE_ID_DELCOM_VISUAL_IND), .driver_data = DELCOM },
 519         { HID_USB_DEVICE(USB_VENDOR_ID_MICROCHIP,
 520           USB_DEVICE_ID_LUXAFOR), .driver_data = LUXAFOR },
 521         { }
 522 };
 523 MODULE_DEVICE_TABLE(hid, hidled_table);
 524
 525 static struct hid_driver hidled_driver = {
 526         .name = "hid-led",
 527         .probe = hidled_probe,
 528         .id_table = hidled_table,
 529 };
 530
 531 module_hid_driver(hidled_driver);
 532
 533 MODULE_LICENSE("GPL");
 534 MODULE_AUTHOR("Heiner Kallweit <hkallweit1@gmail.com>");
 535 MODULE_DESCRIPTION("Simple USB RGB LED driver");