linux/drivers/hid/hid-thingm.c
<<
>>
Prefs
   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 */
  33struct 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
  42static 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
  57static 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
  78static 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
  88static 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
  95static 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
 103static 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
 124static DEVICE_ATTR(rgb, S_IRUGO | S_IWUSR, blink1_show_rgb, blink1_store_rgb);
 125
 126static 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
 134static 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
 155static DEVICE_ATTR(fade, S_IRUGO | S_IWUSR,
 156                blink1_show_fade, blink1_store_fade);
 157
 158static 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
 166static 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
 185static DEVICE_ATTR(play, S_IRUGO | S_IWUSR,
 186                blink1_show_play, blink1_store_play);
 187
 188static 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
 197static 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
 236remove_led:
 237        led_classdev_unregister(led);
 238stop:
 239        hid_hw_stop(hdev);
 240error:
 241        return ret;
 242}
 243
 244static 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
 254static const struct hid_device_id thingm_table[] = {
 255        { HID_USB_DEVICE(USB_VENDOR_ID_THINGM, USB_DEVICE_ID_BLINK1) },
 256        { }
 257};
 258MODULE_DEVICE_TABLE(hid, thingm_table);
 259
 260static struct hid_driver thingm_driver = {
 261        .name = "thingm",
 262        .probe = thingm_probe,
 263        .remove = thingm_remove,
 264        .id_table = thingm_table,
 265};
 266
 267module_hid_driver(thingm_driver);
 268
 269MODULE_LICENSE("GPL");
 270MODULE_AUTHOR("Vivien Didelot <vivien.didelot@savoirfairelinux.com>");
 271MODULE_DESCRIPTION("ThingM blink(1) USB RGB LED driver");
 272
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.