drivers/leds/leds-aw2013.c

0001 // SPDX-License-Identifier: GPL-2.0+
0002 // Driver for Awinic AW2013 3-channel LED driver
0003
0004 #include <linux/i2c.h>
0005 #include <linux/leds.h>
0006 #include <linux/module.h>
0007 #include <linux/regulator/consumer.h>
0008 #include <linux/mutex.h>
0009 #include <linux/of.h>
0010 #include <linux/regmap.h>
0011
0012 #define AW2013_MAX_LEDS 3
0013
0014 /* Reset and ID register */
0015 #define AW2013_RSTR 0x00
0016 #define AW2013_RSTR_RESET 0x55
0017 #define AW2013_RSTR_CHIP_ID 0x33
0018
0019 /* Global control register */
0020 #define AW2013_GCR 0x01
0021 #define AW2013_GCR_ENABLE BIT(0)
0022
0023 /* LED channel enable register */
0024 #define AW2013_LCTR 0x30
0025 #define AW2013_LCTR_LE(x) BIT((x))
0026
0027 /* LED channel control registers */
0028 #define AW2013_LCFG(x) (0x31 + (x))
0029 #define AW2013_LCFG_IMAX_MASK (BIT(0) | BIT(1)) // Should be 0-3
0030 #define AW2013_LCFG_MD BIT(4)
0031 #define AW2013_LCFG_FI BIT(5)
0032 #define AW2013_LCFG_FO BIT(6)
0033
0034 /* LED channel PWM registers */
0035 #define AW2013_REG_PWM(x) (0x34 + (x))
0036
0037 /* LED channel timing registers */
0038 #define AW2013_LEDT0(x) (0x37 + (x) * 3)
0039 #define AW2013_LEDT0_T1(x) ((x) << 4) // Should be 0-7
0040 #define AW2013_LEDT0_T2(x) (x) // Should be 0-5
0041
0042 #define AW2013_LEDT1(x) (0x38 + (x) * 3)
0043 #define AW2013_LEDT1_T3(x) ((x) << 4) // Should be 0-7
0044 #define AW2013_LEDT1_T4(x) (x) // Should be 0-7
0045
0046 #define AW2013_LEDT2(x) (0x39 + (x) * 3)
0047 #define AW2013_LEDT2_T0(x) ((x) << 4) // Should be 0-8
0048 #define AW2013_LEDT2_REPEAT(x) (x) // Should be 0-15
0049
0050 #define AW2013_REG_MAX 0x77
0051
0052 #define AW2013_TIME_STEP 130 /* ms */
0053
0054 struct aw2013;
0055
0056 struct aw2013_led {
0057     struct aw2013 *chip;
0058     struct led_classdev cdev;
0059     u32 num;
0060     unsigned int imax;
0061 };
0062
0063 struct aw2013 {
0064     struct mutex mutex; /* held when writing to registers */
0065     struct regulator *vcc_regulator;
0066     struct i2c_client *client;
0067     struct aw2013_led leds[AW2013_MAX_LEDS];
0068     struct regmap *regmap;
0069     int num_leds;
0070     bool enabled;
0071 };
0072
0073 static int aw2013_chip_init(struct aw2013 *chip)
0074 {
0075     int i, ret;
0076
0077     ret = regmap_write(chip->regmap, AW2013_GCR, AW2013_GCR_ENABLE);
0078     if (ret) {
0079         dev_err(&chip->client->dev, "Failed to enable the chip: %d\n",
0080             ret);
0081         return ret;
0082     }
0083
0084     for (i = 0; i < chip->num_leds; i++) {
0085         ret = regmap_update_bits(chip->regmap,
0086                      AW2013_LCFG(chip->leds[i].num),
0087                      AW2013_LCFG_IMAX_MASK,
0088                      chip->leds[i].imax);
0089         if (ret) {
0090             dev_err(&chip->client->dev,
0091                 "Failed to set maximum current for led %d: %d\n",
0092                 chip->leds[i].num, ret);
0093             return ret;
0094         }
0095     }
0096
0097     return ret;
0098 }
0099
0100 static void aw2013_chip_disable(struct aw2013 *chip)
0101 {
0102     int ret;
0103
0104     if (!chip->enabled)
0105         return;
0106
0107     regmap_write(chip->regmap, AW2013_GCR, 0);
0108
0109     ret = regulator_disable(chip->vcc_regulator);
0110     if (ret) {
0111         dev_err(&chip->client->dev,
0112             "Failed to disable regulator: %d\n", ret);
0113         return;
0114     }
0115
0116     chip->enabled = false;
0117 }
0118
0119 static int aw2013_chip_enable(struct aw2013 *chip)
0120 {
0121     int ret;
0122
0123     if (chip->enabled)
0124         return 0;
0125
0126     ret = regulator_enable(chip->vcc_regulator);
0127     if (ret) {
0128         dev_err(&chip->client->dev,
0129             "Failed to enable regulator: %d\n", ret);
0130         return ret;
0131     }
0132     chip->enabled = true;
0133
0134     ret = aw2013_chip_init(chip);
0135     if (ret)
0136         aw2013_chip_disable(chip);
0137
0138     return ret;
0139 }
0140
0141 static bool aw2013_chip_in_use(struct aw2013 *chip)
0142 {
0143     int i;
0144
0145     for (i = 0; i < chip->num_leds; i++)
0146         if (chip->leds[i].cdev.brightness)
0147             return true;
0148
0149     return false;
0150 }
0151
0152 static int aw2013_brightness_set(struct led_classdev *cdev,
0153                  enum led_brightness brightness)
0154 {
0155     struct aw2013_led *led = container_of(cdev, struct aw2013_led, cdev);
0156     int ret, num;
0157
0158     mutex_lock(&led->chip->mutex);
0159
0160     if (aw2013_chip_in_use(led->chip)) {
0161         ret = aw2013_chip_enable(led->chip);
0162         if (ret)
0163             goto error;
0164     }
0165
0166     num = led->num;
0167
0168     ret = regmap_write(led->chip->regmap, AW2013_REG_PWM(num), brightness);
0169     if (ret)
0170         goto error;
0171
0172     if (brightness) {
0173         ret = regmap_update_bits(led->chip->regmap, AW2013_LCTR,
0174                      AW2013_LCTR_LE(num), 0xFF);
0175     } else {
0176         ret = regmap_update_bits(led->chip->regmap, AW2013_LCTR,
0177                      AW2013_LCTR_LE(num), 0);
0178         if (ret)
0179             goto error;
0180         ret = regmap_update_bits(led->chip->regmap, AW2013_LCFG(num),
0181                      AW2013_LCFG_MD, 0);
0182     }
0183     if (ret)
0184         goto error;
0185
0186     if (!aw2013_chip_in_use(led->chip))
0187         aw2013_chip_disable(led->chip);
0188
0189 error:
0190     mutex_unlock(&led->chip->mutex);
0191
0192     return ret;
0193 }
0194
0195 static int aw2013_blink_set(struct led_classdev *cdev,
0196                 unsigned long *delay_on, unsigned long *delay_off)
0197 {
0198     struct aw2013_led *led = container_of(cdev, struct aw2013_led, cdev);
0199     int ret, num = led->num;
0200     unsigned long off = 0, on = 0;
0201
0202     /* If no blink specified, default to 1 Hz. */
0203     if (!*delay_off && !*delay_on) {
0204         *delay_off = 500;
0205         *delay_on = 500;
0206     }
0207
0208     if (!led->cdev.brightness) {
0209         led->cdev.brightness = LED_FULL;
0210         ret = aw2013_brightness_set(&led->cdev, led->cdev.brightness);
0211         if (ret)
0212             return ret;
0213     }
0214
0215     /* Never on - just set to off */
0216     if (!*delay_on) {
0217         led->cdev.brightness = LED_OFF;
0218         return aw2013_brightness_set(&led->cdev, LED_OFF);
0219     }
0220
0221     mutex_lock(&led->chip->mutex);
0222
0223     /* Never off - brightness is already set, disable blinking */
0224     if (!*delay_off) {
0225         ret = regmap_update_bits(led->chip->regmap, AW2013_LCFG(num),
0226                      AW2013_LCFG_MD, 0);
0227         goto out;
0228     }
0229
0230     /* Convert into values the HW will understand. */
0231     off = min(5, ilog2((*delay_off - 1) / AW2013_TIME_STEP) + 1);
0232     on = min(7, ilog2((*delay_on - 1) / AW2013_TIME_STEP) + 1);
0233
0234     *delay_off = BIT(off) * AW2013_TIME_STEP;
0235     *delay_on = BIT(on) * AW2013_TIME_STEP;
0236
0237     /* Set timings */
0238     ret = regmap_write(led->chip->regmap,
0239                AW2013_LEDT0(num), AW2013_LEDT0_T2(on));
0240     if (ret)
0241         goto out;
0242     ret = regmap_write(led->chip->regmap,
0243                AW2013_LEDT1(num), AW2013_LEDT1_T4(off));
0244     if (ret)
0245         goto out;
0246
0247     /* Finally, enable the LED */
0248     ret = regmap_update_bits(led->chip->regmap, AW2013_LCFG(num),
0249                  AW2013_LCFG_MD, 0xFF);
0250     if (ret)
0251         goto out;
0252
0253     ret = regmap_update_bits(led->chip->regmap, AW2013_LCTR,
0254                  AW2013_LCTR_LE(num), 0xFF);
0255
0256 out:
0257     mutex_unlock(&led->chip->mutex);
0258
0259     return ret;
0260 }
0261
0262 static int aw2013_probe_dt(struct aw2013 *chip)
0263 {
0264     struct device_node *np = dev_of_node(&chip->client->dev), *child;
0265     int count, ret = 0, i = 0;
0266     struct aw2013_led *led;
0267
0268     count = of_get_available_child_count(np);
0269     if (!count || count > AW2013_MAX_LEDS)
0270         return -EINVAL;
0271
0272     regmap_write(chip->regmap, AW2013_RSTR, AW2013_RSTR_RESET);
0273
0274     for_each_available_child_of_node(np, child) {
0275         struct led_init_data init_data = {};
0276         u32 source;
0277         u32 imax;
0278
0279         ret = of_property_read_u32(child, "reg", &source);
0280         if (ret != 0 || source >= AW2013_MAX_LEDS) {
0281             dev_err(&chip->client->dev,
0282                 "Couldn't read LED address: %d\n", ret);
0283             count--;
0284             continue;
0285         }
0286
0287         led = &chip->leds[i];
0288         led->num = source;
0289         led->chip = chip;
0290         init_data.fwnode = of_fwnode_handle(child);
0291
0292         if (!of_property_read_u32(child, "led-max-microamp", &imax)) {
0293             led->imax = min_t(u32, imax / 5000, 3);
0294         } else {
0295             led->imax = 1; // 5mA
0296             dev_info(&chip->client->dev,
0297                  "DT property led-max-microamp is missing\n");
0298         }
0299
0300         led->cdev.brightness_set_blocking = aw2013_brightness_set;
0301         led->cdev.blink_set = aw2013_blink_set;
0302
0303         ret = devm_led_classdev_register_ext(&chip->client->dev,
0304                              &led->cdev, &init_data);
0305         if (ret < 0) {
0306             of_node_put(child);
0307             return ret;
0308         }
0309
0310         i++;
0311     }
0312
0313     if (!count)
0314         return -EINVAL;
0315
0316     chip->num_leds = i;
0317
0318     return 0;
0319 }
0320
0321 static const struct regmap_config aw2013_regmap_config = {
0322     .reg_bits = 8,
0323     .val_bits = 8,
0324     .max_register = AW2013_REG_MAX,
0325 };
0326
0327 static int aw2013_probe(struct i2c_client *client)
0328 {
0329     struct aw2013 *chip;
0330     int ret;
0331     unsigned int chipid;
0332
0333     chip = devm_kzalloc(&client->dev, sizeof(*chip), GFP_KERNEL);
0334     if (!chip)
0335         return -ENOMEM;
0336
0337     mutex_init(&chip->mutex);
0338     mutex_lock(&chip->mutex);
0339
0340     chip->client = client;
0341     i2c_set_clientdata(client, chip);
0342
0343     chip->regmap = devm_regmap_init_i2c(client, &aw2013_regmap_config);
0344     if (IS_ERR(chip->regmap)) {
0345         ret = PTR_ERR(chip->regmap);
0346         dev_err(&client->dev, "Failed to allocate register map: %d\n",
0347             ret);
0348         goto error;
0349     }
0350
0351     chip->vcc_regulator = devm_regulator_get(&client->dev, "vcc");
0352     ret = PTR_ERR_OR_ZERO(chip->vcc_regulator);
0353     if (ret) {
0354         if (ret != -EPROBE_DEFER)
0355             dev_err(&client->dev,
0356                 "Failed to request regulator: %d\n", ret);
0357         goto error;
0358     }
0359
0360     ret = regulator_enable(chip->vcc_regulator);
0361     if (ret) {
0362         dev_err(&client->dev,
0363             "Failed to enable regulator: %d\n", ret);
0364         goto error;
0365     }
0366
0367     ret = regmap_read(chip->regmap, AW2013_RSTR, &chipid);
0368     if (ret) {
0369         dev_err(&client->dev, "Failed to read chip ID: %d\n",
0370             ret);
0371         goto error_reg;
0372     }
0373
0374     if (chipid != AW2013_RSTR_CHIP_ID) {
0375         dev_err(&client->dev, "Chip reported wrong ID: %x\n",
0376             chipid);
0377         ret = -ENODEV;
0378         goto error_reg;
0379     }
0380
0381     ret = aw2013_probe_dt(chip);
0382     if (ret < 0)
0383         goto error_reg;
0384
0385     ret = regulator_disable(chip->vcc_regulator);
0386     if (ret) {
0387         dev_err(&client->dev,
0388             "Failed to disable regulator: %d\n", ret);
0389         goto error;
0390     }
0391
0392     mutex_unlock(&chip->mutex);
0393
0394     return 0;
0395
0396 error_reg:
0397     regulator_disable(chip->vcc_regulator);
0398
0399 error:
0400     mutex_destroy(&chip->mutex);
0401     return ret;
0402 }
0403
0404 static int aw2013_remove(struct i2c_client *client)
0405 {
0406     struct aw2013 *chip = i2c_get_clientdata(client);
0407
0408     aw2013_chip_disable(chip);
0409
0410     mutex_destroy(&chip->mutex);
0411
0412     return 0;
0413 }
0414
0415 static const struct of_device_id aw2013_match_table[] = {
0416     { .compatible = "awinic,aw2013", },
0417     { /* sentinel */ },
0418 };
0419
0420 MODULE_DEVICE_TABLE(of, aw2013_match_table);
0421
0422 static struct i2c_driver aw2013_driver = {
0423     .driver = {
0424         .name = "leds-aw2013",
0425         .of_match_table = of_match_ptr(aw2013_match_table),
0426     },
0427     .probe_new = aw2013_probe,
0428     .remove = aw2013_remove,
0429 };
0430
0431 module_i2c_driver(aw2013_driver);
0432
0433 MODULE_AUTHOR("Nikita Travkin <nikitos.tr@gmail.com>");
0434 MODULE_DESCRIPTION("AW2013 LED driver");
0435 MODULE_LICENSE("GPL v2");