1 | // SPDX-License-Identifier: GPL-2.0-only |
2 | /* |
3 | * LED driver for TI lp3952 controller |
4 | * |
5 | * Copyright (C) 2016, DAQRI, LLC. |
6 | * Author: Tony Makkiel <tony.makkiel@daqri.com> |
7 | */ |
8 | |
9 | #include <linux/delay.h> |
10 | #include <linux/gpio/consumer.h> |
11 | #include <linux/i2c.h> |
12 | #include <linux/io.h> |
13 | #include <linux/kernel.h> |
14 | #include <linux/leds.h> |
15 | #include <linux/leds-lp3952.h> |
16 | #include <linux/module.h> |
17 | #include <linux/notifier.h> |
18 | #include <linux/platform_device.h> |
19 | #include <linux/pm.h> |
20 | #include <linux/reboot.h> |
21 | #include <linux/regmap.h> |
22 | |
23 | static int lp3952_register_write(struct i2c_client *client, u8 reg, u8 val) |
24 | { |
25 | int ret; |
26 | struct lp3952_led_array *priv = i2c_get_clientdata(client); |
27 | |
28 | ret = regmap_write(map: priv->regmap, reg, val); |
29 | |
30 | if (ret) |
31 | dev_err(&client->dev, "%s: reg 0x%x, val 0x%x, err %d\n" , |
32 | __func__, reg, val, ret); |
33 | return ret; |
34 | } |
35 | |
36 | static void lp3952_on_off(struct lp3952_led_array *priv, |
37 | enum lp3952_leds led_id, bool on) |
38 | { |
39 | int ret, val; |
40 | |
41 | dev_dbg(&priv->client->dev, "%s LED %d to %d\n" , __func__, led_id, on); |
42 | |
43 | val = 1 << led_id; |
44 | if (led_id == LP3952_LED_ALL) |
45 | val = LP3952_LED_MASK_ALL; |
46 | |
47 | ret = regmap_update_bits(map: priv->regmap, LP3952_REG_LED_CTRL, mask: val, |
48 | val: on ? val : 0); |
49 | if (ret) |
50 | dev_err(&priv->client->dev, "%s, Error %d\n" , __func__, ret); |
51 | } |
52 | |
53 | /* |
54 | * Using Imax to control brightness. There are 4 possible |
55 | * setting 25, 50, 75 and 100 % of Imax. Possible values are |
56 | * values 0-4. 0 meaning turn off. |
57 | */ |
58 | static int lp3952_set_brightness(struct led_classdev *cdev, |
59 | enum led_brightness value) |
60 | { |
61 | unsigned int reg, shift_val; |
62 | struct lp3952_ctrl_hdl *led = container_of(cdev, |
63 | struct lp3952_ctrl_hdl, |
64 | cdev); |
65 | struct lp3952_led_array *priv = (struct lp3952_led_array *)led->priv; |
66 | |
67 | dev_dbg(cdev->dev, "Brightness request: %d on %d\n" , value, |
68 | led->channel); |
69 | |
70 | if (value == LED_OFF) { |
71 | lp3952_on_off(priv, led_id: led->channel, on: false); |
72 | return 0; |
73 | } |
74 | |
75 | if (led->channel > LP3952_RED_1) { |
76 | dev_err(cdev->dev, " %s Invalid LED requested" , __func__); |
77 | return -EINVAL; |
78 | } |
79 | |
80 | if (led->channel >= LP3952_BLUE_1) { |
81 | reg = LP3952_REG_RGB1_MAX_I_CTRL; |
82 | shift_val = (led->channel - LP3952_BLUE_1) * 2; |
83 | } else { |
84 | reg = LP3952_REG_RGB2_MAX_I_CTRL; |
85 | shift_val = led->channel * 2; |
86 | } |
87 | |
88 | /* Enable the LED in case it is not enabled already */ |
89 | lp3952_on_off(priv, led_id: led->channel, on: true); |
90 | |
91 | return regmap_update_bits(map: priv->regmap, reg, mask: 3 << shift_val, |
92 | val: --value << shift_val); |
93 | } |
94 | |
95 | static int lp3952_get_label(struct device *dev, const char *label, char *dest) |
96 | { |
97 | int ret; |
98 | const char *str; |
99 | |
100 | ret = device_property_read_string(dev, propname: label, val: &str); |
101 | if (ret) |
102 | return ret; |
103 | |
104 | strscpy(p: dest, q: str, LP3952_LABEL_MAX_LEN); |
105 | return 0; |
106 | } |
107 | |
108 | static int lp3952_register_led_classdev(struct lp3952_led_array *priv) |
109 | { |
110 | int i, acpi_ret, ret = -ENODEV; |
111 | static const char *led_name_hdl[LP3952_LED_ALL] = { |
112 | "blue2" , |
113 | "green2" , |
114 | "red2" , |
115 | "blue1" , |
116 | "green1" , |
117 | "red1" |
118 | }; |
119 | |
120 | for (i = 0; i < LP3952_LED_ALL; i++) { |
121 | acpi_ret = lp3952_get_label(dev: &priv->client->dev, label: led_name_hdl[i], |
122 | dest: priv->leds[i].name); |
123 | if (acpi_ret) |
124 | continue; |
125 | |
126 | priv->leds[i].cdev.name = priv->leds[i].name; |
127 | priv->leds[i].cdev.brightness = LED_OFF; |
128 | priv->leds[i].cdev.max_brightness = LP3952_BRIGHT_MAX; |
129 | priv->leds[i].cdev.brightness_set_blocking = |
130 | lp3952_set_brightness; |
131 | priv->leds[i].channel = i; |
132 | priv->leds[i].priv = priv; |
133 | |
134 | ret = devm_led_classdev_register(parent: &priv->client->dev, |
135 | led_cdev: &priv->leds[i].cdev); |
136 | if (ret < 0) { |
137 | dev_err(&priv->client->dev, |
138 | "couldn't register LED %s\n" , |
139 | priv->leds[i].cdev.name); |
140 | break; |
141 | } |
142 | } |
143 | return ret; |
144 | } |
145 | |
146 | static int lp3952_set_pattern_gen_cmd(struct lp3952_led_array *priv, |
147 | u8 cmd_index, u8 r, u8 g, u8 b, |
148 | enum lp3952_tt tt, enum lp3952_cet cet) |
149 | { |
150 | int ret; |
151 | struct ptrn_gen_cmd line = { |
152 | { |
153 | { |
154 | .r = r, |
155 | .g = g, |
156 | .b = b, |
157 | .cet = cet, |
158 | .tt = tt |
159 | } |
160 | } |
161 | }; |
162 | |
163 | if (cmd_index >= LP3952_CMD_REG_COUNT) |
164 | return -EINVAL; |
165 | |
166 | ret = lp3952_register_write(client: priv->client, |
167 | LP3952_REG_CMD_0 + cmd_index * 2, |
168 | val: line.bytes.msb); |
169 | if (ret) |
170 | return ret; |
171 | |
172 | return lp3952_register_write(client: priv->client, |
173 | LP3952_REG_CMD_0 + cmd_index * 2 + 1, |
174 | val: line.bytes.lsb); |
175 | } |
176 | |
177 | static int lp3952_configure(struct lp3952_led_array *priv) |
178 | { |
179 | int ret; |
180 | |
181 | /* Disable any LEDs on from any previous conf. */ |
182 | ret = lp3952_register_write(client: priv->client, LP3952_REG_LED_CTRL, val: 0); |
183 | if (ret) |
184 | return ret; |
185 | |
186 | /* enable rgb patter, loop */ |
187 | ret = lp3952_register_write(client: priv->client, LP3952_REG_PAT_GEN_CTRL, |
188 | LP3952_PATRN_LOOP | LP3952_PATRN_GEN_EN); |
189 | if (ret) |
190 | return ret; |
191 | |
192 | /* Update Bit 6 (Active mode), Select both Led sets, Bit [1:0] */ |
193 | ret = lp3952_register_write(client: priv->client, LP3952_REG_ENABLES, |
194 | LP3952_ACTIVE_MODE | LP3952_INT_B00ST_LDR); |
195 | if (ret) |
196 | return ret; |
197 | |
198 | /* Set Cmd1 for RGB intensity,cmd and transition time */ |
199 | return lp3952_set_pattern_gen_cmd(priv, cmd_index: 0, r: I46, g: I71, b: I100, tt: TT0, |
200 | cet: CET197); |
201 | } |
202 | |
203 | static const struct regmap_config lp3952_regmap = { |
204 | .reg_bits = 8, |
205 | .val_bits = 8, |
206 | .max_register = REG_MAX, |
207 | .cache_type = REGCACHE_MAPLE, |
208 | }; |
209 | |
210 | static int lp3952_probe(struct i2c_client *client) |
211 | { |
212 | int status; |
213 | struct lp3952_led_array *priv; |
214 | |
215 | priv = devm_kzalloc(dev: &client->dev, size: sizeof(*priv), GFP_KERNEL); |
216 | if (!priv) |
217 | return -ENOMEM; |
218 | |
219 | priv->client = client; |
220 | |
221 | priv->enable_gpio = devm_gpiod_get(dev: &client->dev, con_id: "nrst" , |
222 | flags: GPIOD_OUT_HIGH); |
223 | if (IS_ERR(ptr: priv->enable_gpio)) { |
224 | status = PTR_ERR(ptr: priv->enable_gpio); |
225 | dev_err(&client->dev, "Failed to enable gpio: %d\n" , status); |
226 | return status; |
227 | } |
228 | |
229 | priv->regmap = devm_regmap_init_i2c(client, &lp3952_regmap); |
230 | if (IS_ERR(ptr: priv->regmap)) { |
231 | int err = PTR_ERR(ptr: priv->regmap); |
232 | |
233 | dev_err(&client->dev, "Failed to allocate register map: %d\n" , |
234 | err); |
235 | return err; |
236 | } |
237 | |
238 | i2c_set_clientdata(client, data: priv); |
239 | |
240 | status = lp3952_configure(priv); |
241 | if (status) { |
242 | dev_err(&client->dev, "Probe failed. Device not found (%d)\n" , |
243 | status); |
244 | return status; |
245 | } |
246 | |
247 | status = lp3952_register_led_classdev(priv); |
248 | if (status) { |
249 | dev_err(&client->dev, "Unable to register led_classdev: %d\n" , |
250 | status); |
251 | return status; |
252 | } |
253 | |
254 | return 0; |
255 | } |
256 | |
257 | static void lp3952_remove(struct i2c_client *client) |
258 | { |
259 | struct lp3952_led_array *priv; |
260 | |
261 | priv = i2c_get_clientdata(client); |
262 | lp3952_on_off(priv, led_id: LP3952_LED_ALL, on: false); |
263 | gpiod_set_value(desc: priv->enable_gpio, value: 0); |
264 | } |
265 | |
266 | static const struct i2c_device_id lp3952_id[] = { |
267 | {LP3952_NAME, 0}, |
268 | {} |
269 | }; |
270 | MODULE_DEVICE_TABLE(i2c, lp3952_id); |
271 | |
272 | static struct i2c_driver lp3952_i2c_driver = { |
273 | .driver = { |
274 | .name = LP3952_NAME, |
275 | }, |
276 | .probe = lp3952_probe, |
277 | .remove = lp3952_remove, |
278 | .id_table = lp3952_id, |
279 | }; |
280 | |
281 | module_i2c_driver(lp3952_i2c_driver); |
282 | |
283 | MODULE_AUTHOR("Tony Makkiel <tony.makkiel@daqri.com>" ); |
284 | MODULE_DESCRIPTION("lp3952 I2C LED controller driver" ); |
285 | MODULE_LICENSE("GPL v2" ); |
286 | |