Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0
0002 // TI LM3692x LED chip family driver
0003 // Copyright (C) 2017-18 Texas Instruments Incorporated - https://www.ti.com/
0004 
0005 #include <linux/gpio/consumer.h>
0006 #include <linux/i2c.h>
0007 #include <linux/init.h>
0008 #include <linux/leds.h>
0009 #include <linux/log2.h>
0010 #include <linux/mod_devicetable.h>
0011 #include <linux/module.h>
0012 #include <linux/mutex.h>
0013 #include <linux/regmap.h>
0014 #include <linux/regulator/consumer.h>
0015 #include <linux/slab.h>
0016 
0017 #define LM36922_MODEL   0
0018 #define LM36923_MODEL   1
0019 
0020 #define LM3692X_REV     0x0
0021 #define LM3692X_RESET       0x1
0022 #define LM3692X_EN      0x10
0023 #define LM3692X_BRT_CTRL    0x11
0024 #define LM3692X_PWM_CTRL    0x12
0025 #define LM3692X_BOOST_CTRL  0x13
0026 #define LM3692X_AUTO_FREQ_HI    0x15
0027 #define LM3692X_AUTO_FREQ_LO    0x16
0028 #define LM3692X_BL_ADJ_THRESH   0x17
0029 #define LM3692X_BRT_LSB     0x18
0030 #define LM3692X_BRT_MSB     0x19
0031 #define LM3692X_FAULT_CTRL  0x1e
0032 #define LM3692X_FAULT_FLAGS 0x1f
0033 
0034 #define LM3692X_SW_RESET    BIT(0)
0035 #define LM3692X_DEVICE_EN   BIT(0)
0036 #define LM3692X_LED1_EN     BIT(1)
0037 #define LM3692X_LED2_EN     BIT(2)
0038 #define LM36923_LED3_EN     BIT(3)
0039 #define LM3692X_ENABLE_MASK (LM3692X_DEVICE_EN | LM3692X_LED1_EN | \
0040                  LM3692X_LED2_EN | LM36923_LED3_EN)
0041 
0042 /* Brightness Control Bits */
0043 #define LM3692X_BL_ADJ_POL  BIT(0)
0044 #define LM3692X_RAMP_RATE_125us 0x00
0045 #define LM3692X_RAMP_RATE_250us BIT(1)
0046 #define LM3692X_RAMP_RATE_500us BIT(2)
0047 #define LM3692X_RAMP_RATE_1ms   (BIT(1) | BIT(2))
0048 #define LM3692X_RAMP_RATE_2ms   BIT(3)
0049 #define LM3692X_RAMP_RATE_4ms   (BIT(3) | BIT(1))
0050 #define LM3692X_RAMP_RATE_8ms   (BIT(2) | BIT(3))
0051 #define LM3692X_RAMP_RATE_16ms  (BIT(1) | BIT(2) | BIT(3))
0052 #define LM3692X_RAMP_EN     BIT(4)
0053 #define LM3692X_BRHT_MODE_REG   0x00
0054 #define LM3692X_BRHT_MODE_PWM   BIT(5)
0055 #define LM3692X_BRHT_MODE_MULTI_RAMP BIT(6)
0056 #define LM3692X_BRHT_MODE_RAMP_MULTI (BIT(5) | BIT(6))
0057 #define LM3692X_MAP_MODE_EXP    BIT(7)
0058 
0059 /* PWM Register Bits */
0060 #define LM3692X_PWM_FILTER_100  BIT(0)
0061 #define LM3692X_PWM_FILTER_150  BIT(1)
0062 #define LM3692X_PWM_FILTER_200  (BIT(0) | BIT(1))
0063 #define LM3692X_PWM_HYSTER_1LSB BIT(2)
0064 #define LM3692X_PWM_HYSTER_2LSB BIT(3)
0065 #define LM3692X_PWM_HYSTER_3LSB (BIT(3) | BIT(2))
0066 #define LM3692X_PWM_HYSTER_4LSB BIT(4)
0067 #define LM3692X_PWM_HYSTER_5LSB (BIT(4) | BIT(2))
0068 #define LM3692X_PWM_HYSTER_6LSB (BIT(4) | BIT(3))
0069 #define LM3692X_PWM_POLARITY    BIT(5)
0070 #define LM3692X_PWM_SAMP_4MHZ   BIT(6)
0071 #define LM3692X_PWM_SAMP_24MHZ  BIT(7)
0072 
0073 /* Boost Control Bits */
0074 #define LM3692X_OCP_PROT_1A BIT(0)
0075 #define LM3692X_OCP_PROT_1_25A  BIT(1)
0076 #define LM3692X_OCP_PROT_1_5A   (BIT(0) | BIT(1))
0077 #define LM3692X_OVP_21V     BIT(2)
0078 #define LM3692X_OVP_25V     BIT(3)
0079 #define LM3692X_OVP_29V     (BIT(2) | BIT(3))
0080 #define LM3692X_MIN_IND_22UH    BIT(4)
0081 #define LM3692X_BOOST_SW_1MHZ   BIT(5)
0082 #define LM3692X_BOOST_SW_NO_SHIFT   BIT(6)
0083 
0084 /* Fault Control Bits */
0085 #define LM3692X_FAULT_CTRL_OVP BIT(0)
0086 #define LM3692X_FAULT_CTRL_OCP BIT(1)
0087 #define LM3692X_FAULT_CTRL_TSD BIT(2)
0088 #define LM3692X_FAULT_CTRL_OPEN BIT(3)
0089 
0090 /* Fault Flag Bits */
0091 #define LM3692X_FAULT_FLAG_OVP BIT(0)
0092 #define LM3692X_FAULT_FLAG_OCP BIT(1)
0093 #define LM3692X_FAULT_FLAG_TSD BIT(2)
0094 #define LM3692X_FAULT_FLAG_SHRT BIT(3)
0095 #define LM3692X_FAULT_FLAG_OPEN BIT(4)
0096 
0097 /**
0098  * struct lm3692x_led
0099  * @lock: Lock for reading/writing the device
0100  * @client: Pointer to the I2C client
0101  * @led_dev: LED class device pointer
0102  * @regmap: Devices register map
0103  * @enable_gpio: VDDIO/EN gpio to enable communication interface
0104  * @regulator: LED supply regulator pointer
0105  * @led_enable: LED sync to be enabled
0106  * @model_id: Current device model ID enumerated
0107  */
0108 struct lm3692x_led {
0109     struct mutex lock;
0110     struct i2c_client *client;
0111     struct led_classdev led_dev;
0112     struct regmap *regmap;
0113     struct gpio_desc *enable_gpio;
0114     struct regulator *regulator;
0115     int led_enable;
0116     int model_id;
0117 
0118     u8 boost_ctrl, brightness_ctrl;
0119     bool enabled;
0120 };
0121 
0122 static const struct reg_default lm3692x_reg_defs[] = {
0123     {LM3692X_EN, 0xf},
0124     {LM3692X_BRT_CTRL, 0x61},
0125     {LM3692X_PWM_CTRL, 0x73},
0126     {LM3692X_BOOST_CTRL, 0x6f},
0127     {LM3692X_AUTO_FREQ_HI, 0x0},
0128     {LM3692X_AUTO_FREQ_LO, 0x0},
0129     {LM3692X_BL_ADJ_THRESH, 0x0},
0130     {LM3692X_BRT_LSB, 0x7},
0131     {LM3692X_BRT_MSB, 0xff},
0132     {LM3692X_FAULT_CTRL, 0x7},
0133 };
0134 
0135 static const struct regmap_config lm3692x_regmap_config = {
0136     .reg_bits = 8,
0137     .val_bits = 8,
0138 
0139     .max_register = LM3692X_FAULT_FLAGS,
0140     .reg_defaults = lm3692x_reg_defs,
0141     .num_reg_defaults = ARRAY_SIZE(lm3692x_reg_defs),
0142     .cache_type = REGCACHE_RBTREE,
0143 };
0144 
0145 static int lm3692x_fault_check(struct lm3692x_led *led)
0146 {
0147     int ret;
0148     unsigned int read_buf;
0149 
0150     ret = regmap_read(led->regmap, LM3692X_FAULT_FLAGS, &read_buf);
0151     if (ret)
0152         return ret;
0153 
0154     if (read_buf)
0155         dev_err(&led->client->dev, "Detected a fault 0x%X\n", read_buf);
0156 
0157     /* The first read may clear the fault.  Check again to see if the fault
0158      * still exits and return that value.
0159      */
0160     regmap_read(led->regmap, LM3692X_FAULT_FLAGS, &read_buf);
0161     if (read_buf)
0162         dev_err(&led->client->dev, "Second read of fault flags 0x%X\n",
0163             read_buf);
0164 
0165     return read_buf;
0166 }
0167 
0168 static int lm3692x_leds_enable(struct lm3692x_led *led)
0169 {
0170     int enable_state;
0171     int ret, reg_ret;
0172 
0173     if (led->enabled)
0174         return 0;
0175 
0176     if (led->regulator) {
0177         ret = regulator_enable(led->regulator);
0178         if (ret) {
0179             dev_err(&led->client->dev,
0180                 "Failed to enable regulator: %d\n", ret);
0181             return ret;
0182         }
0183     }
0184 
0185     if (led->enable_gpio)
0186         gpiod_direction_output(led->enable_gpio, 1);
0187 
0188     ret = lm3692x_fault_check(led);
0189     if (ret) {
0190         dev_err(&led->client->dev, "Cannot read/clear faults: %d\n",
0191             ret);
0192         goto out;
0193     }
0194 
0195     ret = regmap_write(led->regmap, LM3692X_BRT_CTRL, 0x00);
0196     if (ret)
0197         goto out;
0198 
0199     /*
0200      * For glitch free operation, the following data should
0201      * only be written while LEDx enable bits are 0 and the device enable
0202      * bit is set to 1.
0203      * per Section 7.5.14 of the data sheet
0204      */
0205     ret = regmap_write(led->regmap, LM3692X_EN, LM3692X_DEVICE_EN);
0206     if (ret)
0207         goto out;
0208 
0209     /* Set the brightness to 0 so when enabled the LEDs do not come
0210      * on with full brightness.
0211      */
0212     ret = regmap_write(led->regmap, LM3692X_BRT_MSB, 0);
0213     if (ret)
0214         goto out;
0215 
0216     ret = regmap_write(led->regmap, LM3692X_BRT_LSB, 0);
0217     if (ret)
0218         goto out;
0219 
0220     ret = regmap_write(led->regmap, LM3692X_PWM_CTRL,
0221         LM3692X_PWM_FILTER_100 | LM3692X_PWM_SAMP_24MHZ);
0222     if (ret)
0223         goto out;
0224 
0225     ret = regmap_write(led->regmap, LM3692X_BOOST_CTRL, led->boost_ctrl);
0226     if (ret)
0227         goto out;
0228 
0229     ret = regmap_write(led->regmap, LM3692X_AUTO_FREQ_HI, 0x00);
0230     if (ret)
0231         goto out;
0232 
0233     ret = regmap_write(led->regmap, LM3692X_AUTO_FREQ_LO, 0x00);
0234     if (ret)
0235         goto out;
0236 
0237     ret = regmap_write(led->regmap, LM3692X_BL_ADJ_THRESH, 0x00);
0238     if (ret)
0239         goto out;
0240 
0241     ret = regmap_write(led->regmap, LM3692X_BRT_CTRL,
0242             LM3692X_BL_ADJ_POL | LM3692X_RAMP_EN);
0243     if (ret)
0244         goto out;
0245 
0246     switch (led->led_enable) {
0247     case 0:
0248     default:
0249         if (led->model_id == LM36923_MODEL)
0250             enable_state = LM3692X_LED1_EN | LM3692X_LED2_EN |
0251                    LM36923_LED3_EN;
0252         else
0253             enable_state = LM3692X_LED1_EN | LM3692X_LED2_EN;
0254 
0255         break;
0256     case 1:
0257         enable_state = LM3692X_LED1_EN;
0258         break;
0259     case 2:
0260         enable_state = LM3692X_LED2_EN;
0261         break;
0262 
0263     case 3:
0264         if (led->model_id == LM36923_MODEL) {
0265             enable_state = LM36923_LED3_EN;
0266             break;
0267         }
0268 
0269         ret = -EINVAL;
0270         dev_err(&led->client->dev,
0271             "LED3 sync not available on this device\n");
0272         goto out;
0273     }
0274 
0275     ret = regmap_update_bits(led->regmap, LM3692X_EN, LM3692X_ENABLE_MASK,
0276                  enable_state | LM3692X_DEVICE_EN);
0277 
0278     led->enabled = true;
0279     return ret;
0280 out:
0281     dev_err(&led->client->dev, "Fail writing initialization values\n");
0282 
0283     if (led->enable_gpio)
0284         gpiod_direction_output(led->enable_gpio, 0);
0285 
0286     if (led->regulator) {
0287         reg_ret = regulator_disable(led->regulator);
0288         if (reg_ret)
0289             dev_err(&led->client->dev,
0290                 "Failed to disable regulator: %d\n", reg_ret);
0291     }
0292 
0293     return ret;
0294 }
0295 
0296 static int lm3692x_leds_disable(struct lm3692x_led *led)
0297 {
0298     int ret;
0299 
0300     if (!led->enabled)
0301         return 0;
0302 
0303     ret = regmap_update_bits(led->regmap, LM3692X_EN, LM3692X_DEVICE_EN, 0);
0304     if (ret) {
0305         dev_err(&led->client->dev, "Failed to disable regulator: %d\n",
0306             ret);
0307         return ret;
0308     }
0309 
0310     if (led->enable_gpio)
0311         gpiod_direction_output(led->enable_gpio, 0);
0312 
0313     if (led->regulator) {
0314         ret = regulator_disable(led->regulator);
0315         if (ret)
0316             dev_err(&led->client->dev,
0317                 "Failed to disable regulator: %d\n", ret);
0318     }
0319 
0320     led->enabled = false;
0321     return ret;
0322 }
0323 
0324 static int lm3692x_brightness_set(struct led_classdev *led_cdev,
0325                 enum led_brightness brt_val)
0326 {
0327     struct lm3692x_led *led =
0328             container_of(led_cdev, struct lm3692x_led, led_dev);
0329     int ret;
0330     int led_brightness_lsb = (brt_val >> 5);
0331 
0332     mutex_lock(&led->lock);
0333 
0334     if (brt_val == 0) {
0335         ret = lm3692x_leds_disable(led);
0336         goto out;
0337     } else {
0338         lm3692x_leds_enable(led);
0339     }
0340 
0341     ret = lm3692x_fault_check(led);
0342     if (ret) {
0343         dev_err(&led->client->dev, "Cannot read/clear faults: %d\n",
0344             ret);
0345         goto out;
0346     }
0347 
0348     ret = regmap_write(led->regmap, LM3692X_BRT_MSB, brt_val);
0349     if (ret) {
0350         dev_err(&led->client->dev, "Cannot write MSB: %d\n", ret);
0351         goto out;
0352     }
0353 
0354     ret = regmap_write(led->regmap, LM3692X_BRT_LSB, led_brightness_lsb);
0355     if (ret) {
0356         dev_err(&led->client->dev, "Cannot write LSB: %d\n", ret);
0357         goto out;
0358     }
0359 out:
0360     mutex_unlock(&led->lock);
0361     return ret;
0362 }
0363 
0364 static enum led_brightness lm3692x_max_brightness(struct lm3692x_led *led,
0365                           u32 max_cur)
0366 {
0367     u32 max_code;
0368 
0369     /* see p.12 of LM36922 data sheet for brightness formula */
0370     max_code = ((max_cur * 1000) - 37806) / 12195;
0371     if (max_code > 0x7FF)
0372         max_code = 0x7FF;
0373 
0374     return max_code >> 3;
0375 }
0376 
0377 static int lm3692x_probe_dt(struct lm3692x_led *led)
0378 {
0379     struct fwnode_handle *child = NULL;
0380     struct led_init_data init_data = {};
0381     u32 ovp, max_cur;
0382     int ret;
0383 
0384     led->enable_gpio = devm_gpiod_get_optional(&led->client->dev,
0385                            "enable", GPIOD_OUT_LOW);
0386     if (IS_ERR(led->enable_gpio)) {
0387         ret = PTR_ERR(led->enable_gpio);
0388         dev_err(&led->client->dev, "Failed to get enable gpio: %d\n",
0389             ret);
0390         return ret;
0391     }
0392 
0393     led->regulator = devm_regulator_get_optional(&led->client->dev, "vled");
0394     if (IS_ERR(led->regulator)) {
0395         ret = PTR_ERR(led->regulator);
0396         if (ret != -ENODEV)
0397             return dev_err_probe(&led->client->dev, ret,
0398                          "Failed to get vled regulator\n");
0399 
0400         led->regulator = NULL;
0401     }
0402 
0403     led->boost_ctrl = LM3692X_BOOST_SW_1MHZ |
0404         LM3692X_BOOST_SW_NO_SHIFT |
0405         LM3692X_OCP_PROT_1_5A;
0406     ret = device_property_read_u32(&led->client->dev,
0407                        "ti,ovp-microvolt", &ovp);
0408     if (ret) {
0409         led->boost_ctrl |= LM3692X_OVP_29V;
0410     } else {
0411         switch (ovp) {
0412         case 17000000:
0413             break;
0414         case 21000000:
0415             led->boost_ctrl |= LM3692X_OVP_21V;
0416             break;
0417         case 25000000:
0418             led->boost_ctrl |= LM3692X_OVP_25V;
0419             break;
0420         case 29000000:
0421             led->boost_ctrl |= LM3692X_OVP_29V;
0422             break;
0423         default:
0424             dev_err(&led->client->dev, "Invalid OVP %d\n", ovp);
0425             return -EINVAL;
0426         }
0427     }
0428 
0429     child = device_get_next_child_node(&led->client->dev, child);
0430     if (!child) {
0431         dev_err(&led->client->dev, "No LED Child node\n");
0432         return -ENODEV;
0433     }
0434 
0435     ret = fwnode_property_read_u32(child, "reg", &led->led_enable);
0436     if (ret) {
0437         fwnode_handle_put(child);
0438         dev_err(&led->client->dev, "reg DT property missing\n");
0439         return ret;
0440     }
0441 
0442     ret = fwnode_property_read_u32(child, "led-max-microamp", &max_cur);
0443     led->led_dev.max_brightness = ret ? LED_FULL :
0444         lm3692x_max_brightness(led, max_cur);
0445 
0446     init_data.fwnode = child;
0447     init_data.devicename = led->client->name;
0448     init_data.default_label = ":";
0449 
0450     ret = devm_led_classdev_register_ext(&led->client->dev, &led->led_dev,
0451                          &init_data);
0452     if (ret)
0453         dev_err(&led->client->dev, "led register err: %d\n", ret);
0454 
0455     fwnode_handle_put(init_data.fwnode);
0456     return ret;
0457 }
0458 
0459 static int lm3692x_probe(struct i2c_client *client,
0460             const struct i2c_device_id *id)
0461 {
0462     struct lm3692x_led *led;
0463     int ret;
0464 
0465     led = devm_kzalloc(&client->dev, sizeof(*led), GFP_KERNEL);
0466     if (!led)
0467         return -ENOMEM;
0468 
0469     mutex_init(&led->lock);
0470     led->client = client;
0471     led->led_dev.brightness_set_blocking = lm3692x_brightness_set;
0472     led->model_id = id->driver_data;
0473     i2c_set_clientdata(client, led);
0474 
0475     led->regmap = devm_regmap_init_i2c(client, &lm3692x_regmap_config);
0476     if (IS_ERR(led->regmap)) {
0477         ret = PTR_ERR(led->regmap);
0478         dev_err(&client->dev, "Failed to allocate register map: %d\n",
0479             ret);
0480         return ret;
0481     }
0482 
0483     ret = lm3692x_probe_dt(led);
0484     if (ret)
0485         return ret;
0486 
0487     ret = lm3692x_leds_enable(led);
0488     if (ret)
0489         return ret;
0490 
0491     return 0;
0492 }
0493 
0494 static int lm3692x_remove(struct i2c_client *client)
0495 {
0496     struct lm3692x_led *led = i2c_get_clientdata(client);
0497 
0498     lm3692x_leds_disable(led);
0499     mutex_destroy(&led->lock);
0500 
0501     return 0;
0502 }
0503 
0504 static const struct i2c_device_id lm3692x_id[] = {
0505     { "lm36922", LM36922_MODEL },
0506     { "lm36923", LM36923_MODEL },
0507     { }
0508 };
0509 MODULE_DEVICE_TABLE(i2c, lm3692x_id);
0510 
0511 static const struct of_device_id of_lm3692x_leds_match[] = {
0512     { .compatible = "ti,lm36922", },
0513     { .compatible = "ti,lm36923", },
0514     {},
0515 };
0516 MODULE_DEVICE_TABLE(of, of_lm3692x_leds_match);
0517 
0518 static struct i2c_driver lm3692x_driver = {
0519     .driver = {
0520         .name   = "lm3692x",
0521         .of_match_table = of_lm3692x_leds_match,
0522     },
0523     .probe      = lm3692x_probe,
0524     .remove     = lm3692x_remove,
0525     .id_table   = lm3692x_id,
0526 };
0527 module_i2c_driver(lm3692x_driver);
0528 
0529 MODULE_DESCRIPTION("Texas Instruments LM3692X LED driver");
0530 MODULE_AUTHOR("Dan Murphy <dmurphy@ti.com>");
0531 MODULE_LICENSE("GPL v2");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!