drivers/leds/leds-blinkm.c

   1 /*
   2  *  leds-blinkm.c
   3  *  (c) Jan-Simon Möller (dl9pf@gmx.de)
   4  *
   5  *  This program is free software; you can redistribute it and/or modify
   6  *  it under the terms of the GNU General Public License as published by
   7  *  the Free Software Foundation; either version 2 of the License, or
   8  *  (at your option) any later version.
   9  *
  10  *  This program is distributed in the hope that it will be useful,
  11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  *  GNU General Public License for more details.
  14  *
  15  *  You should have received a copy of the GNU General Public License
  16  *  along with this program; if not, write to the Free Software
  17  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18  */
  19
  20 #include <linux/module.h>
  21 #include <linux/slab.h>
  22 #include <linux/jiffies.h>
  23 #include <linux/i2c.h>
  24 #include <linux/err.h>
  25 #include <linux/mutex.h>
  26 #include <linux/sysfs.h>
  27 #include <linux/printk.h>
  28 #include <linux/pm_runtime.h>
  29 #include <linux/leds.h>
  30 #include <linux/delay.h>
  31
  32 /* Addresses to scan - BlinkM is on 0x09 by default*/
  33 static const unsigned short normal_i2c[] = { 0x09, I2C_CLIENT_END };
  34
  35 static int blinkm_transfer_hw(struct i2c_client *client, int cmd);
  36 static int blinkm_test_run(struct i2c_client *client);
  37
  38 struct blinkm_led {
  39         struct i2c_client *i2c_client;
  40         struct led_classdev led_cdev;
  41         int id;
  42         atomic_t active;
  43 };
  44
  45 struct blinkm_work {
  46         struct blinkm_led *blinkm_led;
  47         struct work_struct work;
  48 };
  49
  50 #define cdev_to_blmled(c)          container_of(c, struct blinkm_led, led_cdev)
  51 #define work_to_blmwork(c)         container_of(c, struct blinkm_work, work)
  52
  53 struct blinkm_data {
  54         struct i2c_client *i2c_client;
  55         struct mutex update_lock;
  56         /* used for led class interface */
  57         struct blinkm_led blinkm_leds[3];
  58         /* used for "blinkm" sysfs interface */
  59         u8 red;                 /* color red */
  60         u8 green;               /* color green */
  61         u8 blue;                /* color blue */
  62         /* next values to use for transfer */
  63         u8 next_red;                    /* color red */
  64         u8 next_green;          /* color green */
  65         u8 next_blue;           /* color blue */
  66         /* internal use */
  67         u8 args[7];             /* set of args for transmission */
  68         u8 i2c_addr;            /* i2c addr */
  69         u8 fw_ver;              /* firmware version */
  70         /* used, but not from userspace */
  71         u8 hue;                 /* HSB  hue */
  72         u8 saturation;          /* HSB  saturation */
  73         u8 brightness;          /* HSB  brightness */
  74         u8 next_hue;                    /* HSB  hue */
  75         u8 next_saturation;             /* HSB  saturation */
  76         u8 next_brightness;             /* HSB  brightness */
  77         /* currently unused / todo */
  78         u8 fade_speed;          /* fade speed     1 - 255 */
  79         s8 time_adjust;         /* time adjust -128 - 127 */
  80         u8 fade:1;              /* fade on = 1, off = 0 */
  81         u8 rand:1;              /* rand fade mode on = 1 */
  82         u8 script_id;           /* script ID */
  83         u8 script_repeats;      /* repeats of script */
  84         u8 script_startline;    /* line to start */
  85 };
  86
  87 /* Colors */
  88 #define RED   0
  89 #define GREEN 1
  90 #define BLUE  2
  91
  92 /* mapping command names to cmd chars - see datasheet */
  93 #define BLM_GO_RGB            0
  94 #define BLM_FADE_RGB          1
  95 #define BLM_FADE_HSB          2
  96 #define BLM_FADE_RAND_RGB     3
  97 #define BLM_FADE_RAND_HSB     4
  98 #define BLM_PLAY_SCRIPT       5
  99 #define BLM_STOP_SCRIPT       6
 100 #define BLM_SET_FADE_SPEED    7
 101 #define BLM_SET_TIME_ADJ      8
 102 #define BLM_GET_CUR_RGB       9
 103 #define BLM_WRITE_SCRIPT_LINE 10
 104 #define BLM_READ_SCRIPT_LINE  11
 105 #define BLM_SET_SCRIPT_LR     12        /* Length & Repeats */
 106 #define BLM_SET_ADDR          13
 107 #define BLM_GET_ADDR          14
 108 #define BLM_GET_FW_VER        15
 109 #define BLM_SET_STARTUP_PARAM 16
 110
 111 /* BlinkM Commands
 112  *  as extracted out of the datasheet:
 113  *
 114  *  cmdchar = command (ascii)
 115  *  cmdbyte = command in hex
 116  *  nr_args = number of arguments (to send)
 117  *  nr_ret  = number of return values (to read)
 118  *  dir = direction (0 = read, 1 = write, 2 = both)
 119  *
 120  */
 121 static const struct {
 122         char cmdchar;
 123         u8 cmdbyte;
 124         u8 nr_args;
 125         u8 nr_ret;
 126         u8 dir:2;
 127 } blinkm_cmds[17] = {
 128   /* cmdchar, cmdbyte, nr_args, nr_ret,  dir */
 129         { 'n', 0x6e, 3, 0, 1},
 130         { 'c', 0x63, 3, 0, 1},
 131         { 'h', 0x68, 3, 0, 1},
 132         { 'C', 0x43, 3, 0, 1},
 133         { 'H', 0x48, 3, 0, 1},
 134         { 'p', 0x70, 3, 0, 1},
 135         { 'o', 0x6f, 0, 0, 1},
 136         { 'f', 0x66, 1, 0, 1},
 137         { 't', 0x74, 1, 0, 1},
 138         { 'g', 0x67, 0, 3, 0},
 139         { 'W', 0x57, 7, 0, 1},
 140         { 'R', 0x52, 2, 5, 2},
 141         { 'L', 0x4c, 3, 0, 1},
 142         { 'A', 0x41, 4, 0, 1},
 143         { 'a', 0x61, 0, 1, 0},
 144         { 'Z', 0x5a, 0, 1, 0},
 145         { 'B', 0x42, 5, 0, 1},
 146 };
 147
 148 static ssize_t show_color_common(struct device *dev, char *buf, int color)
 149 {
 150         struct i2c_client *client;
 151         struct blinkm_data *data;
 152         int ret;
 153
 154         client = to_i2c_client(dev);
 155         data = i2c_get_clientdata(client);
 156
 157         ret = blinkm_transfer_hw(client, BLM_GET_CUR_RGB);
 158         if (ret < 0)
 159                 return ret;
 160         switch (color) {
 161         case RED:
 162                 return scnprintf(buf, PAGE_SIZE, "%02X\n", data->red);
 163         case GREEN:
 164                 return scnprintf(buf, PAGE_SIZE, "%02X\n", data->green);
 165         case BLUE:
 166                 return scnprintf(buf, PAGE_SIZE, "%02X\n", data->blue);
 167         default:
 168                 return -EINVAL;
 169         }
 170         return -EINVAL;
 171 }
 172
 173 static int store_color_common(struct device *dev, const char *buf, int color)
 174 {
 175         struct i2c_client *client;
 176         struct blinkm_data *data;
 177         int ret;
 178         u8 value;
 179
 180         client = to_i2c_client(dev);
 181         data = i2c_get_clientdata(client);
 182
 183         ret = kstrtou8(buf, 10, &value);
 184         if (ret < 0) {
 185                 dev_err(dev, "BlinkM: value too large!\n");
 186                 return ret;
 187         }
 188
 189         switch (color) {
 190         case RED:
 191                 data->next_red = value;
 192                 break;
 193         case GREEN:
 194                 data->next_green = value;
 195                 break;
 196         case BLUE:
 197                 data->next_blue = value;
 198                 break;
 199         default:
 200                 return -EINVAL;
 201         }
 202
 203         dev_dbg(dev, "next_red = %d, next_green = %d, next_blue = %d\n",
 204                         data->next_red, data->next_green, data->next_blue);
 205
 206         /* if mode ... */
 207         ret = blinkm_transfer_hw(client, BLM_GO_RGB);
 208         if (ret < 0) {
 209                 dev_err(dev, "BlinkM: can't set RGB\n");
 210                 return ret;
 211         }
 212         return 0;
 213 }
 214
 215 static ssize_t show_red(struct device *dev, struct device_attribute *attr,
 216                         char *buf)
 217 {
 218         return show_color_common(dev, buf, RED);
 219 }
 220
 221 static ssize_t store_red(struct device *dev, struct device_attribute *attr,
 222                          const char *buf, size_t count)
 223 {
 224         int ret;
 225
 226         ret = store_color_common(dev, buf, RED);
 227         if (ret < 0)
 228                 return ret;
 229         return count;
 230 }
 231
 232 static DEVICE_ATTR(red, S_IRUGO | S_IWUSR, show_red, store_red);
 233
 234 static ssize_t show_green(struct device *dev, struct device_attribute *attr,
 235                           char *buf)
 236 {
 237         return show_color_common(dev, buf, GREEN);
 238 }
 239
 240 static ssize_t store_green(struct device *dev, struct device_attribute *attr,
 241                            const char *buf, size_t count)
 242 {
 243
 244         int ret;
 245
 246         ret = store_color_common(dev, buf, GREEN);
 247         if (ret < 0)
 248                 return ret;
 249         return count;
 250 }
 251
 252 static DEVICE_ATTR(green, S_IRUGO | S_IWUSR, show_green, store_green);
 253
 254 static ssize_t show_blue(struct device *dev, struct device_attribute *attr,
 255                          char *buf)
 256 {
 257         return show_color_common(dev, buf, BLUE);
 258 }
 259
 260 static ssize_t store_blue(struct device *dev, struct device_attribute *attr,
 261                           const char *buf, size_t count)
 262 {
 263         int ret;
 264
 265         ret = store_color_common(dev, buf, BLUE);
 266         if (ret < 0)
 267                 return ret;
 268         return count;
 269 }
 270
 271 static DEVICE_ATTR(blue, S_IRUGO | S_IWUSR, show_blue, store_blue);
 272
 273 static ssize_t show_test(struct device *dev, struct device_attribute *attr,
 274                          char *buf)
 275 {
 276         return scnprintf(buf, PAGE_SIZE,
 277                          "#Write into test to start test sequence!#\n");
 278 }
 279
 280 static ssize_t store_test(struct device *dev, struct device_attribute *attr,
 281                           const char *buf, size_t count)
 282 {
 283
 284         struct i2c_client *client;
 285         int ret;
 286         client = to_i2c_client(dev);
 287
 288         /*test */
 289         ret = blinkm_test_run(client);
 290         if (ret < 0)
 291                 return ret;
 292
 293         return count;
 294 }
 295
 296 static DEVICE_ATTR(test, S_IRUGO | S_IWUSR, show_test, store_test);
 297
 298 /* TODO: HSB, fade, timeadj, script ... */
 299
 300 static struct attribute *blinkm_attrs[] = {
 301         &dev_attr_red.attr,
 302         &dev_attr_green.attr,
 303         &dev_attr_blue.attr,
 304         &dev_attr_test.attr,
 305         NULL,
 306 };
 307
 308 static struct attribute_group blinkm_group = {
 309         .name = "blinkm",
 310         .attrs = blinkm_attrs,
 311 };
 312
 313 static int blinkm_write(struct i2c_client *client, int cmd, u8 *arg)
 314 {
 315         int result;
 316         int i;
 317         int arglen = blinkm_cmds[cmd].nr_args;
 318         /* write out cmd to blinkm - always / default step */
 319         result = i2c_smbus_write_byte(client, blinkm_cmds[cmd].cmdbyte);
 320         if (result < 0)
 321                 return result;
 322         /* no args to write out */
 323         if (arglen == 0)
 324                 return 0;
 325
 326         for (i = 0; i < arglen; i++) {
 327                 /* repeat for arglen */
 328                 result = i2c_smbus_write_byte(client, arg[i]);
 329                 if (result < 0)
 330                         return result;
 331         }
 332         return 0;
 333 }
 334
 335 static int blinkm_read(struct i2c_client *client, int cmd, u8 *arg)
 336 {
 337         int result;
 338         int i;
 339         int retlen = blinkm_cmds[cmd].nr_ret;
 340         for (i = 0; i < retlen; i++) {
 341                 /* repeat for retlen */
 342                 result = i2c_smbus_read_byte(client);
 343                 if (result < 0)
 344                         return result;
 345                 arg[i] = result;
 346         }
 347
 348         return 0;
 349 }
 350
 351 static int blinkm_transfer_hw(struct i2c_client *client, int cmd)
 352 {
 353         /* the protocol is simple but non-standard:
 354          * e.g.  cmd 'g' (= 0x67) for "get device address"
 355          * - which defaults to 0x09 - would be the sequence:
 356          *   a) write 0x67 to the device (byte write)
 357          *   b) read the value (0x09) back right after (byte read)
 358          *
 359          * Watch out for "unfinished" sequences (i.e. not enough reads
 360          * or writes after a command. It will make the blinkM misbehave.
 361          * Sequence is key here.
 362          */
 363
 364         /* args / return are in private data struct */
 365         struct blinkm_data *data = i2c_get_clientdata(client);
 366
 367         /* We start hardware transfers which are not to be
 368          * mixed with other commands. Aquire a lock now. */
 369         if (mutex_lock_interruptible(&data->update_lock) < 0)
 370                 return -EAGAIN;
 371
 372         /* switch cmd - usually write before reads */
 373         switch (cmd) {
 374         case BLM_FADE_RAND_RGB:
 375         case BLM_GO_RGB:
 376         case BLM_FADE_RGB:
 377                 data->args[0] = data->next_red;
 378                 data->args[1] = data->next_green;
 379                 data->args[2] = data->next_blue;
 380                 blinkm_write(client, cmd, data->args);
 381                 data->red = data->args[0];
 382                 data->green = data->args[1];
 383                 data->blue = data->args[2];
 384                 break;
 385         case BLM_FADE_HSB:
 386         case BLM_FADE_RAND_HSB:
 387                 data->args[0] = data->next_hue;
 388                 data->args[1] = data->next_saturation;
 389                 data->args[2] = data->next_brightness;
 390                 blinkm_write(client, cmd, data->args);
 391                 data->hue = data->next_hue;
 392                 data->saturation = data->next_saturation;
 393                 data->brightness = data->next_brightness;
 394                 break;
 395         case BLM_PLAY_SCRIPT:
 396                 data->args[0] = data->script_id;
 397                 data->args[1] = data->script_repeats;
 398                 data->args[2] = data->script_startline;
 399                 blinkm_write(client, cmd, data->args);
 400                 break;
 401         case BLM_STOP_SCRIPT:
 402                 blinkm_write(client, cmd, NULL);
 403                 break;
 404         case BLM_GET_CUR_RGB:
 405                 data->args[0] = data->red;
 406                 data->args[1] = data->green;
 407                 data->args[2] = data->blue;
 408                 blinkm_write(client, cmd, NULL);
 409                 blinkm_read(client, cmd, data->args);
 410                 data->red = data->args[0];
 411                 data->green = data->args[1];
 412                 data->blue = data->args[2];
 413                 break;
 414         case BLM_GET_ADDR:
 415                 data->args[0] = data->i2c_addr;
 416                 blinkm_write(client, cmd, NULL);
 417                 blinkm_read(client, cmd, data->args);
 418                 data->i2c_addr = data->args[0];
 419                 break;
 420         case BLM_SET_TIME_ADJ:
 421         case BLM_SET_FADE_SPEED:
 422         case BLM_READ_SCRIPT_LINE:
 423         case BLM_WRITE_SCRIPT_LINE:
 424         case BLM_SET_SCRIPT_LR:
 425         case BLM_SET_ADDR:
 426         case BLM_GET_FW_VER:
 427         case BLM_SET_STARTUP_PARAM:
 428                 dev_err(&client->dev,
 429                                 "BlinkM: cmd %d not implemented yet.\n", cmd);
 430                 break;
 431         default:
 432                 dev_err(&client->dev, "BlinkM: unknown command %d\n", cmd);
 433                 mutex_unlock(&data->update_lock);
 434                 return -EINVAL;
 435         }                       /* end switch(cmd) */
 436
 437         /* transfers done, unlock */
 438         mutex_unlock(&data->update_lock);
 439         return 0;
 440 }
 441
 442 static void led_work(struct work_struct *work)
 443 {
 444         int ret;
 445         struct blinkm_led *led;
 446         struct blinkm_data *data;
 447         struct blinkm_work *blm_work = work_to_blmwork(work);
 448
 449         led = blm_work->blinkm_led;
 450         data = i2c_get_clientdata(led->i2c_client);
 451         ret = blinkm_transfer_hw(led->i2c_client, BLM_GO_RGB);
 452         atomic_dec(&led->active);
 453         dev_dbg(&led->i2c_client->dev,
 454                         "# DONE # next_red = %d, next_green = %d,"
 455                         " next_blue = %d, active = %d\n",
 456                         data->next_red, data->next_green,
 457                         data->next_blue, atomic_read(&led->active));
 458         kfree(blm_work);
 459 }
 460
 461 static int blinkm_led_common_set(struct led_classdev *led_cdev,
 462                                  enum led_brightness value, int color)
 463 {
 464         /* led_brightness is 0, 127 or 255 - we just use it here as-is */
 465         struct blinkm_led *led = cdev_to_blmled(led_cdev);
 466         struct blinkm_data *data = i2c_get_clientdata(led->i2c_client);
 467         struct blinkm_work *bl_work;
 468
 469         switch (color) {
 470         case RED:
 471                 /* bail out if there's no change */
 472                 if (data->next_red == (u8) value)
 473                         return 0;
 474                 /* we assume a quite fast sequence here ([off]->on->off)
 475                  * think of network led trigger - we cannot blink that fast, so
 476                  * in case we already have a off->on->off transition queued up,
 477                  * we refuse to queue up more.
 478                  * Revisit: fast-changing brightness. */
 479                 if (atomic_read(&led->active) > 1)
 480                         return 0;
 481                 data->next_red = (u8) value;
 482                 break;
 483         case GREEN:
 484                 /* bail out if there's no change */
 485                 if (data->next_green == (u8) value)
 486                         return 0;
 487                 /* we assume a quite fast sequence here ([off]->on->off)
 488                  * Revisit: fast-changing brightness. */
 489                 if (atomic_read(&led->active) > 1)
 490                         return 0;
 491                 data->next_green = (u8) value;
 492                 break;
 493         case BLUE:
 494                 /* bail out if there's no change */
 495                 if (data->next_blue == (u8) value)
 496                         return 0;
 497                 /* we assume a quite fast sequence here ([off]->on->off)
 498                  * Revisit: fast-changing brightness. */
 499                 if (atomic_read(&led->active) > 1)
 500                         return 0;
 501                 data->next_blue = (u8) value;
 502                 break;
 503
 504         default:
 505                 dev_err(&led->i2c_client->dev, "BlinkM: unknown color.\n");
 506                 return -EINVAL;
 507         }
 508
 509         bl_work = kzalloc(sizeof(*bl_work), GFP_ATOMIC);
 510         if (!bl_work)
 511                 return -ENOMEM;
 512
 513         atomic_inc(&led->active);
 514         dev_dbg(&led->i2c_client->dev,
 515                         "#TO_SCHED# next_red = %d, next_green = %d,"
 516                         " next_blue = %d, active = %d\n",
 517                         data->next_red, data->next_green,
 518                         data->next_blue, atomic_read(&led->active));
 519
 520         /* a fresh work _item_ for each change */
 521         bl_work->blinkm_led = led;
 522         INIT_WORK(&bl_work->work, led_work);
 523         /* queue work in own queue for easy sync on exit*/
 524         schedule_work(&bl_work->work);
 525
 526         return 0;
 527 }
 528
 529 static void blinkm_led_red_set(struct led_classdev *led_cdev,
 530                                enum led_brightness value)
 531 {
 532         blinkm_led_common_set(led_cdev, value, RED);
 533 }
 534
 535 static void blinkm_led_green_set(struct led_classdev *led_cdev,
 536                                  enum led_brightness value)
 537 {
 538         blinkm_led_common_set(led_cdev, value, GREEN);
 539 }
 540
 541 static void blinkm_led_blue_set(struct led_classdev *led_cdev,
 542                                 enum led_brightness value)
 543 {
 544         blinkm_led_common_set(led_cdev, value, BLUE);
 545 }
 546
 547 static void blinkm_init_hw(struct i2c_client *client)
 548 {
 549         int ret;
 550         ret = blinkm_transfer_hw(client, BLM_STOP_SCRIPT);
 551         ret = blinkm_transfer_hw(client, BLM_GO_RGB);
 552 }
 553
 554 static int blinkm_test_run(struct i2c_client *client)
 555 {
 556         int ret;
 557         struct blinkm_data *data = i2c_get_clientdata(client);
 558
 559         data->next_red = 0x01;
 560         data->next_green = 0x05;
 561         data->next_blue = 0x10;
 562         ret = blinkm_transfer_hw(client, BLM_GO_RGB);
 563         if (ret < 0)
 564                 return ret;
 565         msleep(2000);
 566
 567         data->next_red = 0x25;
 568         data->next_green = 0x10;
 569         data->next_blue = 0x31;
 570         ret = blinkm_transfer_hw(client, BLM_FADE_RGB);
 571         if (ret < 0)
 572                 return ret;
 573         msleep(2000);
 574
 575         data->next_hue = 0x50;
 576         data->next_saturation = 0x10;
 577         data->next_brightness = 0x20;
 578         ret = blinkm_transfer_hw(client, BLM_FADE_HSB);
 579         if (ret < 0)
 580                 return ret;
 581         msleep(2000);
 582
 583         return 0;
 584 }
 585
 586 /* Return 0 if detection is successful, -ENODEV otherwise */
 587 static int blinkm_detect(struct i2c_client *client, struct i2c_board_info *info)
 588 {
 589         struct i2c_adapter *adapter = client->adapter;
 590         int ret;
 591         int count = 99;
 592         u8 tmpargs[7];
 593
 594         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA
 595                                      | I2C_FUNC_SMBUS_WORD_DATA
 596                                      | I2C_FUNC_SMBUS_WRITE_BYTE))
 597                 return -ENODEV;
 598
 599         /* Now, we do the remaining detection. Simple for now. */
 600         /* We might need more guards to protect other i2c slaves */
 601
 602         /* make sure the blinkM is balanced (read/writes) */
 603         while (count > 0) {
 604                 ret = blinkm_write(client, BLM_GET_ADDR, NULL);
 605                 usleep_range(5000, 10000);
 606                 ret = blinkm_read(client, BLM_GET_ADDR, tmpargs);
 607                 usleep_range(5000, 10000);
 608                 if (tmpargs[0] == 0x09)
 609                         count = 0;
 610                 count--;
 611         }
 612
 613         /* Step 1: Read BlinkM address back  -  cmd_char 'a' */
 614         ret = blinkm_write(client, BLM_GET_ADDR, NULL);
 615         if (ret < 0)
 616                 return ret;
 617         usleep_range(20000, 30000);     /* allow a small delay */
 618         ret = blinkm_read(client, BLM_GET_ADDR, tmpargs);
 619         if (ret < 0)
 620                 return ret;
 621
 622         if (tmpargs[0] != 0x09) {
 623                 dev_err(&client->dev, "enodev DEV ADDR = 0x%02X\n", tmpargs[0]);
 624                 return -ENODEV;
 625         }
 626
 627         strlcpy(info->type, "blinkm", I2C_NAME_SIZE);
 628         return 0;
 629 }
 630
 631 static int blinkm_probe(struct i2c_client *client,
 632                         const struct i2c_device_id *id)
 633 {
 634         struct blinkm_data *data;
 635         struct blinkm_led *led[3];
 636         int err, i;
 637         char blinkm_led_name[28];
 638
 639         data = devm_kzalloc(&client->dev,
 640                         sizeof(struct blinkm_data), GFP_KERNEL);
 641         if (!data) {
 642                 err = -ENOMEM;
 643                 goto exit;
 644         }
 645
 646         data->i2c_addr = 0x09;
 647         data->i2c_addr = 0x08;
 648         /* i2c addr  - use fake addr of 0x08 initially (real is 0x09) */
 649         data->fw_ver = 0xfe;
 650         /* firmware version - use fake until we read real value
 651          * (currently broken - BlinkM confused!) */
 652         data->script_id = 0x01;
 653         data->i2c_client = client;
 654
 655         i2c_set_clientdata(client, data);
 656         mutex_init(&data->update_lock);
 657
 658         /* Register sysfs hooks */
 659         err = sysfs_create_group(&client->dev.kobj, &blinkm_group);
 660         if (err < 0) {
 661                 dev_err(&client->dev, "couldn't register sysfs group\n");
 662                 goto exit;
 663         }
 664
 665         for (i = 0; i < 3; i++) {
 666                 /* RED = 0, GREEN = 1, BLUE = 2 */
 667                 led[i] = &data->blinkm_leds[i];
 668                 led[i]->i2c_client = client;
 669                 led[i]->id = i;
 670                 led[i]->led_cdev.max_brightness = 255;
 671                 led[i]->led_cdev.flags = LED_CORE_SUSPENDRESUME;
 672                 atomic_set(&led[i]->active, 0);
 673                 switch (i) {
 674                 case RED:
 675                         snprintf(blinkm_led_name, sizeof(blinkm_led_name),
 676                                          "blinkm-%d-%d-red",
 677                                          client->adapter->nr,
 678                                          client->addr);
 679                         led[i]->led_cdev.name = blinkm_led_name;
 680                         led[i]->led_cdev.brightness_set = blinkm_led_red_set;
 681                         err = led_classdev_register(&client->dev,
 682                                                     &led[i]->led_cdev);
 683                         if (err < 0) {
 684                                 dev_err(&client->dev,
 685                                         "couldn't register LED %s\n",
 686                                         led[i]->led_cdev.name);
 687                                 goto failred;
 688                         }
 689                         break;
 690                 case GREEN:
 691                         snprintf(blinkm_led_name, sizeof(blinkm_led_name),
 692                                          "blinkm-%d-%d-green",
 693                                          client->adapter->nr,
 694                                          client->addr);
 695                         led[i]->led_cdev.name = blinkm_led_name;
 696                         led[i]->led_cdev.brightness_set = blinkm_led_green_set;
 697                         err = led_classdev_register(&client->dev,
 698                                                     &led[i]->led_cdev);
 699                         if (err < 0) {
 700                                 dev_err(&client->dev,
 701                                         "couldn't register LED %s\n",
 702                                         led[i]->led_cdev.name);
 703                                 goto failgreen;
 704                         }
 705                         break;
 706                 case BLUE:
 707                         snprintf(blinkm_led_name, sizeof(blinkm_led_name),
 708                                          "blinkm-%d-%d-blue",
 709                                          client->adapter->nr,
 710                                          client->addr);
 711                         led[i]->led_cdev.name = blinkm_led_name;
 712                         led[i]->led_cdev.brightness_set = blinkm_led_blue_set;
 713                         err = led_classdev_register(&client->dev,
 714                                                     &led[i]->led_cdev);
 715                         if (err < 0) {
 716                                 dev_err(&client->dev,
 717                                         "couldn't register LED %s\n",
 718                                         led[i]->led_cdev.name);
 719                                 goto failblue;
 720                         }
 721                         break;
 722                 }               /* end switch */
 723         }                       /* end for */
 724
 725         /* Initialize the blinkm */
 726         blinkm_init_hw(client);
 727
 728         return 0;
 729
 730 failblue:
 731         led_classdev_unregister(&led[GREEN]->led_cdev);
 732
 733 failgreen:
 734         led_classdev_unregister(&led[RED]->led_cdev);
 735
 736 failred:
 737         sysfs_remove_group(&client->dev.kobj, &blinkm_group);
 738 exit:
 739         return err;
 740 }
 741
 742 static int blinkm_remove(struct i2c_client *client)
 743 {
 744         struct blinkm_data *data = i2c_get_clientdata(client);
 745         int ret = 0;
 746         int i;
 747
 748         /* make sure no workqueue entries are pending */
 749         for (i = 0; i < 3; i++) {
 750                 flush_scheduled_work();
 751                 led_classdev_unregister(&data->blinkm_leds[i].led_cdev);
 752         }
 753
 754         /* reset rgb */
 755         data->next_red = 0x00;
 756         data->next_green = 0x00;
 757         data->next_blue = 0x00;
 758         ret = blinkm_transfer_hw(client, BLM_FADE_RGB);
 759         if (ret < 0)
 760                 dev_err(&client->dev, "Failure in blinkm_remove ignored. Continuing.\n");
 761
 762         /* reset hsb */
 763         data->next_hue = 0x00;
 764         data->next_saturation = 0x00;
 765         data->next_brightness = 0x00;
 766         ret = blinkm_transfer_hw(client, BLM_FADE_HSB);
 767         if (ret < 0)
 768                 dev_err(&client->dev, "Failure in blinkm_remove ignored. Continuing.\n");
 769
 770         /* red fade to off */
 771         data->next_red = 0xff;
 772         ret = blinkm_transfer_hw(client, BLM_GO_RGB);
 773         if (ret < 0)
 774                 dev_err(&client->dev, "Failure in blinkm_remove ignored. Continuing.\n");
 775
 776         /* off */
 777         data->next_red = 0x00;
 778         ret = blinkm_transfer_hw(client, BLM_FADE_RGB);
 779         if (ret < 0)
 780                 dev_err(&client->dev, "Failure in blinkm_remove ignored. Continuing.\n");
 781
 782         sysfs_remove_group(&client->dev.kobj, &blinkm_group);
 783         return 0;
 784 }
 785
 786 static const struct i2c_device_id blinkm_id[] = {
 787         {"blinkm", 0},
 788         {}
 789 };
 790
 791 MODULE_DEVICE_TABLE(i2c, blinkm_id);
 792
 793   /* This is the driver that will be inserted */
 794 static struct i2c_driver blinkm_driver = {
 795         .class = I2C_CLASS_HWMON,
 796         .driver = {
 797                    .name = "blinkm",
 798                    },
 799         .probe = blinkm_probe,
 800         .remove = blinkm_remove,
 801         .id_table = blinkm_id,
 802         .detect = blinkm_detect,
 803         .address_list = normal_i2c,
 804 };
 805
 806 module_i2c_driver(blinkm_driver);
 807
 808 MODULE_AUTHOR("Jan-Simon Moeller <dl9pf@gmx.de>");
 809 MODULE_DESCRIPTION("BlinkM RGB LED driver");
 810 MODULE_LICENSE("GPL");
 811