drivers/hid/hid-thingm.c

   1 /*
   2  * ThingM blink(1) USB RGB LED driver
   3  *
   4  * Copyright 2013 Savoir-faire Linux Inc.
   5  *      Vivien Didelot <vivien.didelot@savoirfairelinux.com>
   6  *
   7  * This program is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU General Public License as
   9  * published by the Free Software Foundation, version 2.
  10  */
  11
  12 #include <linux/hid.h>
  13 #include <linux/leds.h>
  14 #include <linux/module.h>
  15
  16 #include "hid-ids.h"
  17
  18 #define BLINK1_CMD_SIZE         9
  19
  20 #define blink1_rgb_to_r(rgb)    ((rgb & 0xFF0000) >> 16)
  21 #define blink1_rgb_to_g(rgb)    ((rgb & 0x00FF00) >> 8)
  22 #define blink1_rgb_to_b(rgb)    ((rgb & 0x0000FF) >> 0)
  23
  24 /**
  25  * struct blink1_data - blink(1) device specific data
  26  * @hdev:               HID device.
  27  * @led_cdev:           LED class instance.
  28  * @rgb:                8-bit per channel RGB notation.
  29  * @fade:               fade time in hundredths of a second.
  30  * @brightness:         brightness coefficient.
  31  * @play:               play/pause in-memory patterns.
  32  */
  33 struct blink1_data {
  34         struct hid_device *hdev;
  35         struct led_classdev led_cdev;
  36         u32 rgb;
  37         u16 fade;
  38         u8 brightness;
  39         bool play;
  40 };
  41
  42 static int blink1_send_command(struct blink1_data *data,
  43                 u8 buf[BLINK1_CMD_SIZE])
  44 {
  45         int ret;
  46
  47         hid_dbg(data->hdev, "command: %d%c%.2x%.2x%.2x%.2x%.2x%.2x%.2x\n",
  48                         buf[0], buf[1], buf[2], buf[3], buf[4],
  49                         buf[5], buf[6], buf[7], buf[8]);
  50
  51         ret = data->hdev->hid_output_raw_report(data->hdev, buf,
  52                         BLINK1_CMD_SIZE, HID_FEATURE_REPORT);
  53
  54         return ret < 0 ? ret : 0;
  55 }
  56
  57 static int blink1_update_color(struct blink1_data *data)
  58 {
  59         u8 buf[BLINK1_CMD_SIZE] = { 1, 'n', 0, 0, 0, 0, 0, 0, 0 };
  60
  61         if (data->brightness) {
  62                 unsigned int coef = DIV_ROUND_CLOSEST(255, data->brightness);
  63
  64                 buf[2] = DIV_ROUND_CLOSEST(blink1_rgb_to_r(data->rgb), coef);
  65                 buf[3] = DIV_ROUND_CLOSEST(blink1_rgb_to_g(data->rgb), coef);
  66                 buf[4] = DIV_ROUND_CLOSEST(blink1_rgb_to_b(data->rgb), coef);
  67         }
  68
  69         if (data->fade) {
  70                 buf[1] = 'c';
  71                 buf[5] = (data->fade & 0xFF00) >> 8;
  72                 buf[6] = (data->fade & 0x00FF);
  73         }
  74
  75         return blink1_send_command(data, buf);
  76 }
  77
  78 static void blink1_led_set(struct led_classdev *led_cdev,
  79                 enum led_brightness brightness)
  80 {
  81         struct blink1_data *data = dev_get_drvdata(led_cdev->dev->parent);
  82
  83         data->brightness = brightness;
  84         if (blink1_update_color(data))
  85                 hid_err(data->hdev, "failed to update color\n");
  86 }
  87
  88 static enum led_brightness blink1_led_get(struct led_classdev *led_cdev)
  89 {
  90         struct blink1_data *data = dev_get_drvdata(led_cdev->dev->parent);
  91
  92         return data->brightness;
  93 }
  94
  95 static ssize_t blink1_show_rgb(struct device *dev,
  96                 struct device_attribute *attr, char *buf)
  97 {
  98         struct blink1_data *data = dev_get_drvdata(dev->parent);
  99
 100         return sprintf(buf, "%.6X\n", data->rgb);
 101 }
 102
 103 static ssize_t blink1_store_rgb(struct device *dev,
 104                 struct device_attribute *attr, const char *buf, size_t count)
 105 {
 106         struct blink1_data *data = dev_get_drvdata(dev->parent);
 107         long unsigned int rgb;
 108         int ret;
 109
 110         ret = kstrtoul(buf, 16, &rgb);
 111         if (ret)
 112                 return ret;
 113
 114         /* RGB triplet notation is 24-bit hexadecimal */
 115         if (rgb > 0xFFFFFF)
 116                 return -EINVAL;
 117
 118         data->rgb = rgb;
 119         ret = blink1_update_color(data);
 120
 121         return ret ? ret : count;
 122 }
 123
 124 static DEVICE_ATTR(rgb, S_IRUGO | S_IWUSR, blink1_show_rgb, blink1_store_rgb);
 125
 126 static ssize_t blink1_show_fade(struct device *dev,
 127                 struct device_attribute *attr, char *buf)
 128 {
 129         struct blink1_data *data = dev_get_drvdata(dev->parent);
 130
 131         return sprintf(buf, "%d\n", data->fade * 10);
 132 }
 133
 134 static ssize_t blink1_store_fade(struct device *dev,
 135                 struct device_attribute *attr, const char *buf, size_t count)
 136 {
 137         struct blink1_data *data = dev_get_drvdata(dev->parent);
 138         long unsigned int fade;
 139         int ret;
 140
 141         ret = kstrtoul(buf, 10, &fade);
 142         if (ret)
 143                 return ret;
 144
 145         /* blink(1) accepts 16-bit fade time, number of 10ms ticks */
 146         fade = DIV_ROUND_CLOSEST(fade, 10);
 147         if (fade > 65535)
 148                 return -EINVAL;
 149
 150         data->fade = fade;
 151
 152         return count;
 153 }
 154
 155 static DEVICE_ATTR(fade, S_IRUGO | S_IWUSR,
 156                 blink1_show_fade, blink1_store_fade);
 157
 158 static ssize_t blink1_show_play(struct device *dev,
 159                 struct device_attribute *attr, char *buf)
 160 {
 161         struct blink1_data *data = dev_get_drvdata(dev->parent);
 162
 163         return sprintf(buf, "%d\n", data->play);
 164 }
 165
 166 static ssize_t blink1_store_play(struct device *dev,
 167                 struct device_attribute *attr, const char *buf, size_t count)
 168 {
 169         struct blink1_data *data = dev_get_drvdata(dev->parent);
 170         u8 cmd[BLINK1_CMD_SIZE] = { 1, 'p', 0, 0, 0, 0, 0, 0, 0 };
 171         long unsigned int play;
 172         int ret;
 173
 174         ret = kstrtoul(buf, 10, &play);
 175         if (ret)
 176                 return ret;
 177
 178         data->play = !!play;
 179         cmd[2] = data->play;
 180         ret = blink1_send_command(data, cmd);
 181
 182         return ret ? ret : count;
 183 }
 184
 185 static DEVICE_ATTR(play, S_IRUGO | S_IWUSR,
 186                 blink1_show_play, blink1_store_play);
 187
 188 static const struct attribute_group blink1_sysfs_group = {
 189         .attrs = (struct attribute *[]) {
 190                 &dev_attr_rgb.attr,
 191                 &dev_attr_fade.attr,
 192                 &dev_attr_play.attr,
 193                 NULL
 194         },
 195 };
 196
 197 static int thingm_probe(struct hid_device *hdev, const struct hid_device_id *id)
 198 {
 199         struct blink1_data *data;
 200         struct led_classdev *led;
 201         char led_name[13];
 202         int ret;
 203
 204         data = devm_kzalloc(&hdev->dev, sizeof(struct blink1_data), GFP_KERNEL);
 205         if (!data)
 206                 return -ENOMEM;
 207
 208         hid_set_drvdata(hdev, data);
 209         data->hdev = hdev;
 210         data->rgb = 0xFFFFFF; /* set a default white color */
 211
 212         ret = hid_parse(hdev);
 213         if (ret)
 214                 goto error;
 215
 216         ret = hid_hw_start(hdev, HID_CONNECT_HIDRAW);
 217         if (ret)
 218                 goto error;
 219
 220         /* blink(1) serial numbers range is 0x1A001000 to 0x1A002FFF */
 221         led = &data->led_cdev;
 222         snprintf(led_name, sizeof(led_name), "blink1::%s", hdev->uniq + 4);
 223         led->name = led_name;
 224         led->brightness_set = blink1_led_set;
 225         led->brightness_get = blink1_led_get;
 226         ret = led_classdev_register(&hdev->dev, led);
 227         if (ret)
 228                 goto stop;
 229
 230         ret = sysfs_create_group(&led->dev->kobj, &blink1_sysfs_group);
 231         if (ret)
 232                 goto remove_led;
 233
 234         return 0;
 235
 236 remove_led:
 237         led_classdev_unregister(led);
 238 stop:
 239         hid_hw_stop(hdev);
 240 error:
 241         return ret;
 242 }
 243
 244 static void thingm_remove(struct hid_device *hdev)
 245 {
 246         struct blink1_data *data = hid_get_drvdata(hdev);
 247         struct led_classdev *led = &data->led_cdev;
 248
 249         sysfs_remove_group(&led->dev->kobj, &blink1_sysfs_group);
 250         led_classdev_unregister(led);
 251         hid_hw_stop(hdev);
 252 }
 253
 254 static const struct hid_device_id thingm_table[] = {
 255         { HID_USB_DEVICE(USB_VENDOR_ID_THINGM, USB_DEVICE_ID_BLINK1) },
 256         { }
 257 };
 258 MODULE_DEVICE_TABLE(hid, thingm_table);
 259
 260 static struct hid_driver thingm_driver = {
 261         .name = "thingm",
 262         .probe = thingm_probe,
 263         .remove = thingm_remove,
 264         .id_table = thingm_table,
 265 };
 266
 267 module_hid_driver(thingm_driver);
 268
 269 MODULE_LICENSE("GPL");
 270 MODULE_AUTHOR("Vivien Didelot <vivien.didelot@savoirfairelinux.com>");
 271 MODULE_DESCRIPTION("ThingM blink(1) USB RGB LED driver");