drivers/leds/leds-lp5521.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * LP5521 LED chip driver.
   4  *
   5  * Copyright (C) 2010 Nokia Corporation
   6  * Copyright (C) 2012 Texas Instruments
   7  *
   8  * Contact: Samu Onkalo <[email protected]>
   9  *          Milo(Woogyom) Kim <[email protected]>
  10  */
  11
  12 #include <linux/cleanup.h>
  13 #include <linux/delay.h>
  14 #include <linux/firmware.h>
  15 #include <linux/i2c.h>
  16 #include <linux/leds.h>
  17 #include <linux/module.h>
  18 #include <linux/mutex.h>
  19 #include <linux/platform_data/leds-lp55xx.h>
  20 #include <linux/slab.h>
  21 #include <linux/of.h>
  22
  23 #include "leds-lp55xx-common.h"
  24
  25 #define LP5521_MAX_LEDS                 3
  26 #define LP5521_CMD_DIRECT               0x3F
  27
  28 /* Registers */
  29 #define LP5521_REG_ENABLE               0x00
  30 #define LP5521_REG_OP_MODE              0x01
  31 #define LP5521_REG_R_PWM                0x02
  32 #define LP5521_REG_G_PWM                0x03
  33 #define LP5521_REG_B_PWM                0x04
  34 #define LP5521_REG_R_CURRENT            0x05
  35 #define LP5521_REG_G_CURRENT            0x06
  36 #define LP5521_REG_B_CURRENT            0x07
  37 #define LP5521_REG_CONFIG               0x08
  38 #define LP5521_REG_STATUS               0x0C
  39 #define LP5521_REG_RESET                0x0D
  40 #define LP5521_REG_R_PROG_MEM           0x10
  41 #define LP5521_REG_G_PROG_MEM           0x30
  42 #define LP5521_REG_B_PROG_MEM           0x50
  43
  44 /* Base register to set LED current */
  45 #define LP5521_REG_LED_CURRENT_BASE     LP5521_REG_R_CURRENT
  46 /* Base register to set the brightness */
  47 #define LP5521_REG_LED_PWM_BASE         LP5521_REG_R_PWM
  48
  49 /* Bits in ENABLE register */
  50 #define LP5521_MASTER_ENABLE            0x40    /* Chip master enable */
  51 #define LP5521_LOGARITHMIC_PWM          0x80    /* Logarithmic PWM adjustment */
  52 #define LP5521_EXEC_RUN                 0x2A
  53 #define LP5521_ENABLE_DEFAULT   \
  54         (LP5521_MASTER_ENABLE | LP5521_LOGARITHMIC_PWM)
  55 #define LP5521_ENABLE_RUN_PROGRAM       \
  56         (LP5521_ENABLE_DEFAULT | LP5521_EXEC_RUN)
  57
  58 /* CONFIG register */
  59 #define LP5521_PWM_HF                   0x40    /* PWM: 0 = 256Hz, 1 = 558Hz */
  60 #define LP5521_PWRSAVE_EN               0x20    /* 1 = Power save mode */
  61 #define LP5521_CP_MODE_MASK             0x18    /* Charge pump mode */
  62 #define LP5521_CP_MODE_SHIFT            3
  63 #define LP5521_R_TO_BATT                0x04    /* R out: 0 = CP, 1 = Vbat */
  64 #define LP5521_CLK_INT                  0x01    /* Internal clock */
  65 #define LP5521_DEFAULT_CFG              (LP5521_PWM_HF | LP5521_PWRSAVE_EN)
  66
  67 /* Status */
  68 #define LP5521_EXT_CLK_USED             0x08
  69
  70 /* default R channel current register value */
  71 #define LP5521_REG_R_CURR_DEFAULT       0xAF
  72
  73 /* Reset register value */
  74 #define LP5521_RESET                    0xFF
  75
  76 static inline void lp5521_wait_opmode_done(void)
  77 {
  78         /* operation mode change needs to be longer than 153 us */
  79         usleep_range(200, 300);
  80 }
  81
  82 static inline void lp5521_wait_enable_done(void)
  83 {
  84         /* it takes more 488 us to update ENABLE register */
  85         usleep_range(500, 600);
  86 }
  87
  88 static void lp5521_run_engine(struct lp55xx_chip *chip, bool start)
  89 {
  90         int ret;
  91
  92         /* stop engine */
  93         if (!start) {
  94                 lp55xx_stop_engine(chip);
  95                 lp55xx_write(chip, LP5521_REG_OP_MODE, LP5521_CMD_DIRECT);
  96                 lp5521_wait_opmode_done();
  97                 return;
  98         }
  99
 100         ret = lp55xx_run_engine_common(chip);
 101         if (!ret)
 102                 lp5521_wait_enable_done();
 103 }
 104
 105 static int lp5521_post_init_device(struct lp55xx_chip *chip)
 106 {
 107         int ret;
 108         u8 val;
 109
 110         /*
 111          * Make sure that the chip is reset by reading back the r channel
 112          * current reg. This is dummy read is required on some platforms -
 113          * otherwise further access to the R G B channels in the
 114          * LP5521_REG_ENABLE register will not have any effect - strange!
 115          */
 116         ret = lp55xx_read(chip, LP5521_REG_R_CURRENT, &val);
 117         if (ret) {
 118                 dev_err(&chip->cl->dev, "error in resetting chip\n");
 119                 return ret;
 120         }
 121         if (val != LP5521_REG_R_CURR_DEFAULT) {
 122                 dev_err(&chip->cl->dev,
 123                         "unexpected data in register (expected 0x%x got 0x%x)\n",
 124                         LP5521_REG_R_CURR_DEFAULT, val);
 125                 ret = -EINVAL;
 126                 return ret;
 127         }
 128         usleep_range(10000, 20000);
 129
 130         /* Set all PWMs to direct control mode */
 131         ret = lp55xx_write(chip, LP5521_REG_OP_MODE, LP5521_CMD_DIRECT);
 132         if (ret)
 133                 return ret;
 134
 135         /* Update configuration for the clock setting */
 136         val = LP5521_DEFAULT_CFG;
 137         if (!lp55xx_is_extclk_used(chip))
 138                 val |= LP5521_CLK_INT;
 139
 140         val |= (chip->pdata->charge_pump_mode << LP5521_CP_MODE_SHIFT) & LP5521_CP_MODE_MASK;
 141
 142         ret = lp55xx_write(chip, LP5521_REG_CONFIG, val);
 143         if (ret)
 144                 return ret;
 145
 146         /* Initialize all channels PWM to zero -> leds off */
 147         lp55xx_write(chip, LP5521_REG_R_PWM, 0);
 148         lp55xx_write(chip, LP5521_REG_G_PWM, 0);
 149         lp55xx_write(chip, LP5521_REG_B_PWM, 0);
 150
 151         /* Set engines are set to run state when OP_MODE enables engines */
 152         ret = lp55xx_write(chip, LP5521_REG_ENABLE, LP5521_ENABLE_RUN_PROGRAM);
 153         if (ret)
 154                 return ret;
 155
 156         lp5521_wait_enable_done();
 157
 158         return 0;
 159 }
 160
 161 static int lp5521_run_selftest(struct lp55xx_chip *chip, char *buf)
 162 {
 163         struct lp55xx_platform_data *pdata = chip->pdata;
 164         int ret;
 165         u8 status;
 166
 167         ret = lp55xx_read(chip, LP5521_REG_STATUS, &status);
 168         if (ret < 0)
 169                 return ret;
 170
 171         if (pdata->clock_mode != LP55XX_CLOCK_EXT)
 172                 return 0;
 173
 174         /* Check that ext clock is really in use if requested */
 175         if  ((status & LP5521_EXT_CLK_USED) == 0)
 176                 return -EIO;
 177
 178         return 0;
 179 }
 180
 181 static ssize_t lp5521_selftest(struct device *dev,
 182                                struct device_attribute *attr,
 183                                char *buf)
 184 {
 185         struct lp55xx_led *led = i2c_get_clientdata(to_i2c_client(dev));
 186         struct lp55xx_chip *chip = led->chip;
 187         int ret;
 188
 189         guard(mutex)(&chip->lock);
 190
 191         ret = lp5521_run_selftest(chip, buf);
 192
 193         return sysfs_emit(buf, "%s\n", ret ? "FAIL" : "OK");
 194 }
 195
 196 /* device attributes */
 197 LP55XX_DEV_ATTR_ENGINE_MODE(1);
 198 LP55XX_DEV_ATTR_ENGINE_MODE(2);
 199 LP55XX_DEV_ATTR_ENGINE_MODE(3);
 200 LP55XX_DEV_ATTR_ENGINE_LOAD(1);
 201 LP55XX_DEV_ATTR_ENGINE_LOAD(2);
 202 LP55XX_DEV_ATTR_ENGINE_LOAD(3);
 203 static LP55XX_DEV_ATTR_RO(selftest, lp5521_selftest);
 204
 205 static struct attribute *lp5521_attributes[] = {
 206         &dev_attr_engine1_mode.attr,
 207         &dev_attr_engine2_mode.attr,
 208         &dev_attr_engine3_mode.attr,
 209         &dev_attr_engine1_load.attr,
 210         &dev_attr_engine2_load.attr,
 211         &dev_attr_engine3_load.attr,
 212         &dev_attr_selftest.attr,
 213         NULL
 214 };
 215
 216 static const struct attribute_group lp5521_group = {
 217         .attrs = lp5521_attributes,
 218 };
 219
 220 /* Chip specific configurations */
 221 static struct lp55xx_device_config lp5521_cfg = {
 222         .reg_op_mode = {
 223                 .addr = LP5521_REG_OP_MODE,
 224         },
 225         .reg_exec = {
 226                 .addr = LP5521_REG_ENABLE,
 227         },
 228         .reset = {
 229                 .addr = LP5521_REG_RESET,
 230                 .val  = LP5521_RESET,
 231         },
 232         .enable = {
 233                 .addr = LP5521_REG_ENABLE,
 234                 .val  = LP5521_ENABLE_DEFAULT,
 235         },
 236         .prog_mem_base = {
 237                 .addr = LP5521_REG_R_PROG_MEM,
 238         },
 239         .reg_led_pwm_base = {
 240                 .addr = LP5521_REG_LED_PWM_BASE,
 241         },
 242         .reg_led_current_base = {
 243                 .addr = LP5521_REG_LED_CURRENT_BASE,
 244         },
 245         .max_channel  = LP5521_MAX_LEDS,
 246         .post_init_device   = lp5521_post_init_device,
 247         .brightness_fn      = lp55xx_led_brightness,
 248         .multicolor_brightness_fn = lp55xx_multicolor_brightness,
 249         .set_led_current    = lp55xx_set_led_current,
 250         .firmware_cb        = lp55xx_firmware_loaded_cb,
 251         .run_engine         = lp5521_run_engine,
 252         .dev_attr_group     = &lp5521_group,
 253 };
 254
 255 static const struct i2c_device_id lp5521_id[] = {
 256         { "lp5521", .driver_data = (kernel_ulong_t)&lp5521_cfg, }, /* Three channel chip */
 257         { }
 258 };
 259 MODULE_DEVICE_TABLE(i2c, lp5521_id);
 260
 261 static const struct of_device_id of_lp5521_leds_match[] = {
 262         { .compatible = "national,lp5521", .data = &lp5521_cfg, },
 263         {},
 264 };
 265
 266 MODULE_DEVICE_TABLE(of, of_lp5521_leds_match);
 267
 268 static struct i2c_driver lp5521_driver = {
 269         .driver = {
 270                 .name   = "lp5521",
 271                 .of_match_table = of_lp5521_leds_match,
 272         },
 273         .probe          = lp55xx_probe,
 274         .remove         = lp55xx_remove,
 275         .id_table       = lp5521_id,
 276 };
 277
 278 module_i2c_driver(lp5521_driver);
 279
 280 MODULE_AUTHOR("Mathias Nyman, Yuri Zaporozhets, Samu Onkalo");
 281 MODULE_AUTHOR("Milo Kim <[email protected]>");
 282 MODULE_DESCRIPTION("LP5521 LED engine");
 283 MODULE_LICENSE("GPL v2");