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