drivers/leds/leds-lp5521.c

   1 /*
   2  * LP5521 LED chip driver.
   3  *
   4  * Copyright (C) 2010 Nokia Corporation
   5  *
   6  * Contact: Samu Onkalo <samu.p.onkalo@nokia.com>
   7  *
   8  * This program is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU General Public License
  10  * version 2 as published by the Free Software Foundation.
  11  *
  12  * This program is distributed in the hope that it will be useful, but
  13  * WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
  20  * 02110-1301 USA
  21  */
  22
  23 #include <linux/module.h>
  24 #include <linux/init.h>
  25 #include <linux/i2c.h>
  26 #include <linux/mutex.h>
  27 #include <linux/gpio.h>
  28 #include <linux/interrupt.h>
  29 #include <linux/delay.h>
  30 #include <linux/ctype.h>
  31 #include <linux/spinlock.h>
  32 #include <linux/wait.h>
  33 #include <linux/leds.h>
  34 #include <linux/leds-lp5521.h>
  35 #include <linux/workqueue.h>
  36 #include <linux/slab.h>
  37 #include <linux/platform_data/leds-lp55xx.h>
  38
  39 #include "leds-lp55xx-common.h"
  40
  41 #define LP5521_PROGRAM_LENGTH           32      /* in bytes */
  42
  43 #define LP5521_MAX_LEDS                 3       /* Maximum number of LEDs */
  44 #define LP5521_MAX_ENGINES              3       /* Maximum number of engines */
  45
  46 #define LP5521_ENG_MASK_BASE            0x30    /* 00110000 */
  47 #define LP5521_ENG_STATUS_MASK          0x07    /* 00000111 */
  48
  49 #define LP5521_CMD_LOAD                 0x15    /* 00010101 */
  50 #define LP5521_CMD_RUN                  0x2a    /* 00101010 */
  51 #define LP5521_CMD_DIRECT               0x3f    /* 00111111 */
  52 #define LP5521_CMD_DISABLED             0x00    /* 00000000 */
  53
  54 /* Registers */
  55 #define LP5521_REG_ENABLE               0x00
  56 #define LP5521_REG_OP_MODE              0x01
  57 #define LP5521_REG_R_PWM                0x02
  58 #define LP5521_REG_G_PWM                0x03
  59 #define LP5521_REG_B_PWM                0x04
  60 #define LP5521_REG_R_CURRENT            0x05
  61 #define LP5521_REG_G_CURRENT            0x06
  62 #define LP5521_REG_B_CURRENT            0x07
  63 #define LP5521_REG_CONFIG               0x08
  64 #define LP5521_REG_R_CHANNEL_PC         0x09
  65 #define LP5521_REG_G_CHANNEL_PC         0x0A
  66 #define LP5521_REG_B_CHANNEL_PC         0x0B
  67 #define LP5521_REG_STATUS               0x0C
  68 #define LP5521_REG_RESET                0x0D
  69 #define LP5521_REG_GPO                  0x0E
  70 #define LP5521_REG_R_PROG_MEM           0x10
  71 #define LP5521_REG_G_PROG_MEM           0x30
  72 #define LP5521_REG_B_PROG_MEM           0x50
  73
  74 #define LP5521_PROG_MEM_BASE            LP5521_REG_R_PROG_MEM
  75 #define LP5521_PROG_MEM_SIZE            0x20
  76
  77 /* Base register to set LED current */
  78 #define LP5521_REG_LED_CURRENT_BASE     LP5521_REG_R_CURRENT
  79
  80 /* Base register to set the brightness */
  81 #define LP5521_REG_LED_PWM_BASE         LP5521_REG_R_PWM
  82
  83 /* Bits in ENABLE register */
  84 #define LP5521_MASTER_ENABLE            0x40    /* Chip master enable */
  85 #define LP5521_LOGARITHMIC_PWM          0x80    /* Logarithmic PWM adjustment */
  86 #define LP5521_EXEC_RUN                 0x2A
  87 #define LP5521_ENABLE_DEFAULT   \
  88         (LP5521_MASTER_ENABLE | LP5521_LOGARITHMIC_PWM)
  89 #define LP5521_ENABLE_RUN_PROGRAM       \
  90         (LP5521_ENABLE_DEFAULT | LP5521_EXEC_RUN)
  91
  92 /* Status */
  93 #define LP5521_EXT_CLK_USED             0x08
  94
  95 /* default R channel current register value */
  96 #define LP5521_REG_R_CURR_DEFAULT       0xAF
  97
  98 /* Pattern Mode */
  99 #define PATTERN_OFF     0
 100
 101 /* Reset register value */
 102 #define LP5521_RESET                    0xFF
 103
 104 struct lp5521_engine {
 105         int             id;
 106         u8              mode;
 107         u8              prog_page;
 108         u8              engine_mask;
 109 };
 110
 111 struct lp5521_led {
 112         int                     id;
 113         u8                      chan_nr;
 114         u8                      led_current;
 115         u8                      max_current;
 116         struct led_classdev     cdev;
 117         struct work_struct      brightness_work;
 118         u8                      brightness;
 119 };
 120
 121 struct lp5521_chip {
 122         struct lp5521_platform_data *pdata;
 123         struct mutex            lock; /* Serialize control */
 124         struct i2c_client       *client;
 125         struct lp5521_engine    engines[LP5521_MAX_ENGINES];
 126         struct lp5521_led       leds[LP5521_MAX_LEDS];
 127         u8                      num_channels;
 128         u8                      num_leds;
 129 };
 130
 131 static inline void lp5521_wait_enable_done(void)
 132 {
 133         /* it takes more 488 us to update ENABLE register */
 134         usleep_range(500, 600);
 135 }
 136
 137 static void lp5521_set_led_current(struct lp55xx_led *led, u8 led_current)
 138 {
 139         led->led_current = led_current;
 140         lp55xx_write(led->chip, LP5521_REG_LED_CURRENT_BASE + led->chan_nr,
 141                 led_current);
 142 }
 143
 144 static inline struct lp5521_led *cdev_to_led(struct led_classdev *cdev)
 145 {
 146         return container_of(cdev, struct lp5521_led, cdev);
 147 }
 148
 149 static inline struct lp5521_chip *engine_to_lp5521(struct lp5521_engine *engine)
 150 {
 151         return container_of(engine, struct lp5521_chip,
 152                             engines[engine->id - 1]);
 153 }
 154
 155 static inline struct lp5521_chip *led_to_lp5521(struct lp5521_led *led)
 156 {
 157         return container_of(led, struct lp5521_chip,
 158                             leds[led->id]);
 159 }
 160
 161 static inline int lp5521_write(struct i2c_client *client, u8 reg, u8 value)
 162 {
 163         return i2c_smbus_write_byte_data(client, reg, value);
 164 }
 165
 166 static int lp5521_read(struct i2c_client *client, u8 reg, u8 *buf)
 167 {
 168         s32 ret;
 169
 170         ret = i2c_smbus_read_byte_data(client, reg);
 171         if (ret < 0)
 172                 return ret;
 173
 174         *buf = ret;
 175         return 0;
 176 }
 177
 178 static int lp5521_set_engine_mode(struct lp5521_engine *engine, u8 mode)
 179 {
 180         struct lp5521_chip *chip = engine_to_lp5521(engine);
 181         struct i2c_client *client = chip->client;
 182         int ret;
 183         u8 engine_state;
 184
 185         /* Only transition between RUN and DIRECT mode are handled here */
 186         if (mode == LP5521_CMD_LOAD)
 187                 return 0;
 188
 189         if (mode == LP5521_CMD_DISABLED)
 190                 mode = LP5521_CMD_DIRECT;
 191
 192         ret = lp5521_read(client, LP5521_REG_OP_MODE, &engine_state);
 193         if (ret < 0)
 194                 return ret;
 195
 196         /* set mode only for this engine */
 197         engine_state &= ~(engine->engine_mask);
 198         mode &= engine->engine_mask;
 199         engine_state |= mode;
 200         return lp5521_write(client, LP5521_REG_OP_MODE, engine_state);
 201 }
 202
 203 static int lp5521_load_program(struct lp5521_engine *eng, const u8 *pattern)
 204 {
 205         struct lp5521_chip *chip = engine_to_lp5521(eng);
 206         struct i2c_client *client = chip->client;
 207         int ret;
 208         int addr;
 209         u8 mode;
 210
 211         /* move current engine to direct mode and remember the state */
 212         ret = lp5521_set_engine_mode(eng, LP5521_CMD_DIRECT);
 213         if (ret)
 214                 return ret;
 215
 216         /* Mode change requires min 500 us delay. 1 - 2 ms  with margin */
 217         usleep_range(1000, 2000);
 218         ret = lp5521_read(client, LP5521_REG_OP_MODE, &mode);
 219         if (ret)
 220                 return ret;
 221
 222         /* For loading, all the engines to load mode */
 223         lp5521_write(client, LP5521_REG_OP_MODE, LP5521_CMD_DIRECT);
 224         /* Mode change requires min 500 us delay. 1 - 2 ms  with margin */
 225         usleep_range(1000, 2000);
 226         lp5521_write(client, LP5521_REG_OP_MODE, LP5521_CMD_LOAD);
 227         /* Mode change requires min 500 us delay. 1 - 2 ms  with margin */
 228         usleep_range(1000, 2000);
 229
 230         addr = LP5521_PROG_MEM_BASE + eng->prog_page * LP5521_PROG_MEM_SIZE;
 231         i2c_smbus_write_i2c_block_data(client,
 232                                 addr,
 233                                 LP5521_PROG_MEM_SIZE,
 234                                 pattern);
 235
 236         return lp5521_write(client, LP5521_REG_OP_MODE, mode);
 237 }
 238
 239 static int lp5521_post_init_device(struct lp55xx_chip *chip)
 240 {
 241         int ret;
 242         u8 val;
 243
 244         /*
 245          * Make sure that the chip is reset by reading back the r channel
 246          * current reg. This is dummy read is required on some platforms -
 247          * otherwise further access to the R G B channels in the
 248          * LP5521_REG_ENABLE register will not have any effect - strange!
 249          */
 250         ret = lp55xx_read(chip, LP5521_REG_R_CURRENT, &val);
 251         if (ret) {
 252                 dev_err(&chip->cl->dev, "error in resetting chip\n");
 253                 return ret;
 254         }
 255         if (val != LP5521_REG_R_CURR_DEFAULT) {
 256                 dev_err(&chip->cl->dev,
 257                         "unexpected data in register (expected 0x%x got 0x%x)\n",
 258                         LP5521_REG_R_CURR_DEFAULT, val);
 259                 ret = -EINVAL;
 260                 return ret;
 261         }
 262         usleep_range(10000, 20000);
 263
 264         /* Set all PWMs to direct control mode */
 265         ret = lp55xx_write(chip, LP5521_REG_OP_MODE, LP5521_CMD_DIRECT);
 266
 267         val = chip->pdata->update_config ?
 268                 : (LP5521_PWRSAVE_EN | LP5521_CP_MODE_AUTO | LP5521_R_TO_BATT);
 269         ret = lp55xx_write(chip, LP5521_REG_CONFIG, val);
 270         if (ret)
 271                 return ret;
 272
 273         /* Initialize all channels PWM to zero -> leds off */
 274         lp55xx_write(chip, LP5521_REG_R_PWM, 0);
 275         lp55xx_write(chip, LP5521_REG_G_PWM, 0);
 276         lp55xx_write(chip, LP5521_REG_B_PWM, 0);
 277
 278         /* Set engines are set to run state when OP_MODE enables engines */
 279         ret = lp55xx_write(chip, LP5521_REG_ENABLE, LP5521_ENABLE_RUN_PROGRAM);
 280         if (ret)
 281                 return ret;
 282
 283         lp5521_wait_enable_done();
 284
 285         return 0;
 286 }
 287
 288 static int lp5521_run_selftest(struct lp5521_chip *chip, char *buf)
 289 {
 290         int ret;
 291         u8 status;
 292
 293         ret = lp5521_read(chip->client, LP5521_REG_STATUS, &status);
 294         if (ret < 0)
 295                 return ret;
 296
 297         /* Check that ext clock is really in use if requested */
 298         if (chip->pdata && chip->pdata->clock_mode == LP5521_CLOCK_EXT)
 299                 if  ((status & LP5521_EXT_CLK_USED) == 0)
 300                         return -EIO;
 301         return 0;
 302 }
 303
 304 static void lp5521_led_brightness_work(struct work_struct *work)
 305 {
 306         struct lp55xx_led *led = container_of(work, struct lp55xx_led,
 307                                               brightness_work);
 308         struct lp55xx_chip *chip = led->chip;
 309
 310         mutex_lock(&chip->lock);
 311         lp55xx_write(chip, LP5521_REG_LED_PWM_BASE + led->chan_nr,
 312                 led->brightness);
 313         mutex_unlock(&chip->lock);
 314 }
 315
 316 /* Set engine mode and create appropriate sysfs attributes, if required. */
 317 static int lp5521_set_mode(struct lp5521_engine *engine, u8 mode)
 318 {
 319         int ret = 0;
 320
 321         /* if in that mode already do nothing, except for run */
 322         if (mode == engine->mode && mode != LP5521_CMD_RUN)
 323                 return 0;
 324
 325         if (mode == LP5521_CMD_RUN) {
 326                 ret = lp5521_set_engine_mode(engine, LP5521_CMD_RUN);
 327         } else if (mode == LP5521_CMD_LOAD) {
 328                 lp5521_set_engine_mode(engine, LP5521_CMD_DISABLED);
 329                 lp5521_set_engine_mode(engine, LP5521_CMD_LOAD);
 330         } else if (mode == LP5521_CMD_DISABLED) {
 331                 lp5521_set_engine_mode(engine, LP5521_CMD_DISABLED);
 332         }
 333
 334         engine->mode = mode;
 335
 336         return ret;
 337 }
 338
 339 static int lp5521_do_store_load(struct lp5521_engine *engine,
 340                                 const char *buf, size_t len)
 341 {
 342         struct lp5521_chip *chip = engine_to_lp5521(engine);
 343         struct i2c_client *client = chip->client;
 344         int  ret, nrchars, offset = 0, i = 0;
 345         char c[3];
 346         unsigned cmd;
 347         u8 pattern[LP5521_PROGRAM_LENGTH] = {0};
 348
 349         while ((offset < len - 1) && (i < LP5521_PROGRAM_LENGTH)) {
 350                 /* separate sscanfs because length is working only for %s */
 351                 ret = sscanf(buf + offset, "%2s%n ", c, &nrchars);
 352                 if (ret != 2)
 353                         goto fail;
 354                 ret = sscanf(c, "%2x", &cmd);
 355                 if (ret != 1)
 356                         goto fail;
 357                 pattern[i] = (u8)cmd;
 358
 359                 offset += nrchars;
 360                 i++;
 361         }
 362
 363         /* Each instruction is 16bit long. Check that length is even */
 364         if (i % 2)
 365                 goto fail;
 366
 367         mutex_lock(&chip->lock);
 368         if (engine->mode == LP5521_CMD_LOAD)
 369                 ret = lp5521_load_program(engine, pattern);
 370         else
 371                 ret = -EINVAL;
 372         mutex_unlock(&chip->lock);
 373
 374         if (ret) {
 375                 dev_err(&client->dev, "failed loading pattern\n");
 376                 return ret;
 377         }
 378
 379         return len;
 380 fail:
 381         dev_err(&client->dev, "wrong pattern format\n");
 382         return -EINVAL;
 383 }
 384
 385 static ssize_t store_engine_load(struct device *dev,
 386                                      struct device_attribute *attr,
 387                                      const char *buf, size_t len, int nr)
 388 {
 389         struct i2c_client *client = to_i2c_client(dev);
 390         struct lp5521_chip *chip = i2c_get_clientdata(client);
 391         return lp5521_do_store_load(&chip->engines[nr - 1], buf, len);
 392 }
 393
 394 #define store_load(nr)                                                  \
 395 static ssize_t store_engine##nr##_load(struct device *dev,              \
 396                                      struct device_attribute *attr,     \
 397                                      const char *buf, size_t len)       \
 398 {                                                                       \
 399         return store_engine_load(dev, attr, buf, len, nr);              \
 400 }
 401 store_load(1)
 402 store_load(2)
 403 store_load(3)
 404
 405 static ssize_t show_engine_mode(struct device *dev,
 406                                 struct device_attribute *attr,
 407                                 char *buf, int nr)
 408 {
 409         struct i2c_client *client = to_i2c_client(dev);
 410         struct lp5521_chip *chip = i2c_get_clientdata(client);
 411         switch (chip->engines[nr - 1].mode) {
 412         case LP5521_CMD_RUN:
 413                 return sprintf(buf, "run\n");
 414         case LP5521_CMD_LOAD:
 415                 return sprintf(buf, "load\n");
 416         case LP5521_CMD_DISABLED:
 417                 return sprintf(buf, "disabled\n");
 418         default:
 419                 return sprintf(buf, "disabled\n");
 420         }
 421 }
 422
 423 #define show_mode(nr)                                                   \
 424 static ssize_t show_engine##nr##_mode(struct device *dev,               \
 425                                     struct device_attribute *attr,      \
 426                                     char *buf)                          \
 427 {                                                                       \
 428         return show_engine_mode(dev, attr, buf, nr);                    \
 429 }
 430 show_mode(1)
 431 show_mode(2)
 432 show_mode(3)
 433
 434 static ssize_t store_engine_mode(struct device *dev,
 435                                  struct device_attribute *attr,
 436                                  const char *buf, size_t len, int nr)
 437 {
 438         struct i2c_client *client = to_i2c_client(dev);
 439         struct lp5521_chip *chip = i2c_get_clientdata(client);
 440         struct lp5521_engine *engine = &chip->engines[nr - 1];
 441         mutex_lock(&chip->lock);
 442
 443         if (!strncmp(buf, "run", 3))
 444                 lp5521_set_mode(engine, LP5521_CMD_RUN);
 445         else if (!strncmp(buf, "load", 4))
 446                 lp5521_set_mode(engine, LP5521_CMD_LOAD);
 447         else if (!strncmp(buf, "disabled", 8))
 448                 lp5521_set_mode(engine, LP5521_CMD_DISABLED);
 449
 450         mutex_unlock(&chip->lock);
 451         return len;
 452 }
 453
 454 #define store_mode(nr)                                                  \
 455 static ssize_t store_engine##nr##_mode(struct device *dev,              \
 456                                      struct device_attribute *attr,     \
 457                                      const char *buf, size_t len)       \
 458 {                                                                       \
 459         return store_engine_mode(dev, attr, buf, len, nr);              \
 460 }
 461 store_mode(1)
 462 store_mode(2)
 463 store_mode(3)
 464
 465 static ssize_t lp5521_selftest(struct device *dev,
 466                                struct device_attribute *attr,
 467                                char *buf)
 468 {
 469         struct i2c_client *client = to_i2c_client(dev);
 470         struct lp5521_chip *chip = i2c_get_clientdata(client);
 471         int ret;
 472
 473         mutex_lock(&chip->lock);
 474         ret = lp5521_run_selftest(chip, buf);
 475         mutex_unlock(&chip->lock);
 476         return sprintf(buf, "%s\n", ret ? "FAIL" : "OK");
 477 }
 478
 479 static void lp5521_clear_program_memory(struct i2c_client *cl)
 480 {
 481         int i;
 482         u8 rgb_mem[] = {
 483                 LP5521_REG_R_PROG_MEM,
 484                 LP5521_REG_G_PROG_MEM,
 485                 LP5521_REG_B_PROG_MEM,
 486         };
 487
 488         for (i = 0; i < ARRAY_SIZE(rgb_mem); i++) {
 489                 lp5521_write(cl, rgb_mem[i], 0);
 490                 lp5521_write(cl, rgb_mem[i] + 1, 0);
 491         }
 492 }
 493
 494 static void lp5521_write_program_memory(struct i2c_client *cl,
 495                                 u8 base, u8 *rgb, int size)
 496 {
 497         int i;
 498
 499         if (!rgb || size <= 0)
 500                 return;
 501
 502         for (i = 0; i < size; i++)
 503                 lp5521_write(cl, base + i, *(rgb + i));
 504
 505         lp5521_write(cl, base + i, 0);
 506         lp5521_write(cl, base + i + 1, 0);
 507 }
 508
 509 static inline struct lp5521_led_pattern *lp5521_get_pattern
 510                                         (struct lp5521_chip *chip, u8 offset)
 511 {
 512         struct lp5521_led_pattern *ptn;
 513         ptn = chip->pdata->patterns + (offset - 1);
 514         return ptn;
 515 }
 516
 517 static void lp5521_run_led_pattern(int mode, struct lp5521_chip *chip)
 518 {
 519         struct lp5521_led_pattern *ptn;
 520         struct i2c_client *cl = chip->client;
 521         int num_patterns = chip->pdata->num_patterns;
 522
 523         if (mode > num_patterns || !(chip->pdata->patterns))
 524                 return;
 525
 526         if (mode == PATTERN_OFF) {
 527                 lp5521_write(cl, LP5521_REG_ENABLE, LP5521_ENABLE_DEFAULT);
 528                 usleep_range(1000, 2000);
 529                 lp5521_write(cl, LP5521_REG_OP_MODE, LP5521_CMD_DIRECT);
 530         } else {
 531                 ptn = lp5521_get_pattern(chip, mode);
 532                 if (!ptn)
 533                         return;
 534
 535                 lp5521_write(cl, LP5521_REG_OP_MODE, LP5521_CMD_LOAD);
 536                 usleep_range(1000, 2000);
 537
 538                 lp5521_clear_program_memory(cl);
 539
 540                 lp5521_write_program_memory(cl, LP5521_REG_R_PROG_MEM,
 541                                         ptn->r, ptn->size_r);
 542                 lp5521_write_program_memory(cl, LP5521_REG_G_PROG_MEM,
 543                                         ptn->g, ptn->size_g);
 544                 lp5521_write_program_memory(cl, LP5521_REG_B_PROG_MEM,
 545                                         ptn->b, ptn->size_b);
 546
 547                 lp5521_write(cl, LP5521_REG_OP_MODE, LP5521_CMD_RUN);
 548                 usleep_range(1000, 2000);
 549                 lp5521_write(cl, LP5521_REG_ENABLE, LP5521_ENABLE_RUN_PROGRAM);
 550         }
 551 }
 552
 553 static ssize_t store_led_pattern(struct device *dev,
 554                                 struct device_attribute *attr,
 555                                 const char *buf, size_t len)
 556 {
 557         struct lp5521_chip *chip = i2c_get_clientdata(to_i2c_client(dev));
 558         unsigned long val;
 559         int ret;
 560
 561         ret = kstrtoul(buf, 16, &val);
 562         if (ret)
 563                 return ret;
 564
 565         lp5521_run_led_pattern(val, chip);
 566
 567         return len;
 568 }
 569
 570 static struct attribute_group lp5521_led_attribute_group = {
 571 };
 572
 573 /* device attributes */
 574 static DEVICE_ATTR(engine1_mode, S_IRUGO | S_IWUSR,
 575                    show_engine1_mode, store_engine1_mode);
 576 static DEVICE_ATTR(engine2_mode, S_IRUGO | S_IWUSR,
 577                    show_engine2_mode, store_engine2_mode);
 578 static DEVICE_ATTR(engine3_mode, S_IRUGO | S_IWUSR,
 579                    show_engine3_mode, store_engine3_mode);
 580 static DEVICE_ATTR(engine1_load, S_IWUSR, NULL, store_engine1_load);
 581 static DEVICE_ATTR(engine2_load, S_IWUSR, NULL, store_engine2_load);
 582 static DEVICE_ATTR(engine3_load, S_IWUSR, NULL, store_engine3_load);
 583 static DEVICE_ATTR(selftest, S_IRUGO, lp5521_selftest, NULL);
 584 static DEVICE_ATTR(led_pattern, S_IWUSR, NULL, store_led_pattern);
 585
 586 static struct attribute *lp5521_attributes[] = {
 587         &dev_attr_engine1_mode.attr,
 588         &dev_attr_engine2_mode.attr,
 589         &dev_attr_engine3_mode.attr,
 590         &dev_attr_selftest.attr,
 591         &dev_attr_engine1_load.attr,
 592         &dev_attr_engine2_load.attr,
 593         &dev_attr_engine3_load.attr,
 594         &dev_attr_led_pattern.attr,
 595         NULL
 596 };
 597
 598 static const struct attribute_group lp5521_group = {
 599         .attrs = lp5521_attributes,
 600 };
 601
 602 static int lp5521_register_sysfs(struct i2c_client *client)
 603 {
 604         struct device *dev = &client->dev;
 605         return sysfs_create_group(&dev->kobj, &lp5521_group);
 606 }
 607
 608 static void lp5521_unregister_sysfs(struct i2c_client *client)
 609 {
 610         struct lp5521_chip *chip = i2c_get_clientdata(client);
 611         struct device *dev = &client->dev;
 612         int i;
 613
 614         sysfs_remove_group(&dev->kobj, &lp5521_group);
 615
 616         for (i = 0; i < chip->num_leds; i++)
 617                 sysfs_remove_group(&chip->leds[i].cdev.dev->kobj,
 618                                 &lp5521_led_attribute_group);
 619 }
 620
 621 static void lp5521_unregister_leds(struct lp5521_chip *chip)
 622 {
 623         int i;
 624
 625         for (i = 0; i < chip->num_leds; i++) {
 626                 led_classdev_unregister(&chip->leds[i].cdev);
 627                 cancel_work_sync(&chip->leds[i].brightness_work);
 628         }
 629 }
 630
 631 /* Chip specific configurations */
 632 static struct lp55xx_device_config lp5521_cfg = {
 633         .reset = {
 634                 .addr = LP5521_REG_RESET,
 635                 .val  = LP5521_RESET,
 636         },
 637         .enable = {
 638                 .addr = LP5521_REG_ENABLE,
 639                 .val  = LP5521_ENABLE_DEFAULT,
 640         },
 641         .max_channel  = LP5521_MAX_LEDS,
 642         .post_init_device   = lp5521_post_init_device,
 643         .brightness_work_fn = lp5521_led_brightness_work,
 644         .set_led_current    = lp5521_set_led_current,
 645 };
 646
 647 static int lp5521_probe(struct i2c_client *client,
 648                         const struct i2c_device_id *id)
 649 {
 650         struct lp5521_chip              *old_chip = NULL;
 651         int ret;
 652         struct lp55xx_chip *chip;
 653         struct lp55xx_led *led;
 654         struct lp55xx_platform_data *pdata = client->dev.platform_data;
 655
 656         if (!pdata) {
 657                 dev_err(&client->dev, "no platform data\n");
 658                 return -EINVAL;
 659         }
 660
 661         chip = devm_kzalloc(&client->dev, sizeof(*chip), GFP_KERNEL);
 662         if (!chip)
 663                 return -ENOMEM;
 664
 665         led = devm_kzalloc(&client->dev,
 666                         sizeof(*led) * pdata->num_channels, GFP_KERNEL);
 667         if (!led)
 668                 return -ENOMEM;
 669
 670         chip->cl = client;
 671         chip->pdata = pdata;
 672         chip->cfg = &lp5521_cfg;
 673
 674         mutex_init(&chip->lock);
 675
 676         i2c_set_clientdata(client, led);
 677
 678         ret = lp55xx_init_device(chip);
 679         if (ret)
 680                 goto err_init;
 681
 682         dev_info(&client->dev, "%s programmable led chip found\n", id->name);
 683
 684         ret = lp55xx_register_leds(led, chip);
 685         if (ret)
 686                 goto err_register_leds;
 687
 688         ret = lp5521_register_sysfs(client);
 689         if (ret) {
 690                 dev_err(&client->dev, "registering sysfs failed\n");
 691                 goto fail2;
 692         }
 693         return ret;
 694 fail2:
 695         lp5521_unregister_leds(old_chip);
 696 err_register_leds:
 697         lp55xx_deinit_device(chip);
 698 err_init:
 699         return ret;
 700 }
 701
 702 static int lp5521_remove(struct i2c_client *client)
 703 {
 704         struct lp5521_chip *old_chip = i2c_get_clientdata(client);
 705         struct lp55xx_led *led = i2c_get_clientdata(client);
 706         struct lp55xx_chip *chip = led->chip;
 707
 708         lp5521_run_led_pattern(PATTERN_OFF, old_chip);
 709         lp5521_unregister_sysfs(client);
 710
 711         lp5521_unregister_leds(old_chip);
 712         lp55xx_deinit_device(chip);
 713
 714         return 0;
 715 }
 716
 717 static const struct i2c_device_id lp5521_id[] = {
 718         { "lp5521", 0 }, /* Three channel chip */
 719         { }
 720 };
 721 MODULE_DEVICE_TABLE(i2c, lp5521_id);
 722
 723 static struct i2c_driver lp5521_driver = {
 724         .driver = {
 725                 .name   = "lp5521",
 726         },
 727         .probe          = lp5521_probe,
 728         .remove         = lp5521_remove,
 729         .id_table       = lp5521_id,
 730 };
 731
 732 module_i2c_driver(lp5521_driver);
 733
 734 MODULE_AUTHOR("Mathias Nyman, Yuri Zaporozhets, Samu Onkalo");
 735 MODULE_DESCRIPTION("LP5521 LED engine");
 736 MODULE_LICENSE("GPL v2");