[linux.git] / drivers / leds / leds-bd2606mvv.c

// 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 = bd2606mvv_probe,
};

module_i2c_driver(bd2606mvv_driver);

MODULE_AUTHOR("Andreas Kemnade <[email protected]>");
MODULE_DESCRIPTION("BD2606 LED driver");
MODULE_LICENSE("GPL");
Commit	Line	Data
8325642d AK	1	// SPDX-License-Identifier: GPL-2.0-only
	2	/*
	3	* Copyright (C) 2023 Andreas Kemnade
	4	*
	5	* Datasheet:
	6	* https://fscdn.rohm.com/en/products/databook/datasheet/ic/power/led_driver/bd2606mvv_1-e.pdf
	7	*
	8	* If LED brightness cannot be controlled independently due to shared
	9	* brightness registers, max_brightness is set to 1 and only on/off
	10	* is possible for the affected LED pair.
	11	*/
	12
	13	#include <linux/i2c.h>
	14	#include <linux/leds.h>
	15	#include <linux/module.h>
	16	#include <linux/mod_devicetable.h>
	17	#include <linux/property.h>
	18	#include <linux/regmap.h>
	19	#include <linux/slab.h>
	20
	21	#define BD2606_MAX_LEDS 6
	22	#define BD2606_MAX_BRIGHTNESS 63
	23	#define BD2606_REG_PWRCNT 3
	24	#define ldev_to_led(c) container_of(c, struct bd2606mvv_led, ldev)
	25
	26	struct bd2606mvv_led {
	27	unsigned int led_no;
	28	struct led_classdev ldev;
	29	struct bd2606mvv_priv *priv;
	30	};
	31
	32	struct bd2606mvv_priv {
	33	struct bd2606mvv_led leds[BD2606_MAX_LEDS];
	34	struct regmap *regmap;
	35	};
	36
	37	static int
	38	bd2606mvv_brightness_set(struct led_classdev *led_cdev,
	39	enum led_brightness brightness)
	40	{
	41	struct bd2606mvv_led *led = ldev_to_led(led_cdev);
	42	struct bd2606mvv_priv *priv = led->priv;
	43	int err;
	44
	45	if (brightness == 0)
	46	return regmap_update_bits(priv->regmap,
	47	BD2606_REG_PWRCNT,
	48	1 << led->led_no,
	49	0);
	50
	51	/* shared brightness register */
	52	err = regmap_write(priv->regmap, led->led_no / 2,
	53	led_cdev->max_brightness == 1 ?
	54	BD2606_MAX_BRIGHTNESS : brightness);
	55	if (err)
	56	return err;
	57
	58	return regmap_update_bits(priv->regmap,
	59	BD2606_REG_PWRCNT,
	60	1 << led->led_no,
	61	1 << led->led_no);
	62	}
	63
	64	static const struct regmap_config bd2606mvv_regmap = {
65	.reg_bits = 8,
66	.val_bits = 8,
67	.max_register = 0x3,
68	};
69
70	static int bd2606mvv_probe(struct i2c_client *client)
71	{
72	struct fwnode_handle np, child;
73	struct device *dev = &client->dev;
74	struct bd2606mvv_priv *priv;
75	struct fwnode_handle *led_fwnodes[BD2606_MAX_LEDS] = { 0 };
76	int active_pairs[BD2606_MAX_LEDS / 2] = { 0 };
77	int err, reg;
78	int i;
79
80	np = dev_fwnode(dev);
81	if (!np)
82	return -ENODEV;
83
84	priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
85	if (!priv)
86	return -ENOMEM;
87
88	priv->regmap = devm_regmap_init_i2c(client, &bd2606mvv_regmap);
89	if (IS_ERR(priv->regmap)) {
90	err = PTR_ERR(priv->regmap);
91	dev_err(dev, "Failed to allocate register map: %d\n", err);
92	return err;
93	}
94
95	i2c_set_clientdata(client, priv);
96
97	fwnode_for_each_available_child_node(np, child) {
98	struct bd2606mvv_led *led;
99
100	err = fwnode_property_read_u32(child, "reg", &reg);
101	if (err) {
102	fwnode_handle_put(child);
103	return err;
104	}
105	if (reg < 0 \|\| reg >= BD2606_MAX_LEDS \|\| led_fwnodes[reg]) {
106	fwnode_handle_put(child);
107	return -EINVAL;
108	}
109	led = &priv->leds[reg];
110	led_fwnodes[reg] = child;
111	active_pairs[reg / 2]++;
112	led->priv = priv;
113	led->led_no = reg;
114	led->ldev.brightness_set_blocking = bd2606mvv_brightness_set;
115	led->ldev.max_brightness = BD2606_MAX_BRIGHTNESS;
116	}
117
118	for (i = 0; i < BD2606_MAX_LEDS; i++) {
119	struct led_init_data init_data = {};
120
121	if (!led_fwnodes[i])
122	continue;
123
124	init_data.fwnode = led_fwnodes[i];
125	/* Check whether brightness can be independently adjusted. */
126	if (active_pairs[i / 2] == 2)
127	priv->leds[i].ldev.max_brightness = 1;
128
129	err = devm_led_classdev_register_ext(dev,
130	&priv->leds[i].ldev,
131	&init_data);
132	if (err < 0) {
133	fwnode_handle_put(child);
134	return dev_err_probe(dev, err,
135	"couldn't register LED %s\n",
136	priv->leds[i].ldev.name);
137	}
138	}
139	return 0;
140	}
141
142	static const struct of_device_id __maybe_unused of_bd2606mvv_leds_match[] = {
143	{ .compatible = "rohm,bd2606mvv", },
144	{},
145	};
146	MODULE_DEVICE_TABLE(of, of_bd2606mvv_leds_match);
147
148	static struct i2c_driver bd2606mvv_driver = {
149	.driver = {
150	.name = "leds-bd2606mvv",
151	.of_match_table = of_match_ptr(of_bd2606mvv_leds_match),
152	},
d9ff8a8e	153	.probe = bd2606mvv_probe,
8325642d AK	154	};
	155
	156	module_i2c_driver(bd2606mvv_driver);
	157
	158	MODULE_AUTHOR("Andreas Kemnade <[email protected]>");
	159	MODULE_DESCRIPTION("BD2606 LED driver");
	160	MODULE_LICENSE("GPL");