linux/drivers/leds/leds-lp5523.c
<<
>>
Prefs
   1// SPDX-License-Identifier: GPL-2.0-only
   2/*
   3 * lp5523.c - LP5523, LP55231 LED Driver
   4 *
   5 * Copyright (C) 2010 Nokia Corporation
   6 * Copyright (C) 2012 Texas Instruments
   7 *
   8 * Contact: Samu Onkalo <samu.p.onkalo@nokia.com>
   9 *          Milo(Woogyom) Kim <milo.kim@ti.com>
  10 */
  11
  12#include <linux/delay.h>
  13#include <linux/firmware.h>
  14#include <linux/i2c.h>
  15#include <linux/leds.h>
  16#include <linux/module.h>
  17#include <linux/mutex.h>
  18#include <linux/of.h>
  19#include <linux/platform_data/leds-lp55xx.h>
  20#include <linux/slab.h>
  21
  22#include "leds-lp55xx-common.h"
  23
  24#define LP5523_PROGRAM_LENGTH           32      /* bytes */
  25/* Memory is used like this:
  26 * 0x00 engine 1 program
  27 * 0x10 engine 2 program
  28 * 0x20 engine 3 program
  29 * 0x30 engine 1 muxing info
  30 * 0x40 engine 2 muxing info
  31 * 0x50 engine 3 muxing info
  32 */
  33#define LP5523_MAX_LEDS                 9
  34
  35/* Registers */
  36#define LP5523_REG_ENABLE               0x00
  37#define LP5523_REG_OP_MODE              0x01
  38#define LP5523_REG_ENABLE_LEDS_MSB      0x04
  39#define LP5523_REG_ENABLE_LEDS_LSB      0x05
  40#define LP5523_REG_LED_CTRL_BASE        0x06
  41#define LP5523_REG_LED_PWM_BASE         0x16
  42#define LP5523_REG_LED_CURRENT_BASE     0x26
  43#define LP5523_REG_CONFIG               0x36
  44#define LP5523_REG_STATUS               0x3A
  45#define LP5523_REG_RESET                0x3D
  46#define LP5523_REG_LED_TEST_CTRL        0x41
  47#define LP5523_REG_LED_TEST_ADC         0x42
  48#define LP5523_REG_MASTER_FADER_BASE    0x48
  49#define LP5523_REG_CH1_PROG_START       0x4C
  50#define LP5523_REG_CH2_PROG_START       0x4D
  51#define LP5523_REG_CH3_PROG_START       0x4E
  52#define LP5523_REG_PROG_PAGE_SEL        0x4F
  53#define LP5523_REG_PROG_MEM             0x50
  54
  55/* Bit description in registers */
  56#define LP5523_ENABLE                   0x40
  57#define LP5523_AUTO_INC                 0x40
  58#define LP5523_PWR_SAVE                 0x20
  59#define LP5523_PWM_PWR_SAVE             0x04
  60#define LP5523_CP_AUTO                  0x18
  61#define LP5523_AUTO_CLK                 0x02
  62
  63#define LP5523_EN_LEDTEST               0x80
  64#define LP5523_LEDTEST_DONE             0x80
  65#define LP5523_RESET                    0xFF
  66#define LP5523_ADC_SHORTCIRC_LIM        80
  67#define LP5523_EXT_CLK_USED             0x08
  68#define LP5523_ENG_STATUS_MASK          0x07
  69
  70#define LP5523_FADER_MAPPING_MASK       0xC0
  71#define LP5523_FADER_MAPPING_SHIFT      6
  72
  73/* Memory Page Selection */
  74#define LP5523_PAGE_ENG1                0
  75#define LP5523_PAGE_ENG2                1
  76#define LP5523_PAGE_ENG3                2
  77#define LP5523_PAGE_MUX1                3
  78#define LP5523_PAGE_MUX2                4
  79#define LP5523_PAGE_MUX3                5
  80
  81/* Program Memory Operations */
  82#define LP5523_MODE_ENG1_M              0x30    /* Operation Mode Register */
  83#define LP5523_MODE_ENG2_M              0x0C
  84#define LP5523_MODE_ENG3_M              0x03
  85#define LP5523_LOAD_ENG1                0x10
  86#define LP5523_LOAD_ENG2                0x04
  87#define LP5523_LOAD_ENG3                0x01
  88
  89#define LP5523_ENG1_IS_LOADING(mode)    \
  90        ((mode & LP5523_MODE_ENG1_M) == LP5523_LOAD_ENG1)
  91#define LP5523_ENG2_IS_LOADING(mode)    \
  92        ((mode & LP5523_MODE_ENG2_M) == LP5523_LOAD_ENG2)
  93#define LP5523_ENG3_IS_LOADING(mode)    \
  94        ((mode & LP5523_MODE_ENG3_M) == LP5523_LOAD_ENG3)
  95
  96#define LP5523_EXEC_ENG1_M              0x30    /* Enable Register */
  97#define LP5523_EXEC_ENG2_M              0x0C
  98#define LP5523_EXEC_ENG3_M              0x03
  99#define LP5523_EXEC_M                   0x3F
 100#define LP5523_RUN_ENG1                 0x20
 101#define LP5523_RUN_ENG2                 0x08
 102#define LP5523_RUN_ENG3                 0x02
 103
 104#define LED_ACTIVE(mux, led)            (!!(mux & (0x0001 << led)))
 105
 106enum lp5523_chip_id {
 107        LP5523,
 108        LP55231,
 109};
 110
 111static int lp5523_init_program_engine(struct lp55xx_chip *chip);
 112
 113static inline void lp5523_wait_opmode_done(void)
 114{
 115        usleep_range(1000, 2000);
 116}
 117
 118static void lp5523_set_led_current(struct lp55xx_led *led, u8 led_current)
 119{
 120        led->led_current = led_current;
 121        lp55xx_write(led->chip, LP5523_REG_LED_CURRENT_BASE + led->chan_nr,
 122                led_current);
 123}
 124
 125static int lp5523_post_init_device(struct lp55xx_chip *chip)
 126{
 127        int ret;
 128
 129        ret = lp55xx_write(chip, LP5523_REG_ENABLE, LP5523_ENABLE);
 130        if (ret)
 131                return ret;
 132
 133        /* Chip startup time is 500 us, 1 - 2 ms gives some margin */
 134        usleep_range(1000, 2000);
 135
 136        ret = lp55xx_write(chip, LP5523_REG_CONFIG,
 137                            LP5523_AUTO_INC | LP5523_PWR_SAVE |
 138                            LP5523_CP_AUTO | LP5523_AUTO_CLK |
 139                            LP5523_PWM_PWR_SAVE);
 140        if (ret)
 141                return ret;
 142
 143        /* turn on all leds */
 144        ret = lp55xx_write(chip, LP5523_REG_ENABLE_LEDS_MSB, 0x01);
 145        if (ret)
 146                return ret;
 147
 148        ret = lp55xx_write(chip, LP5523_REG_ENABLE_LEDS_LSB, 0xff);
 149        if (ret)
 150                return ret;
 151
 152        return lp5523_init_program_engine(chip);
 153}
 154
 155static void lp5523_load_engine(struct lp55xx_chip *chip)
 156{
 157        enum lp55xx_engine_index idx = chip->engine_idx;
 158        static const u8 mask[] = {
 159                [LP55XX_ENGINE_1] = LP5523_MODE_ENG1_M,
 160                [LP55XX_ENGINE_2] = LP5523_MODE_ENG2_M,
 161                [LP55XX_ENGINE_3] = LP5523_MODE_ENG3_M,
 162        };
 163
 164        static const u8 val[] = {
 165                [LP55XX_ENGINE_1] = LP5523_LOAD_ENG1,
 166                [LP55XX_ENGINE_2] = LP5523_LOAD_ENG2,
 167                [LP55XX_ENGINE_3] = LP5523_LOAD_ENG3,
 168        };
 169
 170        lp55xx_update_bits(chip, LP5523_REG_OP_MODE, mask[idx], val[idx]);
 171
 172        lp5523_wait_opmode_done();
 173}
 174
 175static void lp5523_load_engine_and_select_page(struct lp55xx_chip *chip)
 176{
 177        enum lp55xx_engine_index idx = chip->engine_idx;
 178        static const u8 page_sel[] = {
 179                [LP55XX_ENGINE_1] = LP5523_PAGE_ENG1,
 180                [LP55XX_ENGINE_2] = LP5523_PAGE_ENG2,
 181                [LP55XX_ENGINE_3] = LP5523_PAGE_ENG3,
 182        };
 183
 184        lp5523_load_engine(chip);
 185
 186        lp55xx_write(chip, LP5523_REG_PROG_PAGE_SEL, page_sel[idx]);
 187}
 188
 189static void lp5523_stop_all_engines(struct lp55xx_chip *chip)
 190{
 191        lp55xx_write(chip, LP5523_REG_OP_MODE, 0);
 192        lp5523_wait_opmode_done();
 193}
 194
 195static void lp5523_stop_engine(struct lp55xx_chip *chip)
 196{
 197        enum lp55xx_engine_index idx = chip->engine_idx;
 198        static const u8 mask[] = {
 199                [LP55XX_ENGINE_1] = LP5523_MODE_ENG1_M,
 200                [LP55XX_ENGINE_2] = LP5523_MODE_ENG2_M,
 201                [LP55XX_ENGINE_3] = LP5523_MODE_ENG3_M,
 202        };
 203
 204        lp55xx_update_bits(chip, LP5523_REG_OP_MODE, mask[idx], 0);
 205
 206        lp5523_wait_opmode_done();
 207}
 208
 209static void lp5523_turn_off_channels(struct lp55xx_chip *chip)
 210{
 211        int i;
 212
 213        for (i = 0; i < LP5523_MAX_LEDS; i++)
 214                lp55xx_write(chip, LP5523_REG_LED_PWM_BASE + i, 0);
 215}
 216
 217static void lp5523_run_engine(struct lp55xx_chip *chip, bool start)
 218{
 219        int ret;
 220        u8 mode;
 221        u8 exec;
 222
 223        /* stop engine */
 224        if (!start) {
 225                lp5523_stop_engine(chip);
 226                lp5523_turn_off_channels(chip);
 227                return;
 228        }
 229
 230        /*
 231         * To run the engine,
 232         * operation mode and enable register should updated at the same time
 233         */
 234
 235        ret = lp55xx_read(chip, LP5523_REG_OP_MODE, &mode);
 236        if (ret)
 237                return;
 238
 239        ret = lp55xx_read(chip, LP5523_REG_ENABLE, &exec);
 240        if (ret)
 241                return;
 242
 243        /* change operation mode to RUN only when each engine is loading */
 244        if (LP5523_ENG1_IS_LOADING(mode)) {
 245                mode = (mode & ~LP5523_MODE_ENG1_M) | LP5523_RUN_ENG1;
 246                exec = (exec & ~LP5523_EXEC_ENG1_M) | LP5523_RUN_ENG1;
 247        }
 248
 249        if (LP5523_ENG2_IS_LOADING(mode)) {
 250                mode = (mode & ~LP5523_MODE_ENG2_M) | LP5523_RUN_ENG2;
 251                exec = (exec & ~LP5523_EXEC_ENG2_M) | LP5523_RUN_ENG2;
 252        }
 253
 254        if (LP5523_ENG3_IS_LOADING(mode)) {
 255                mode = (mode & ~LP5523_MODE_ENG3_M) | LP5523_RUN_ENG3;
 256                exec = (exec & ~LP5523_EXEC_ENG3_M) | LP5523_RUN_ENG3;
 257        }
 258
 259        lp55xx_write(chip, LP5523_REG_OP_MODE, mode);
 260        lp5523_wait_opmode_done();
 261
 262        lp55xx_update_bits(chip, LP5523_REG_ENABLE, LP5523_EXEC_M, exec);
 263}
 264
 265static int lp5523_init_program_engine(struct lp55xx_chip *chip)
 266{
 267        int i;
 268        int j;
 269        int ret;
 270        u8 status;
 271        /* one pattern per engine setting LED MUX start and stop addresses */
 272        static const u8 pattern[][LP5523_PROGRAM_LENGTH] =  {
 273                { 0x9c, 0x30, 0x9c, 0xb0, 0x9d, 0x80, 0xd8, 0x00, 0},
 274                { 0x9c, 0x40, 0x9c, 0xc0, 0x9d, 0x80, 0xd8, 0x00, 0},
 275                { 0x9c, 0x50, 0x9c, 0xd0, 0x9d, 0x80, 0xd8, 0x00, 0},
 276        };
 277
 278        /* hardcode 32 bytes of memory for each engine from program memory */
 279        ret = lp55xx_write(chip, LP5523_REG_CH1_PROG_START, 0x00);
 280        if (ret)
 281                return ret;
 282
 283        ret = lp55xx_write(chip, LP5523_REG_CH2_PROG_START, 0x10);
 284        if (ret)
 285                return ret;
 286
 287        ret = lp55xx_write(chip, LP5523_REG_CH3_PROG_START, 0x20);
 288        if (ret)
 289                return ret;
 290
 291        /* write LED MUX address space for each engine */
 292        for (i = LP55XX_ENGINE_1; i <= LP55XX_ENGINE_3; i++) {
 293                chip->engine_idx = i;
 294                lp5523_load_engine_and_select_page(chip);
 295
 296                for (j = 0; j < LP5523_PROGRAM_LENGTH; j++) {
 297                        ret = lp55xx_write(chip, LP5523_REG_PROG_MEM + j,
 298                                        pattern[i - 1][j]);
 299                        if (ret)
 300                                goto out;
 301                }
 302        }
 303
 304        lp5523_run_engine(chip, true);
 305
 306        /* Let the programs run for couple of ms and check the engine status */
 307        usleep_range(3000, 6000);
 308        ret = lp55xx_read(chip, LP5523_REG_STATUS, &status);
 309        if (ret)
 310                return ret;
 311        status &= LP5523_ENG_STATUS_MASK;
 312
 313        if (status != LP5523_ENG_STATUS_MASK) {
 314                dev_err(&chip->cl->dev,
 315                        "could not configure LED engine, status = 0x%.2x\n",
 316                        status);
 317                ret = -1;
 318        }
 319
 320out:
 321        lp5523_stop_all_engines(chip);
 322        return ret;
 323}
 324
 325static int lp5523_update_program_memory(struct lp55xx_chip *chip,
 326                                        const u8 *data, size_t size)
 327{
 328        u8 pattern[LP5523_PROGRAM_LENGTH] = {0};
 329        unsigned int cmd;
 330        char c[3];
 331        int nrchars;
 332        int ret;
 333        int offset = 0;
 334        int i = 0;
 335
 336        while ((offset < size - 1) && (i < LP5523_PROGRAM_LENGTH)) {
 337                /* separate sscanfs because length is working only for %s */
 338                ret = sscanf(data + offset, "%2s%n ", c, &nrchars);
 339                if (ret != 1)
 340                        goto err;
 341
 342                ret = sscanf(c, "%2x", &cmd);
 343                if (ret != 1)
 344                        goto err;
 345
 346                pattern[i] = (u8)cmd;
 347                offset += nrchars;
 348                i++;
 349        }
 350
 351        /* Each instruction is 16bit long. Check that length is even */
 352        if (i % 2)
 353                goto err;
 354
 355        for (i = 0; i < LP5523_PROGRAM_LENGTH; i++) {
 356                ret = lp55xx_write(chip, LP5523_REG_PROG_MEM + i, pattern[i]);
 357                if (ret)
 358                        return -EINVAL;
 359        }
 360
 361        return size;
 362
 363err:
 364        dev_err(&chip->cl->dev, "wrong pattern format\n");
 365        return -EINVAL;
 366}
 367
 368static void lp5523_firmware_loaded(struct lp55xx_chip *chip)
 369{
 370        const struct firmware *fw = chip->fw;
 371
 372        if (fw->size > LP5523_PROGRAM_LENGTH) {
 373                dev_err(&chip->cl->dev, "firmware data size overflow: %zu\n",
 374                        fw->size);
 375                return;
 376        }
 377
 378        /*
 379         * Program memory sequence
 380         *  1) set engine mode to "LOAD"
 381         *  2) write firmware data into program memory
 382         */
 383
 384        lp5523_load_engine_and_select_page(chip);
 385        lp5523_update_program_memory(chip, fw->data, fw->size);
 386}
 387
 388static ssize_t show_engine_mode(struct device *dev,
 389                                struct device_attribute *attr,
 390                                char *buf, int nr)
 391{
 392        struct lp55xx_led *led = i2c_get_clientdata(to_i2c_client(dev));
 393        struct lp55xx_chip *chip = led->chip;
 394        enum lp55xx_engine_mode mode = chip->engines[nr - 1].mode;
 395
 396        switch (mode) {
 397        case LP55XX_ENGINE_RUN:
 398                return sprintf(buf, "run\n");
 399        case LP55XX_ENGINE_LOAD:
 400                return sprintf(buf, "load\n");
 401        case LP55XX_ENGINE_DISABLED:
 402        default:
 403                return sprintf(buf, "disabled\n");
 404        }
 405}
 406show_mode(1)
 407show_mode(2)
 408show_mode(3)
 409
 410static ssize_t store_engine_mode(struct device *dev,
 411                                 struct device_attribute *attr,
 412                                 const char *buf, size_t len, int nr)
 413{
 414        struct lp55xx_led *led = i2c_get_clientdata(to_i2c_client(dev));
 415        struct lp55xx_chip *chip = led->chip;
 416        struct lp55xx_engine *engine = &chip->engines[nr - 1];
 417
 418        mutex_lock(&chip->lock);
 419
 420        chip->engine_idx = nr;
 421
 422        if (!strncmp(buf, "run", 3)) {
 423                lp5523_run_engine(chip, true);
 424                engine->mode = LP55XX_ENGINE_RUN;
 425        } else if (!strncmp(buf, "load", 4)) {
 426                lp5523_stop_engine(chip);
 427                lp5523_load_engine(chip);
 428                engine->mode = LP55XX_ENGINE_LOAD;
 429        } else if (!strncmp(buf, "disabled", 8)) {
 430                lp5523_stop_engine(chip);
 431                engine->mode = LP55XX_ENGINE_DISABLED;
 432        }
 433
 434        mutex_unlock(&chip->lock);
 435
 436        return len;
 437}
 438store_mode(1)
 439store_mode(2)
 440store_mode(3)
 441
 442static int lp5523_mux_parse(const char *buf, u16 *mux, size_t len)
 443{
 444        u16 tmp_mux = 0;
 445        int i;
 446
 447        len = min_t(int, len, LP5523_MAX_LEDS);
 448
 449        for (i = 0; i < len; i++) {
 450                switch (buf[i]) {
 451                case '1':
 452                        tmp_mux |= (1 << i);
 453                        break;
 454                case '0':
 455                        break;
 456                case '\n':
 457                        i = len;
 458                        break;
 459                default:
 460                        return -1;
 461                }
 462        }
 463        *mux = tmp_mux;
 464
 465        return 0;
 466}
 467
 468static void lp5523_mux_to_array(u16 led_mux, char *array)
 469{
 470        int i, pos = 0;
 471
 472        for (i = 0; i < LP5523_MAX_LEDS; i++)
 473                pos += sprintf(array + pos, "%x", LED_ACTIVE(led_mux, i));
 474
 475        array[pos] = '\0';
 476}
 477
 478static ssize_t show_engine_leds(struct device *dev,
 479                            struct device_attribute *attr,
 480                            char *buf, int nr)
 481{
 482        struct lp55xx_led *led = i2c_get_clientdata(to_i2c_client(dev));
 483        struct lp55xx_chip *chip = led->chip;
 484        char mux[LP5523_MAX_LEDS + 1];
 485
 486        lp5523_mux_to_array(chip->engines[nr - 1].led_mux, mux);
 487
 488        return sprintf(buf, "%s\n", mux);
 489}
 490show_leds(1)
 491show_leds(2)
 492show_leds(3)
 493
 494static int lp5523_load_mux(struct lp55xx_chip *chip, u16 mux, int nr)
 495{
 496        struct lp55xx_engine *engine = &chip->engines[nr - 1];
 497        int ret;
 498        static const u8 mux_page[] = {
 499                [LP55XX_ENGINE_1] = LP5523_PAGE_MUX1,
 500                [LP55XX_ENGINE_2] = LP5523_PAGE_MUX2,
 501                [LP55XX_ENGINE_3] = LP5523_PAGE_MUX3,
 502        };
 503
 504        lp5523_load_engine(chip);
 505
 506        ret = lp55xx_write(chip, LP5523_REG_PROG_PAGE_SEL, mux_page[nr]);
 507        if (ret)
 508                return ret;
 509
 510        ret = lp55xx_write(chip, LP5523_REG_PROG_MEM, (u8)(mux >> 8));
 511        if (ret)
 512                return ret;
 513
 514        ret = lp55xx_write(chip, LP5523_REG_PROG_MEM + 1, (u8)(mux));
 515        if (ret)
 516                return ret;
 517
 518        engine->led_mux = mux;
 519        return 0;
 520}
 521
 522static ssize_t store_engine_leds(struct device *dev,
 523                             struct device_attribute *attr,
 524                             const char *buf, size_t len, int nr)
 525{
 526        struct lp55xx_led *led = i2c_get_clientdata(to_i2c_client(dev));
 527        struct lp55xx_chip *chip = led->chip;
 528        struct lp55xx_engine *engine = &chip->engines[nr - 1];
 529        u16 mux = 0;
 530        ssize_t ret;
 531
 532        if (lp5523_mux_parse(buf, &mux, len))
 533                return -EINVAL;
 534
 535        mutex_lock(&chip->lock);
 536
 537        chip->engine_idx = nr;
 538        ret = -EINVAL;
 539
 540        if (engine->mode != LP55XX_ENGINE_LOAD)
 541                goto leave;
 542
 543        if (lp5523_load_mux(chip, mux, nr))
 544                goto leave;
 545
 546        ret = len;
 547leave:
 548        mutex_unlock(&chip->lock);
 549        return ret;
 550}
 551store_leds(1)
 552store_leds(2)
 553store_leds(3)
 554
 555static ssize_t store_engine_load(struct device *dev,
 556                             struct device_attribute *attr,
 557                             const char *buf, size_t len, int nr)
 558{
 559        struct lp55xx_led *led = i2c_get_clientdata(to_i2c_client(dev));
 560        struct lp55xx_chip *chip = led->chip;
 561        int ret;
 562
 563        mutex_lock(&chip->lock);
 564
 565        chip->engine_idx = nr;
 566        lp5523_load_engine_and_select_page(chip);
 567        ret = lp5523_update_program_memory(chip, buf, len);
 568
 569        mutex_unlock(&chip->lock);
 570
 571        return ret;
 572}
 573store_load(1)
 574store_load(2)
 575store_load(3)
 576
 577static ssize_t lp5523_selftest(struct device *dev,
 578                               struct device_attribute *attr,
 579                               char *buf)
 580{
 581        struct lp55xx_led *led = i2c_get_clientdata(to_i2c_client(dev));
 582        struct lp55xx_chip *chip = led->chip;
 583        struct lp55xx_platform_data *pdata = chip->pdata;
 584        int i, ret, pos = 0;
 585        u8 status, adc, vdd;
 586
 587        mutex_lock(&chip->lock);
 588
 589        ret = lp55xx_read(chip, LP5523_REG_STATUS, &status);
 590        if (ret < 0)
 591                goto fail;
 592
 593        /* Check that ext clock is really in use if requested */
 594        if (pdata->clock_mode == LP55XX_CLOCK_EXT) {
 595                if  ((status & LP5523_EXT_CLK_USED) == 0)
 596                        goto fail;
 597        }
 598
 599        /* Measure VDD (i.e. VBAT) first (channel 16 corresponds to VDD) */
 600        lp55xx_write(chip, LP5523_REG_LED_TEST_CTRL, LP5523_EN_LEDTEST | 16);
 601        usleep_range(3000, 6000); /* ADC conversion time is typically 2.7 ms */
 602        ret = lp55xx_read(chip, LP5523_REG_STATUS, &status);
 603        if (ret < 0)
 604                goto fail;
 605
 606        if (!(status & LP5523_LEDTEST_DONE))
 607                usleep_range(3000, 6000); /* Was not ready. Wait little bit */
 608
 609        ret = lp55xx_read(chip, LP5523_REG_LED_TEST_ADC, &vdd);
 610        if (ret < 0)
 611                goto fail;
 612
 613        vdd--;  /* There may be some fluctuation in measurement */
 614
 615        for (i = 0; i < LP5523_MAX_LEDS; i++) {
 616                /* Skip non-existing channels */
 617                if (pdata->led_config[i].led_current == 0)
 618                        continue;
 619
 620                /* Set default current */
 621                lp55xx_write(chip, LP5523_REG_LED_CURRENT_BASE + i,
 622                        pdata->led_config[i].led_current);
 623
 624                lp55xx_write(chip, LP5523_REG_LED_PWM_BASE + i, 0xff);
 625                /* let current stabilize 2 - 4ms before measurements start */
 626                usleep_range(2000, 4000);
 627                lp55xx_write(chip, LP5523_REG_LED_TEST_CTRL,
 628                             LP5523_EN_LEDTEST | i);
 629                /* ADC conversion time is 2.7 ms typically */
 630                usleep_range(3000, 6000);
 631                ret = lp55xx_read(chip, LP5523_REG_STATUS, &status);
 632                if (ret < 0)
 633                        goto fail;
 634
 635                if (!(status & LP5523_LEDTEST_DONE))
 636                        usleep_range(3000, 6000);/* Was not ready. Wait. */
 637
 638                ret = lp55xx_read(chip, LP5523_REG_LED_TEST_ADC, &adc);
 639                if (ret < 0)
 640                        goto fail;
 641
 642                if (adc >= vdd || adc < LP5523_ADC_SHORTCIRC_LIM)
 643                        pos += sprintf(buf + pos, "LED %d FAIL\n", i);
 644
 645                lp55xx_write(chip, LP5523_REG_LED_PWM_BASE + i, 0x00);
 646
 647                /* Restore current */
 648                lp55xx_write(chip, LP5523_REG_LED_CURRENT_BASE + i,
 649                        led->led_current);
 650                led++;
 651        }
 652        if (pos == 0)
 653                pos = sprintf(buf, "OK\n");
 654        goto release_lock;
 655fail:
 656        pos = sprintf(buf, "FAIL\n");
 657
 658release_lock:
 659        mutex_unlock(&chip->lock);
 660
 661        return pos;
 662}
 663
 664#define show_fader(nr)                                          \
 665static ssize_t show_master_fader##nr(struct device *dev,        \
 666                            struct device_attribute *attr,      \
 667                            char *buf)                          \
 668{                                                               \
 669        return show_master_fader(dev, attr, buf, nr);           \
 670}
 671
 672#define store_fader(nr)                                         \
 673static ssize_t store_master_fader##nr(struct device *dev,       \
 674                             struct device_attribute *attr,     \
 675                             const char *buf, size_t len)       \
 676{                                                               \
 677        return store_master_fader(dev, attr, buf, len, nr);     \
 678}
 679
 680static ssize_t show_master_fader(struct device *dev,
 681                                 struct device_attribute *attr,
 682                                 char *buf, int nr)
 683{
 684        struct lp55xx_led *led = i2c_get_clientdata(to_i2c_client(dev));
 685        struct lp55xx_chip *chip = led->chip;
 686        int ret;
 687        u8 val;
 688
 689        mutex_lock(&chip->lock);
 690        ret = lp55xx_read(chip, LP5523_REG_MASTER_FADER_BASE + nr - 1, &val);
 691        mutex_unlock(&chip->lock);
 692
 693        if (ret == 0)
 694                ret = sprintf(buf, "%u\n", val);
 695
 696        return ret;
 697}
 698show_fader(1)
 699show_fader(2)
 700show_fader(3)
 701
 702static ssize_t store_master_fader(struct device *dev,
 703                                  struct device_attribute *attr,
 704                                  const char *buf, size_t len, int nr)
 705{
 706        struct lp55xx_led *led = i2c_get_clientdata(to_i2c_client(dev));
 707        struct lp55xx_chip *chip = led->chip;
 708        int ret;
 709        unsigned long val;
 710
 711        if (kstrtoul(buf, 0, &val))
 712                return -EINVAL;
 713
 714        if (val > 0xff)
 715                return -EINVAL;
 716
 717        mutex_lock(&chip->lock);
 718        ret = lp55xx_write(chip, LP5523_REG_MASTER_FADER_BASE + nr - 1,
 719                           (u8)val);
 720        mutex_unlock(&chip->lock);
 721
 722        if (ret == 0)
 723                ret = len;
 724
 725        return ret;
 726}
 727store_fader(1)
 728store_fader(2)
 729store_fader(3)
 730
 731static ssize_t show_master_fader_leds(struct device *dev,
 732                                      struct device_attribute *attr,
 733                                      char *buf)
 734{
 735        struct lp55xx_led *led = i2c_get_clientdata(to_i2c_client(dev));
 736        struct lp55xx_chip *chip = led->chip;
 737        int i, ret, pos = 0;
 738        u8 val;
 739
 740        mutex_lock(&chip->lock);
 741
 742        for (i = 0; i < LP5523_MAX_LEDS; i++) {
 743                ret = lp55xx_read(chip, LP5523_REG_LED_CTRL_BASE + i, &val);
 744                if (ret)
 745                        goto leave;
 746
 747                val = (val & LP5523_FADER_MAPPING_MASK)
 748                        >> LP5523_FADER_MAPPING_SHIFT;
 749                if (val > 3) {
 750                        ret = -EINVAL;
 751                        goto leave;
 752                }
 753                buf[pos++] = val + '0';
 754        }
 755        buf[pos++] = '\n';
 756        ret = pos;
 757leave:
 758        mutex_unlock(&chip->lock);
 759        return ret;
 760}
 761
 762static ssize_t store_master_fader_leds(struct device *dev,
 763                                       struct device_attribute *attr,
 764                                       const char *buf, size_t len)
 765{
 766        struct lp55xx_led *led = i2c_get_clientdata(to_i2c_client(dev));
 767        struct lp55xx_chip *chip = led->chip;
 768        int i, n, ret;
 769        u8 val;
 770
 771        n = min_t(int, len, LP5523_MAX_LEDS);
 772
 773        mutex_lock(&chip->lock);
 774
 775        for (i = 0; i < n; i++) {
 776                if (buf[i] >= '0' && buf[i] <= '3') {
 777                        val = (buf[i] - '0') << LP5523_FADER_MAPPING_SHIFT;
 778                        ret = lp55xx_update_bits(chip,
 779                                                 LP5523_REG_LED_CTRL_BASE + i,
 780                                                 LP5523_FADER_MAPPING_MASK,
 781                                                 val);
 782                        if (ret)
 783                                goto leave;
 784                } else {
 785                        ret = -EINVAL;
 786                        goto leave;
 787                }
 788        }
 789        ret = len;
 790leave:
 791        mutex_unlock(&chip->lock);
 792        return ret;
 793}
 794
 795static int lp5523_multicolor_brightness(struct lp55xx_led *led)
 796{
 797        struct lp55xx_chip *chip = led->chip;
 798        int ret;
 799        int i;
 800
 801        mutex_lock(&chip->lock);
 802        for (i = 0; i < led->mc_cdev.num_colors; i++) {
 803                ret = lp55xx_write(chip,
 804                                   LP5523_REG_LED_PWM_BASE +
 805                                   led->mc_cdev.subled_info[i].channel,
 806                                   led->mc_cdev.subled_info[i].brightness);
 807                if (ret)
 808                        break;
 809        }
 810        mutex_unlock(&chip->lock);
 811        return ret;
 812}
 813
 814static int lp5523_led_brightness(struct lp55xx_led *led)
 815{
 816        struct lp55xx_chip *chip = led->chip;
 817        int ret;
 818
 819        mutex_lock(&chip->lock);
 820        ret = lp55xx_write(chip, LP5523_REG_LED_PWM_BASE + led->chan_nr,
 821                     led->brightness);
 822        mutex_unlock(&chip->lock);
 823        return ret;
 824}
 825
 826static LP55XX_DEV_ATTR_RW(engine1_mode, show_engine1_mode, store_engine1_mode);
 827static LP55XX_DEV_ATTR_RW(engine2_mode, show_engine2_mode, store_engine2_mode);
 828static LP55XX_DEV_ATTR_RW(engine3_mode, show_engine3_mode, store_engine3_mode);
 829static LP55XX_DEV_ATTR_RW(engine1_leds, show_engine1_leds, store_engine1_leds);
 830static LP55XX_DEV_ATTR_RW(engine2_leds, show_engine2_leds, store_engine2_leds);
 831static LP55XX_DEV_ATTR_RW(engine3_leds, show_engine3_leds, store_engine3_leds);
 832static LP55XX_DEV_ATTR_WO(engine1_load, store_engine1_load);
 833static LP55XX_DEV_ATTR_WO(engine2_load, store_engine2_load);
 834static LP55XX_DEV_ATTR_WO(engine3_load, store_engine3_load);
 835static LP55XX_DEV_ATTR_RO(selftest, lp5523_selftest);
 836static LP55XX_DEV_ATTR_RW(master_fader1, show_master_fader1,
 837                          store_master_fader1);
 838static LP55XX_DEV_ATTR_RW(master_fader2, show_master_fader2,
 839                          store_master_fader2);
 840static LP55XX_DEV_ATTR_RW(master_fader3, show_master_fader3,
 841                          store_master_fader3);
 842static LP55XX_DEV_ATTR_RW(master_fader_leds, show_master_fader_leds,
 843                          store_master_fader_leds);
 844
 845static struct attribute *lp5523_attributes[] = {
 846        &dev_attr_engine1_mode.attr,
 847        &dev_attr_engine2_mode.attr,
 848        &dev_attr_engine3_mode.attr,
 849        &dev_attr_engine1_load.attr,
 850        &dev_attr_engine2_load.attr,
 851        &dev_attr_engine3_load.attr,
 852        &dev_attr_engine1_leds.attr,
 853        &dev_attr_engine2_leds.attr,
 854        &dev_attr_engine3_leds.attr,
 855        &dev_attr_selftest.attr,
 856        &dev_attr_master_fader1.attr,
 857        &dev_attr_master_fader2.attr,
 858        &dev_attr_master_fader3.attr,
 859        &dev_attr_master_fader_leds.attr,
 860        NULL,
 861};
 862
 863static const struct attribute_group lp5523_group = {
 864        .attrs = lp5523_attributes,
 865};
 866
 867/* Chip specific configurations */
 868static struct lp55xx_device_config lp5523_cfg = {
 869        .reset = {
 870                .addr = LP5523_REG_RESET,
 871                .val  = LP5523_RESET,
 872        },
 873        .enable = {
 874                .addr = LP5523_REG_ENABLE,
 875                .val  = LP5523_ENABLE,
 876        },
 877        .max_channel  = LP5523_MAX_LEDS,
 878        .post_init_device   = lp5523_post_init_device,
 879        .brightness_fn      = lp5523_led_brightness,
 880        .multicolor_brightness_fn = lp5523_multicolor_brightness,
 881        .set_led_current    = lp5523_set_led_current,
 882        .firmware_cb        = lp5523_firmware_loaded,
 883        .run_engine         = lp5523_run_engine,
 884        .dev_attr_group     = &lp5523_group,
 885};
 886
 887static int lp5523_probe(struct i2c_client *client,
 888                        const struct i2c_device_id *id)
 889{
 890        int ret;
 891        struct lp55xx_chip *chip;
 892        struct lp55xx_led *led;
 893        struct lp55xx_platform_data *pdata = dev_get_platdata(&client->dev);
 894        struct device_node *np = dev_of_node(&client->dev);
 895
 896        chip = devm_kzalloc(&client->dev, sizeof(*chip), GFP_KERNEL);
 897        if (!chip)
 898                return -ENOMEM;
 899
 900        chip->cfg = &lp5523_cfg;
 901
 902        if (!pdata) {
 903                if (np) {
 904                        pdata = lp55xx_of_populate_pdata(&client->dev, np,
 905                                                         chip);
 906                        if (IS_ERR(pdata))
 907                                return PTR_ERR(pdata);
 908                } else {
 909                        dev_err(&client->dev, "no platform data\n");
 910                        return -EINVAL;
 911                }
 912        }
 913
 914        led = devm_kcalloc(&client->dev,
 915                        pdata->num_channels, sizeof(*led), GFP_KERNEL);
 916        if (!led)
 917                return -ENOMEM;
 918
 919        chip->cl = client;
 920        chip->pdata = pdata;
 921
 922        mutex_init(&chip->lock);
 923
 924        i2c_set_clientdata(client, led);
 925
 926        ret = lp55xx_init_device(chip);
 927        if (ret)
 928                goto err_init;
 929
 930        dev_info(&client->dev, "%s Programmable led chip found\n", id->name);
 931
 932        ret = lp55xx_register_leds(led, chip);
 933        if (ret)
 934                goto err_out;
 935
 936        ret = lp55xx_register_sysfs(chip);
 937        if (ret) {
 938                dev_err(&client->dev, "registering sysfs failed\n");
 939                goto err_out;
 940        }
 941
 942        return 0;
 943
 944err_out:
 945        lp55xx_deinit_device(chip);
 946err_init:
 947        return ret;
 948}
 949
 950static int lp5523_remove(struct i2c_client *client)
 951{
 952        struct lp55xx_led *led = i2c_get_clientdata(client);
 953        struct lp55xx_chip *chip = led->chip;
 954
 955        lp5523_stop_all_engines(chip);
 956        lp55xx_unregister_sysfs(chip);
 957        lp55xx_deinit_device(chip);
 958
 959        return 0;
 960}
 961
 962static const struct i2c_device_id lp5523_id[] = {
 963        { "lp5523",  LP5523 },
 964        { "lp55231", LP55231 },
 965        { }
 966};
 967
 968MODULE_DEVICE_TABLE(i2c, lp5523_id);
 969
 970#ifdef CONFIG_OF
 971static const struct of_device_id of_lp5523_leds_match[] = {
 972        { .compatible = "national,lp5523", },
 973        { .compatible = "ti,lp55231", },
 974        {},
 975};
 976
 977MODULE_DEVICE_TABLE(of, of_lp5523_leds_match);
 978#endif
 979
 980static struct i2c_driver lp5523_driver = {
 981        .driver = {
 982                .name   = "lp5523x",
 983                .of_match_table = of_match_ptr(of_lp5523_leds_match),
 984        },
 985        .probe          = lp5523_probe,
 986        .remove         = lp5523_remove,
 987        .id_table       = lp5523_id,
 988};
 989
 990module_i2c_driver(lp5523_driver);
 991
 992MODULE_AUTHOR("Mathias Nyman <mathias.nyman@nokia.com>");
 993MODULE_AUTHOR("Milo Kim <milo.kim@ti.com>");
 994MODULE_DESCRIPTION("LP5523 LED engine");
 995MODULE_LICENSE("GPL");
 996