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

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

drivers/leds/Kconfig

+14 −0
Original line number Diff line number Diff line
@@ -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

drivers/leds/Makefile

+1 −0
Original line number Diff line number Diff line
@@ -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

drivers/leds/leds-bd2606mvv.c

0 → 100644
+160 −0
Original line number Diff line number Diff line 
// 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");