#include <linux/delay.h>
#include <linux/i2c.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/led-class-multicolor.h>
#include <linux/leds.h>
#include <linux/module.h>
#include <linux/mutex.h>
#include <linux/sysfs.h>
#include <linux/types.h>
#include "leds-lp5812.h"
static const struct lp5812_mode_mapping chip_mode_map[] = {
{"direct_mode", 0, 0, 0, 0, 0, 0},
{"tcm:1:0", 1, 0, 0, 0, 0, 0},
{"tcm:1:1", 1, 1, 0, 0, 0, 0},
{"tcm:1:2", 1, 2, 0, 0, 0, 0},
{"tcm:1:3", 1, 3, 0, 0, 0, 0},
{"tcm:2:0:1", 2, 0, 1, 0, 0, 0},
{"tcm:2:0:2", 2, 0, 2, 0, 0, 0},
{"tcm:2:0:3", 2, 0, 3, 0, 0, 0},
{"tcm:2:1:2", 2, 1, 2, 0, 0, 0},
{"tcm:2:1:3", 2, 1, 3, 0, 0, 0},
{"tcm:2:2:3", 2, 2, 3, 0, 0, 0},
{"tcm:3:0:1:2", 3, 0, 1, 2, 0, 0},
{"tcm:3:0:1:3", 3, 0, 1, 3, 0, 0},
{"tcm:3:0:2:3", 3, 0, 2, 3, 0, 0},
{"tcm:4:0:1:2:3", 4, 0, 1, 2, 3, 0},
{"mix:1:0:1", 5, 1, 0, 0, 0, 0},
{"mix:1:0:2", 5, 2, 0, 0, 0, 0},
{"mix:1:0:3", 5, 3, 0, 0, 0, 0},
{"mix:1:1:0", 5, 0, 0, 0, 0, 1},
{"mix:1:1:2", 5, 2, 0, 0, 0, 1},
{"mix:1:1:3", 5, 3, 0, 0, 0, 1},
{"mix:1:2:0", 5, 0, 0, 0, 0, 2},
{"mix:1:2:1", 5, 1, 0, 0, 0, 2},
{"mix:1:2:3", 5, 3, 0, 0, 0, 2},
{"mix:1:3:0", 5, 0, 0, 0, 0, 3},
{"mix:1:3:1", 5, 1, 0, 0, 0, 3},
{"mix:1:3:2", 5, 2, 0, 0, 0, 3},
{"mix:2:0:1:2", 6, 1, 2, 0, 0, 0},
{"mix:2:0:1:3", 6, 1, 3, 0, 0, 0},
{"mix:2:0:2:3", 6, 2, 3, 0, 0, 0},
{"mix:2:1:0:2", 6, 0, 2, 0, 0, 1},
{"mix:2:1:0:3", 6, 0, 3, 0, 0, 1},
{"mix:2:1:2:3", 6, 2, 3, 0, 0, 1},
{"mix:2:2:0:1", 6, 0, 1, 0, 0, 2},
{"mix:2:2:0:3", 6, 0, 3, 0, 0, 2},
{"mix:2:2:1:3", 6, 1, 3, 0, 0, 2},
{"mix:2:3:0:1", 6, 0, 1, 0, 0, 3},
{"mix:2:3:0:2", 6, 0, 2, 0, 0, 3},
{"mix:2:3:1:2", 6, 1, 2, 0, 0, 3},
{"mix:3:0:1:2:3", 7, 1, 2, 3, 0, 0},
{"mix:3:1:0:2:3", 7, 0, 2, 3, 0, 1},
{"mix:3:2:0:1:3", 7, 0, 1, 3, 0, 2},
{"mix:3:3:0:1:2", 7, 0, 1, 2, 0, 3}
};
static int lp5812_write(struct lp5812_chip *chip, u16 reg, u8 val)
{
struct device *dev = &chip->client->dev;
struct i2c_msg msg;
u8 buf[LP5812_DATA_LENGTH];
u8 reg_addr_bit8_9;
int ret;
reg_addr_bit8_9 = (reg >> LP5812_REG_ADDR_HIGH_SHIFT) & LP5812_REG_ADDR_BIT_8_9_MASK;
buf[LP5812_DATA_BYTE_0_IDX] = (u8)(reg & LP5812_REG_ADDR_LOW_MASK);
buf[LP5812_DATA_BYTE_1_IDX] = val;
msg.addr = (chip->client->addr << LP5812_CHIP_ADDR_SHIFT) | reg_addr_bit8_9;
msg.flags = 0;
msg.len = sizeof(buf);
msg.buf = buf;
ret = i2c_transfer(chip->client->adapter, &msg, 1);
if (ret == 1)
return 0;
dev_err(dev, "I2C write error, ret=%d\n", ret);
return ret < 0 ? ret : -EIO;
}
static int lp5812_read(struct lp5812_chip *chip, u16 reg, u8 *val)
{
struct device *dev = &chip->client->dev;
struct i2c_msg msgs[LP5812_READ_MSG_LENGTH];
u8 ret_val;
u8 reg_addr_bit8_9;
u8 converted_reg;
int ret;
reg_addr_bit8_9 = (reg >> LP5812_REG_ADDR_HIGH_SHIFT) & LP5812_REG_ADDR_BIT_8_9_MASK;
converted_reg = (u8)(reg & LP5812_REG_ADDR_LOW_MASK);
msgs[LP5812_MSG_0_IDX].addr =
(chip->client->addr << LP5812_CHIP_ADDR_SHIFT) | reg_addr_bit8_9;
msgs[LP5812_MSG_0_IDX].flags = 0;
msgs[LP5812_MSG_0_IDX].len = 1;
msgs[LP5812_MSG_0_IDX].buf = &converted_reg;
msgs[LP5812_MSG_1_IDX].addr =
(chip->client->addr << LP5812_CHIP_ADDR_SHIFT) | reg_addr_bit8_9;
msgs[LP5812_MSG_1_IDX].flags = I2C_M_RD;
msgs[LP5812_MSG_1_IDX].len = 1;
msgs[LP5812_MSG_1_IDX].buf = &ret_val;
ret = i2c_transfer(chip->client->adapter, msgs, LP5812_READ_MSG_LENGTH);
if (ret == LP5812_READ_MSG_LENGTH) {
*val = ret_val;
return 0;
}
dev_err(dev, "I2C read error, ret=%d\n", ret);
*val = 0;
return ret < 0 ? ret : -EIO;
}
static int lp5812_read_tsd_config_status(struct lp5812_chip *chip, u8 *reg_val)
{
return lp5812_read(chip, LP5812_TSD_CONFIG_STATUS, reg_val);
}
static int lp5812_update_regs_config(struct lp5812_chip *chip)
{
u8 reg_val;
int ret;
ret = lp5812_write(chip, LP5812_CMD_UPDATE, LP5812_UPDATE_CMD_VAL);
if (ret)
return ret;
ret = lp5812_read_tsd_config_status(chip, ®_val);
if (ret)
return ret;
return reg_val & LP5812_CFG_ERR_STATUS_MASK;
}
static ssize_t parse_drive_mode(struct lp5812_chip *chip, const char *str)
{
int i;
chip->drive_mode.bits.mix_sel_led_0 = false;
chip->drive_mode.bits.mix_sel_led_1 = false;
chip->drive_mode.bits.mix_sel_led_2 = false;
chip->drive_mode.bits.mix_sel_led_3 = false;
if (sysfs_streq(str, LP5812_MODE_DIRECT_NAME)) {
chip->drive_mode.bits.led_mode = LP5812_MODE_DIRECT_VALUE;
return 0;
}
for (i = 0; i < ARRAY_SIZE(chip_mode_map); i++) {
if (!sysfs_streq(str, chip_mode_map[i].mode_name))
continue;
chip->drive_mode.bits.led_mode = chip_mode_map[i].mode;
chip->scan_order.bits.order0 = chip_mode_map[i].scan_order_0;
chip->scan_order.bits.order1 = chip_mode_map[i].scan_order_1;
chip->scan_order.bits.order2 = chip_mode_map[i].scan_order_2;
chip->scan_order.bits.order3 = chip_mode_map[i].scan_order_3;
switch (chip_mode_map[i].selection_led) {
case LP5812_MODE_MIX_SELECT_LED_0:
chip->drive_mode.bits.mix_sel_led_0 = true;
break;
case LP5812_MODE_MIX_SELECT_LED_1:
chip->drive_mode.bits.mix_sel_led_1 = true;
break;
case LP5812_MODE_MIX_SELECT_LED_2:
chip->drive_mode.bits.mix_sel_led_2 = true;
break;
case LP5812_MODE_MIX_SELECT_LED_3:
chip->drive_mode.bits.mix_sel_led_3 = true;
break;
default:
return -EINVAL;
}
return 0;
}
return -EINVAL;
}
static int lp5812_set_drive_mode_scan_order(struct lp5812_chip *chip)
{
u8 val;
int ret;
val = chip->drive_mode.val;
ret = lp5812_write(chip, LP5812_DEV_CONFIG1, val);
if (ret)
return ret;
val = chip->scan_order.val;
ret = lp5812_write(chip, LP5812_DEV_CONFIG2, val);
return ret;
}
static int lp5812_set_led_mode(struct lp5812_chip *chip, int led_number,
enum control_mode mode)
{
u8 reg_val;
u16 reg;
int ret;
if (led_number < LP5812_NUMBER_LED_IN_REG)
reg = LP5812_DEV_CONFIG3;
else
reg = LP5812_DEV_CONFIG4;
ret = lp5812_read(chip, reg, ®_val);
if (ret)
return ret;
if (mode == LP5812_MODE_MANUAL)
reg_val &= ~(LP5812_ENABLE << (led_number % LP5812_NUMBER_LED_IN_REG));
else
reg_val |= (LP5812_ENABLE << (led_number % LP5812_NUMBER_LED_IN_REG));
ret = lp5812_write(chip, reg, reg_val);
if (ret)
return ret;
ret = lp5812_update_regs_config(chip);
return ret;
}
static int lp5812_manual_dc_pwm_control(struct lp5812_chip *chip, int led_number,
u8 val, enum dimming_type dimming_type)
{
u16 led_base_reg;
int ret;
if (dimming_type == LP5812_DIMMING_ANALOG)
led_base_reg = LP5812_MANUAL_DC_BASE;
else
led_base_reg = LP5812_MANUAL_PWM_BASE;
ret = lp5812_write(chip, led_base_reg + led_number, val);
return ret;
}
static int lp5812_multicolor_brightness(struct lp5812_led *led)
{
struct lp5812_chip *chip = led->chip;
int ret, i;
guard(mutex)(&chip->lock);
for (i = 0; i < led->mc_cdev.num_colors; i++) {
ret = lp5812_manual_dc_pwm_control(chip, led->mc_cdev.subled_info[i].channel,
led->mc_cdev.subled_info[i].brightness,
LP5812_DIMMING_PWM);
if (ret)
return ret;
}
return 0;
}
static int lp5812_led_brightness(struct lp5812_led *led)
{
struct lp5812_chip *chip = led->chip;
struct lp5812_led_config *led_cfg;
int ret;
led_cfg = &chip->led_config[led->chan_nr];
guard(mutex)(&chip->lock);
ret = lp5812_manual_dc_pwm_control(chip, led_cfg->led_id[0],
led->brightness, LP5812_DIMMING_PWM);
return ret;
}
static int lp5812_set_brightness(struct led_classdev *cdev,
enum led_brightness brightness)
{
struct lp5812_led *led = container_of(cdev, struct lp5812_led, cdev);
led->brightness = (u8)brightness;
return lp5812_led_brightness(led);
}
static int lp5812_set_mc_brightness(struct led_classdev *cdev,
enum led_brightness brightness)
{
struct led_classdev_mc *mc_dev = lcdev_to_mccdev(cdev);
struct lp5812_led *led = container_of(mc_dev, struct lp5812_led, mc_cdev);
led_mc_calc_color_components(&led->mc_cdev, brightness);
return lp5812_multicolor_brightness(led);
}
static int lp5812_init_led(struct lp5812_led *led, struct lp5812_chip *chip, int chan)
{
struct device *dev = &chip->client->dev;
struct mc_subled *mc_led_info;
struct led_classdev *led_cdev;
int i, ret;
if (chip->led_config[chan].name) {
led->cdev.name = chip->led_config[chan].name;
} else {
led->cdev.name = devm_kasprintf(dev, GFP_KERNEL, "%s:channel%d",
chip->label ? : chip->client->name, chan);
if (!led->cdev.name)
return -ENOMEM;
}
if (!chip->led_config[chan].is_sc_led) {
mc_led_info = devm_kcalloc(dev, chip->led_config[chan].num_colors,
sizeof(*mc_led_info), GFP_KERNEL);
if (!mc_led_info)
return -ENOMEM;
led_cdev = &led->mc_cdev.led_cdev;
led_cdev->name = led->cdev.name;
led_cdev->brightness_set_blocking = lp5812_set_mc_brightness;
led->mc_cdev.num_colors = chip->led_config[chan].num_colors;
for (i = 0; i < led->mc_cdev.num_colors; i++) {
mc_led_info[i].color_index = chip->led_config[chan].color_id[i];
mc_led_info[i].channel = chip->led_config[chan].led_id[i];
}
led->mc_cdev.subled_info = mc_led_info;
} else {
led->cdev.brightness_set_blocking = lp5812_set_brightness;
}
led->chan_nr = chan;
if (chip->led_config[chan].is_sc_led) {
ret = devm_led_classdev_register(dev, &led->cdev);
if (ret == 0)
led->cdev.dev->platform_data = led;
} else {
ret = devm_led_classdev_multicolor_register(dev, &led->mc_cdev);
if (ret == 0)
led->mc_cdev.led_cdev.dev->platform_data = led;
}
return ret;
}
static int lp5812_register_leds(struct lp5812_led *leds, struct lp5812_chip *chip)
{
struct lp5812_led *led;
int num_channels = chip->num_channels;
u8 reg_val;
u16 reg;
int ret, i, j;
for (i = 0; i < num_channels; i++) {
led = &leds[i];
ret = lp5812_init_led(led, chip, i);
if (ret)
goto err_init_led;
led->chip = chip;
for (j = 0; j < chip->led_config[i].num_colors; j++) {
ret = lp5812_write(chip,
LP5812_AUTO_DC_BASE + chip->led_config[i].led_id[j],
chip->led_config[i].max_current[j]);
if (ret)
goto err_init_led;
ret = lp5812_manual_dc_pwm_control(chip, chip->led_config[i].led_id[j],
chip->led_config[i].max_current[j],
LP5812_DIMMING_ANALOG);
if (ret)
goto err_init_led;
ret = lp5812_set_led_mode(chip, chip->led_config[i].led_id[j],
LP5812_MODE_MANUAL);
if (ret)
goto err_init_led;
reg = (chip->led_config[i].led_id[j] < LP5812_NUMBER_LED_IN_REG) ?
LP5812_LED_EN_1 : LP5812_LED_EN_2;
ret = lp5812_read(chip, reg, ®_val);
if (ret)
goto err_init_led;
reg_val |= (LP5812_ENABLE << (chip->led_config[i].led_id[j] %
LP5812_NUMBER_LED_IN_REG));
ret = lp5812_write(chip, reg, reg_val);
if (ret)
goto err_init_led;
}
}
return 0;
err_init_led:
return ret;
}
static int lp5812_init_device(struct lp5812_chip *chip)
{
int ret;
usleep_range(LP5812_WAIT_DEVICE_STABLE_MIN, LP5812_WAIT_DEVICE_STABLE_MAX);
ret = lp5812_write(chip, LP5812_REG_ENABLE, LP5812_ENABLE);
if (ret) {
dev_err(&chip->client->dev, "failed to enable LP5812 device\n");
return ret;
}
ret = lp5812_write(chip, LP5812_DEV_CONFIG12, LP5812_LSD_LOD_START_UP);
if (ret) {
dev_err(&chip->client->dev, "failed to configure device safety thresholds\n");
return ret;
}
ret = parse_drive_mode(chip, chip->scan_mode);
if (ret)
return ret;
ret = lp5812_set_drive_mode_scan_order(chip);
if (ret)
return ret;
ret = lp5812_update_regs_config(chip);
if (ret) {
dev_err(&chip->client->dev, "failed to apply configuration updates\n");
return ret;
}
return 0;
}
static void lp5812_deinit_device(struct lp5812_chip *chip)
{
lp5812_write(chip, LP5812_LED_EN_1, LP5812_DISABLE);
lp5812_write(chip, LP5812_LED_EN_2, LP5812_DISABLE);
lp5812_write(chip, LP5812_REG_ENABLE, LP5812_DISABLE);
}
static int lp5812_parse_led_channel(struct device_node *np,
struct lp5812_led_config *cfg,
int color_number)
{
int color_id, reg, ret;
u32 max_cur;
ret = of_property_read_u32(np, "reg", ®);
if (ret)
return ret;
cfg->led_id[color_number] = reg;
ret = of_property_read_u32(np, "led-max-microamp", &max_cur);
if (ret)
max_cur = 0;
cfg->max_current[color_number] = max_cur / 100;
ret = of_property_read_u32(np, "color", &color_id);
if (ret)
color_id = 0;
cfg->color_id[color_number] = color_id;
return 0;
}
static int lp5812_parse_led(struct device_node *np,
struct lp5812_led_config *cfg,
int led_index)
{
int num_colors, ret;
of_property_read_string(np, "label", &cfg[led_index].name);
ret = of_property_read_u32(np, "reg", &cfg[led_index].chan_nr);
if (ret)
return ret;
num_colors = 0;
for_each_available_child_of_node_scoped(np, child) {
ret = lp5812_parse_led_channel(child, &cfg[led_index], num_colors);
if (ret)
return ret;
num_colors++;
}
if (num_colors == 0) {
ret = lp5812_parse_led_channel(np, &cfg[led_index], 0);
if (ret)
return ret;
num_colors = 1;
cfg[led_index].is_sc_led = true;
} else {
cfg[led_index].is_sc_led = false;
}
cfg[led_index].num_colors = num_colors;
return 0;
}
static int lp5812_of_probe(struct device *dev,
struct device_node *np,
struct lp5812_chip *chip)
{
struct lp5812_led_config *cfg;
int num_channels, i = 0, ret;
num_channels = of_get_available_child_count(np);
if (num_channels == 0) {
dev_err(dev, "no LED channels\n");
return -EINVAL;
}
cfg = devm_kcalloc(dev, num_channels, sizeof(*cfg), GFP_KERNEL);
if (!cfg)
return -ENOMEM;
chip->led_config = &cfg[0];
chip->num_channels = num_channels;
for_each_available_child_of_node_scoped(np, child) {
ret = lp5812_parse_led(child, cfg, i);
if (ret)
return -EINVAL;
i++;
}
ret = of_property_read_string(np, "ti,scan-mode", &chip->scan_mode);
if (ret)
chip->scan_mode = LP5812_MODE_DIRECT_NAME;
of_property_read_string(np, "label", &chip->label);
return 0;
}
static int lp5812_probe(struct i2c_client *client)
{
struct lp5812_chip *chip;
struct device_node *np = dev_of_node(&client->dev);
struct lp5812_led *leds;
int ret;
if (!np)
return -EINVAL;
chip = devm_kzalloc(&client->dev, sizeof(*chip), GFP_KERNEL);
if (!chip)
return -ENOMEM;
ret = lp5812_of_probe(&client->dev, np, chip);
if (ret)
return ret;
leds = devm_kcalloc(&client->dev, chip->num_channels, sizeof(*leds), GFP_KERNEL);
if (!leds)
return -ENOMEM;
chip->client = client;
mutex_init(&chip->lock);
i2c_set_clientdata(client, chip);
ret = lp5812_init_device(chip);
if (ret)
return ret;
ret = lp5812_register_leds(leds, chip);
if (ret)
goto err_out;
return 0;
err_out:
lp5812_deinit_device(chip);
return ret;
}
static void lp5812_remove(struct i2c_client *client)
{
struct lp5812_chip *chip = i2c_get_clientdata(client);
lp5812_deinit_device(chip);
}
static const struct of_device_id of_lp5812_match[] = {
{ .compatible = "ti,lp5812" },
{ }
};
MODULE_DEVICE_TABLE(of, of_lp5812_match);
static struct i2c_driver lp5812_driver = {
.driver = {
.name = "lp5812",
.of_match_table = of_lp5812_match,
},
.probe = lp5812_probe,
.remove = lp5812_remove,
};
module_i2c_driver(lp5812_driver);
MODULE_DESCRIPTION("Texas Instruments LP5812 LED Driver");
MODULE_AUTHOR("Jared Zhou <jared-zhou@ti.com>");
MODULE_LICENSE("GPL");
