Commit 8325642d authored by Andreas Kemnade's avatar Andreas Kemnade Committed by Lee Jones

leds: bd2606mvv: Driver for the Rohm 6 Channel i2c LED driver

The device provides 6 channels which can be individually
turned off and on but groups of two channels share a common brightness
register.

Limitation: The GPIO to enable the device is not used yet.
Signed-off-by: default avatarAndreas Kemnade <andreas@kemnade.info>
Reviewed-by: default avatarMatti Vaittinen <mazziesaccount@gmail.com>
Acked-by: default avatarPavel Machek <pavel@ucw.cz>
Signed-off-by: default avatarLee Jones <lee@kernel.org>
Link: https://lore.kernel.org/r/20230419111806.1100437-3-andreas@kemnade.info
parent 36cd9fb5
......@@ -551,6 +551,20 @@ config LEDS_REGULATOR
help
This option enables support for regulator driven LEDs.
config LEDS_BD2606MVV
tristate "LED driver for BD2606MVV"
depends on LEDS_CLASS
depends on I2C
select REGMAP_I2C
help
This option enables support for BD2606MVV LED driver chips
accessed via the I2C bus. It supports setting brightness, with
the limitiation that there are groups of two channels sharing
a brightness setting, but not the on/off setting.
To compile this driver as a module, choose M here: the module will
be called leds-bd2606mvv.
config LEDS_BD2802
tristate "LED driver for BD2802 RGB LED"
depends on LEDS_CLASS
......
......@@ -17,6 +17,7 @@ obj-$(CONFIG_LEDS_ARIEL) += leds-ariel.o
obj-$(CONFIG_LEDS_AW2013) += leds-aw2013.o
obj-$(CONFIG_LEDS_BCM6328) += leds-bcm6328.o
obj-$(CONFIG_LEDS_BCM6358) += leds-bcm6358.o
obj-$(CONFIG_LEDS_BD2606MVV) += leds-bd2606mvv.o
obj-$(CONFIG_LEDS_BD2802) += leds-bd2802.o
obj-$(CONFIG_LEDS_BLINKM) += leds-blinkm.o
obj-$(CONFIG_LEDS_CLEVO_MAIL) += leds-clevo-mail.o
......
// SPDX-License-Identifier: GPL-2.0-only
/*
* Copyright (C) 2023 Andreas Kemnade
*
* Datasheet:
* https://fscdn.rohm.com/en/products/databook/datasheet/ic/power/led_driver/bd2606mvv_1-e.pdf
*
* If LED brightness cannot be controlled independently due to shared
* brightness registers, max_brightness is set to 1 and only on/off
* is possible for the affected LED pair.
*/
#include <linux/i2c.h>
#include <linux/leds.h>
#include <linux/module.h>
#include <linux/mod_devicetable.h>
#include <linux/property.h>
#include <linux/regmap.h>
#include <linux/slab.h>
#define BD2606_MAX_LEDS 6
#define BD2606_MAX_BRIGHTNESS 63
#define BD2606_REG_PWRCNT 3
#define ldev_to_led(c) container_of(c, struct bd2606mvv_led, ldev)
struct bd2606mvv_led {
unsigned int led_no;
struct led_classdev ldev;
struct bd2606mvv_priv *priv;
};
struct bd2606mvv_priv {
struct bd2606mvv_led leds[BD2606_MAX_LEDS];
struct regmap *regmap;
};
static int
bd2606mvv_brightness_set(struct led_classdev *led_cdev,
enum led_brightness brightness)
{
struct bd2606mvv_led *led = ldev_to_led(led_cdev);
struct bd2606mvv_priv *priv = led->priv;
int err;
if (brightness == 0)
return regmap_update_bits(priv->regmap,
BD2606_REG_PWRCNT,
1 << led->led_no,
0);
/* shared brightness register */
err = regmap_write(priv->regmap, led->led_no / 2,
led_cdev->max_brightness == 1 ?
BD2606_MAX_BRIGHTNESS : brightness);
if (err)
return err;
return regmap_update_bits(priv->regmap,
BD2606_REG_PWRCNT,
1 << led->led_no,
1 << led->led_no);
}
static const struct regmap_config bd2606mvv_regmap = {
.reg_bits = 8,
.val_bits = 8,
.max_register = 0x3,
};
static int bd2606mvv_probe(struct i2c_client *client)
{
struct fwnode_handle *np, *child;
struct device *dev = &client->dev;
struct bd2606mvv_priv *priv;
struct fwnode_handle *led_fwnodes[BD2606_MAX_LEDS] = { 0 };
int active_pairs[BD2606_MAX_LEDS / 2] = { 0 };
int err, reg;
int i;
np = dev_fwnode(dev);
if (!np)
return -ENODEV;
priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
if (!priv)
return -ENOMEM;
priv->regmap = devm_regmap_init_i2c(client, &bd2606mvv_regmap);
if (IS_ERR(priv->regmap)) {
err = PTR_ERR(priv->regmap);
dev_err(dev, "Failed to allocate register map: %d\n", err);
return err;
}
i2c_set_clientdata(client, priv);
fwnode_for_each_available_child_node(np, child) {
struct bd2606mvv_led *led;
err = fwnode_property_read_u32(child, "reg", &reg);
if (err) {
fwnode_handle_put(child);
return err;
}
if (reg < 0 || reg >= BD2606_MAX_LEDS || led_fwnodes[reg]) {
fwnode_handle_put(child);
return -EINVAL;
}
led = &priv->leds[reg];
led_fwnodes[reg] = child;
active_pairs[reg / 2]++;
led->priv = priv;
led->led_no = reg;
led->ldev.brightness_set_blocking = bd2606mvv_brightness_set;
led->ldev.max_brightness = BD2606_MAX_BRIGHTNESS;
}
for (i = 0; i < BD2606_MAX_LEDS; i++) {
struct led_init_data init_data = {};
if (!led_fwnodes[i])
continue;
init_data.fwnode = led_fwnodes[i];
/* Check whether brightness can be independently adjusted. */
if (active_pairs[i / 2] == 2)
priv->leds[i].ldev.max_brightness = 1;
err = devm_led_classdev_register_ext(dev,
&priv->leds[i].ldev,
&init_data);
if (err < 0) {
fwnode_handle_put(child);
return dev_err_probe(dev, err,
"couldn't register LED %s\n",
priv->leds[i].ldev.name);
}
}
return 0;
}
static const struct of_device_id __maybe_unused of_bd2606mvv_leds_match[] = {
{ .compatible = "rohm,bd2606mvv", },
{},
};
MODULE_DEVICE_TABLE(of, of_bd2606mvv_leds_match);
static struct i2c_driver bd2606mvv_driver = {
.driver = {
.name = "leds-bd2606mvv",
.of_match_table = of_match_ptr(of_bd2606mvv_leds_match),
},
.probe_new = bd2606mvv_probe,
};
module_i2c_driver(bd2606mvv_driver);
MODULE_AUTHOR("Andreas Kemnade <andreas@kemnade.info>");
MODULE_DESCRIPTION("BD2606 LED driver");
MODULE_LICENSE("GPL");
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment