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
26struct bd2606mvv_led {
27 unsigned int led_no;
28 struct led_classdev ldev;
29 struct bd2606mvv_priv *priv;
30};
31
32struct bd2606mvv_priv {
33 struct bd2606mvv_led leds[BD2606_MAX_LEDS];
34 struct regmap *regmap;
35};
36
37static int
38bd2606mvv_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(map: priv->regmap,
47 BD2606_REG_PWRCNT,
48 mask: 1 << led->led_no,
49 val: 0);
50
51 /* shared brightness register */
52 err = regmap_write(map: priv->regmap, reg: led->led_no / 2,
53 val: led_cdev->max_brightness == 1 ?
54 BD2606_MAX_BRIGHTNESS : brightness);
55 if (err)
56 return err;
57
58 return regmap_update_bits(map: priv->regmap,
59 BD2606_REG_PWRCNT,
60 mask: 1 << led->led_no,
61 val: 1 << led->led_no);
62}
63
64static const struct regmap_config bd2606mvv_regmap = {
65 .reg_bits = 8,
66 .val_bits = 8,
67 .max_register = 0x3,
68};
69
70static 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, size: 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(ptr: priv->regmap)) {
90 err = PTR_ERR(ptr: priv->regmap);
91 dev_err(dev, "Failed to allocate register map: %d\n", err);
92 return err;
93 }
94
95 i2c_set_clientdata(client, data: priv);
96
97 fwnode_for_each_available_child_node(np, child) {
98 struct bd2606mvv_led *led;
99
100 err = fwnode_property_read_u32(fwnode: child, propname: "reg", val: &reg);
101 if (err) {
102 fwnode_handle_put(fwnode: child);
103 return err;
104 }
105 if (reg < 0 || reg >= BD2606_MAX_LEDS || led_fwnodes[reg]) {
106 fwnode_handle_put(fwnode: 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(parent: dev,
130 led_cdev: &priv->leds[i].ldev,
131 init_data: &init_data);
132 if (err < 0) {
133 fwnode_handle_put(fwnode: child);
134 return dev_err_probe(dev, err,
135 fmt: "couldn't register LED %s\n",
136 priv->leds[i].ldev.name);
137 }
138 }
139 return 0;
140}
141
142static const struct of_device_id __maybe_unused of_bd2606mvv_leds_match[] = {
143 { .compatible = "rohm,bd2606mvv", },
144 {},
145};
146MODULE_DEVICE_TABLE(of, of_bd2606mvv_leds_match);
147
148static struct i2c_driver bd2606mvv_driver = {
149 .driver = {
150 .name = "leds-bd2606mvv",
151 .of_match_table = of_match_ptr(of_bd2606mvv_leds_match),
152 },
153 .probe = bd2606mvv_probe,
154};
155
156module_i2c_driver(bd2606mvv_driver);
157
158MODULE_AUTHOR("Andreas Kemnade <andreas@kemnade.info>");
159MODULE_DESCRIPTION("BD2606 LED driver");
160MODULE_LICENSE("GPL");
161

source code of linux/drivers/leds/leds-bd2606mvv.c