drivers/leds/leds-tlc591xx.c

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * Copyright 2014 Belkin Inc.
0004  * Copyright 2015 Andrew Lunn <andrew@lunn.ch>
0005  */
0006
0007 #include <linux/i2c.h>
0008 #include <linux/leds.h>
0009 #include <linux/module.h>
0010 #include <linux/of.h>
0011 #include <linux/of_device.h>
0012 #include <linux/regmap.h>
0013 #include <linux/slab.h>
0014
0015 #define TLC591XX_MAX_LEDS   16
0016 #define TLC591XX_MAX_BRIGHTNESS 256
0017
0018 #define TLC591XX_REG_MODE1  0x00
0019 #define MODE1_RESPON_ADDR_MASK  0xF0
0020 #define MODE1_NORMAL_MODE   (0 << 4)
0021 #define MODE1_SPEED_MODE    (1 << 4)
0022
0023 #define TLC591XX_REG_MODE2  0x01
0024 #define MODE2_DIM       (0 << 5)
0025 #define MODE2_BLINK     (1 << 5)
0026 #define MODE2_OCH_STOP      (0 << 3)
0027 #define MODE2_OCH_ACK       (1 << 3)
0028
0029 #define TLC591XX_REG_PWM(x) (0x02 + (x))
0030
0031 #define TLC591XX_REG_GRPPWM 0x12
0032 #define TLC591XX_REG_GRPFREQ    0x13
0033
0034 /* LED Driver Output State, determine the source that drives LED outputs */
0035 #define LEDOUT_OFF      0x0 /* Output LOW */
0036 #define LEDOUT_ON       0x1 /* Output HI-Z */
0037 #define LEDOUT_DIM      0x2 /* Dimming */
0038 #define LEDOUT_BLINK        0x3 /* Blinking */
0039 #define LEDOUT_MASK     0x3
0040
0041 #define ldev_to_led(c)      container_of(c, struct tlc591xx_led, ldev)
0042
0043 struct tlc591xx_led {
0044     bool active;
0045     unsigned int led_no;
0046     struct led_classdev ldev;
0047     struct tlc591xx_priv *priv;
0048 };
0049
0050 struct tlc591xx_priv {
0051     struct tlc591xx_led leds[TLC591XX_MAX_LEDS];
0052     struct regmap *regmap;
0053     unsigned int reg_ledout_offset;
0054 };
0055
0056 struct tlc591xx {
0057     unsigned int max_leds;
0058     unsigned int reg_ledout_offset;
0059 };
0060
0061 static const struct tlc591xx tlc59116 = {
0062     .max_leds = 16,
0063     .reg_ledout_offset = 0x14,
0064 };
0065
0066 static const struct tlc591xx tlc59108 = {
0067     .max_leds = 8,
0068     .reg_ledout_offset = 0x0c,
0069 };
0070
0071 static int
0072 tlc591xx_set_mode(struct regmap *regmap, u8 mode)
0073 {
0074     int err;
0075     u8 val;
0076
0077     err = regmap_write(regmap, TLC591XX_REG_MODE1, MODE1_NORMAL_MODE);
0078     if (err)
0079         return err;
0080
0081     val = MODE2_OCH_STOP | mode;
0082
0083     return regmap_write(regmap, TLC591XX_REG_MODE2, val);
0084 }
0085
0086 static int
0087 tlc591xx_set_ledout(struct tlc591xx_priv *priv, struct tlc591xx_led *led,
0088             u8 val)
0089 {
0090     unsigned int i = (led->led_no % 4) * 2;
0091     unsigned int mask = LEDOUT_MASK << i;
0092     unsigned int addr = priv->reg_ledout_offset + (led->led_no >> 2);
0093
0094     val = val << i;
0095
0096     return regmap_update_bits(priv->regmap, addr, mask, val);
0097 }
0098
0099 static int
0100 tlc591xx_set_pwm(struct tlc591xx_priv *priv, struct tlc591xx_led *led,
0101          u8 brightness)
0102 {
0103     u8 pwm = TLC591XX_REG_PWM(led->led_no);
0104
0105     return regmap_write(priv->regmap, pwm, brightness);
0106 }
0107
0108 static int
0109 tlc591xx_brightness_set(struct led_classdev *led_cdev,
0110             enum led_brightness brightness)
0111 {
0112     struct tlc591xx_led *led = ldev_to_led(led_cdev);
0113     struct tlc591xx_priv *priv = led->priv;
0114     int err;
0115
0116     switch ((int)brightness) {
0117     case 0:
0118         err = tlc591xx_set_ledout(priv, led, LEDOUT_OFF);
0119         break;
0120     case TLC591XX_MAX_BRIGHTNESS:
0121         err = tlc591xx_set_ledout(priv, led, LEDOUT_ON);
0122         break;
0123     default:
0124         err = tlc591xx_set_ledout(priv, led, LEDOUT_DIM);
0125         if (!err)
0126             err = tlc591xx_set_pwm(priv, led, brightness);
0127     }
0128
0129     return err;
0130 }
0131
0132 static const struct regmap_config tlc591xx_regmap = {
0133     .reg_bits = 8,
0134     .val_bits = 8,
0135     .max_register = 0x1e,
0136 };
0137
0138 static const struct of_device_id of_tlc591xx_leds_match[] = {
0139     { .compatible = "ti,tlc59116",
0140       .data = &tlc59116 },
0141     { .compatible = "ti,tlc59108",
0142       .data = &tlc59108 },
0143     {},
0144 };
0145 MODULE_DEVICE_TABLE(of, of_tlc591xx_leds_match);
0146
0147 static int
0148 tlc591xx_probe(struct i2c_client *client,
0149            const struct i2c_device_id *id)
0150 {
0151     struct device_node *np, *child;
0152     struct device *dev = &client->dev;
0153     const struct tlc591xx *tlc591xx;
0154     struct tlc591xx_priv *priv;
0155     int err, count, reg;
0156
0157     np = dev_of_node(dev);
0158     if (!np)
0159         return -ENODEV;
0160
0161     tlc591xx = device_get_match_data(dev);
0162     if (!tlc591xx)
0163         return -ENODEV;
0164
0165     count = of_get_available_child_count(np);
0166     if (!count || count > tlc591xx->max_leds)
0167         return -EINVAL;
0168
0169     priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
0170     if (!priv)
0171         return -ENOMEM;
0172
0173     priv->regmap = devm_regmap_init_i2c(client, &tlc591xx_regmap);
0174     if (IS_ERR(priv->regmap)) {
0175         err = PTR_ERR(priv->regmap);
0176         dev_err(dev, "Failed to allocate register map: %d\n", err);
0177         return err;
0178     }
0179     priv->reg_ledout_offset = tlc591xx->reg_ledout_offset;
0180
0181     i2c_set_clientdata(client, priv);
0182
0183     err = tlc591xx_set_mode(priv->regmap, MODE2_DIM);
0184     if (err < 0)
0185         return err;
0186
0187     for_each_available_child_of_node(np, child) {
0188         struct tlc591xx_led *led;
0189         struct led_init_data init_data = {};
0190
0191         init_data.fwnode = of_fwnode_handle(child);
0192
0193         err = of_property_read_u32(child, "reg", &reg);
0194         if (err) {
0195             of_node_put(child);
0196             return err;
0197         }
0198         if (reg < 0 || reg >= tlc591xx->max_leds ||
0199             priv->leds[reg].active) {
0200             of_node_put(child);
0201             return -EINVAL;
0202         }
0203         led = &priv->leds[reg];
0204
0205         led->active = true;
0206         led->priv = priv;
0207         led->led_no = reg;
0208         led->ldev.brightness_set_blocking = tlc591xx_brightness_set;
0209         led->ldev.max_brightness = TLC591XX_MAX_BRIGHTNESS;
0210         err = devm_led_classdev_register_ext(dev, &led->ldev,
0211                              &init_data);
0212         if (err < 0) {
0213             of_node_put(child);
0214             return dev_err_probe(dev, err,
0215                          "couldn't register LED %s\n",
0216                          led->ldev.name);
0217         }
0218     }
0219     return 0;
0220 }
0221
0222 static const struct i2c_device_id tlc591xx_id[] = {
0223     { "tlc59116" },
0224     { "tlc59108" },
0225     {},
0226 };
0227 MODULE_DEVICE_TABLE(i2c, tlc591xx_id);
0228
0229 static struct i2c_driver tlc591xx_driver = {
0230     .driver = {
0231         .name = "tlc591xx",
0232         .of_match_table = of_match_ptr(of_tlc591xx_leds_match),
0233     },
0234     .probe = tlc591xx_probe,
0235     .id_table = tlc591xx_id,
0236 };
0237
0238 module_i2c_driver(tlc591xx_driver);
0239
0240 MODULE_AUTHOR("Andrew Lunn <andrew@lunn.ch>");
0241 MODULE_LICENSE("GPL");
0242 MODULE_DESCRIPTION("TLC591XX LED driver");