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/property.h>
17 #include <linux/regmap.h>
18 #include <linux/slab.h>
19
20 #define BD2606_MAX_LEDS 6
21 #define BD2606_MAX_BRIGHTNESS 63
22 #define BD2606_REG_PWRCNT 3
23 #define ldev_to_led(c) container_of(c, struct bd2606mvv_led, ldev)
24
25 struct bd2606mvv_led {
26 unsigned int led_no;
27 struct led_classdev ldev;
28 struct bd2606mvv_priv *priv;
29 };
30
31 struct bd2606mvv_priv {
32 struct bd2606mvv_led leds[BD2606_MAX_LEDS];
33 struct regmap *regmap;
34 };
35
36 static int
bd2606mvv_brightness_set(struct led_classdev * led_cdev,enum led_brightness brightness)37 bd2606mvv_brightness_set(struct led_classdev *led_cdev,
38 enum led_brightness brightness)
39 {
40 struct bd2606mvv_led *led = ldev_to_led(led_cdev);
41 struct bd2606mvv_priv *priv = led->priv;
42 int err;
43
44 if (brightness == 0)
45 return regmap_update_bits(priv->regmap,
46 BD2606_REG_PWRCNT,
47 1 << led->led_no,
48 0);
49
50 /* shared brightness register */
51 err = regmap_write(priv->regmap, led->led_no / 2,
52 led_cdev->max_brightness == 1 ?
53 BD2606_MAX_BRIGHTNESS : brightness);
54 if (err)
55 return err;
56
57 return regmap_update_bits(priv->regmap,
58 BD2606_REG_PWRCNT,
59 1 << led->led_no,
60 1 << led->led_no);
61 }
62
63 static const struct regmap_config bd2606mvv_regmap = {
64 .reg_bits = 8,
65 .val_bits = 8,
66 .max_register = 0x3,
67 };
68
bd2606mvv_probe(struct i2c_client * client)69 static int bd2606mvv_probe(struct i2c_client *client)
70 {
71 struct device *dev = &client->dev;
72 struct bd2606mvv_priv *priv;
73 struct fwnode_handle *led_fwnodes[BD2606_MAX_LEDS] = { 0 };
74 int active_pairs[BD2606_MAX_LEDS / 2] = { 0 };
75 int err, reg;
76 int i, j;
77
78 if (!dev_fwnode(dev))
79 return -ENODEV;
80
81 priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
82 if (!priv)
83 return -ENOMEM;
84
85 priv->regmap = devm_regmap_init_i2c(client, &bd2606mvv_regmap);
86 if (IS_ERR(priv->regmap)) {
87 err = PTR_ERR(priv->regmap);
88 dev_err(dev, "Failed to allocate register map: %d\n", err);
89 return err;
90 }
91
92 i2c_set_clientdata(client, priv);
93
94 device_for_each_child_node_scoped(dev, child) {
95 struct bd2606mvv_led *led;
96
97 err = fwnode_property_read_u32(child, "reg", ®);
98 if (err)
99 return err;
100
101 if (reg < 0 || reg >= BD2606_MAX_LEDS || led_fwnodes[reg])
102 return -EINVAL;
103
104 led = &priv->leds[reg];
105 led_fwnodes[reg] = fwnode_handle_get(child);
106 active_pairs[reg / 2]++;
107 led->priv = priv;
108 led->led_no = reg;
109 led->ldev.brightness_set_blocking = bd2606mvv_brightness_set;
110 led->ldev.max_brightness = BD2606_MAX_BRIGHTNESS;
111 }
112
113 for (i = 0; i < BD2606_MAX_LEDS; i++) {
114 struct led_init_data init_data = {};
115
116 if (!led_fwnodes[i])
117 continue;
118
119 init_data.fwnode = led_fwnodes[i];
120 /* Check whether brightness can be independently adjusted. */
121 if (active_pairs[i / 2] == 2)
122 priv->leds[i].ldev.max_brightness = 1;
123
124 err = devm_led_classdev_register_ext(dev,
125 &priv->leds[i].ldev,
126 &init_data);
127 if (err < 0) {
128 for (j = i; j < BD2606_MAX_LEDS; j++)
129 fwnode_handle_put(led_fwnodes[j]);
130 return dev_err_probe(dev, err,
131 "couldn't register LED %s\n",
132 priv->leds[i].ldev.name);
133 }
134 }
135 return 0;
136 }
137
138 static const struct of_device_id __maybe_unused of_bd2606mvv_leds_match[] = {
139 { .compatible = "rohm,bd2606mvv", },
140 {},
141 };
142 MODULE_DEVICE_TABLE(of, of_bd2606mvv_leds_match);
143
144 static struct i2c_driver bd2606mvv_driver = {
145 .driver = {
146 .name = "leds-bd2606mvv",
147 .of_match_table = of_match_ptr(of_bd2606mvv_leds_match),
148 },
149 .probe = bd2606mvv_probe,
150 };
151
152 module_i2c_driver(bd2606mvv_driver);
153
154 MODULE_AUTHOR("Andreas Kemnade <andreas@kemnade.info>");
155 MODULE_DESCRIPTION("BD2606 LED driver");
156 MODULE_LICENSE("GPL");
157