1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * Driver for ISSI IS31FL32xx family of I2C LED controllers
4  *
5  * Copyright 2015 Allworx Corp.
6  *
7  * Datasheets:
8  *   http://www.issi.com/US/product-analog-fxled-driver.shtml
9  *   http://www.si-en.com/product.asp?parentid=890
10  */
11 
12 #include <linux/device.h>
13 #include <linux/i2c.h>
14 #include <linux/kernel.h>
15 #include <linux/leds.h>
16 #include <linux/module.h>
17 #include <linux/of.h>
18 #include <linux/of_device.h>
19 
20 /* Used to indicate a device has no such register */
21 #define IS31FL32XX_REG_NONE 0xFF
22 
23 /* Software Shutdown bit in Shutdown Register */
24 #define IS31FL32XX_SHUTDOWN_SSD_ENABLE  0
25 #define IS31FL32XX_SHUTDOWN_SSD_DISABLE BIT(0)
26 
27 /* IS31FL3216 has a number of unique registers */
28 #define IS31FL3216_CONFIG_REG 0x00
29 #define IS31FL3216_LIGHTING_EFFECT_REG 0x03
30 #define IS31FL3216_CHANNEL_CONFIG_REG 0x04
31 
32 /* Software Shutdown bit in 3216 Config Register */
33 #define IS31FL3216_CONFIG_SSD_ENABLE  BIT(7)
34 #define IS31FL3216_CONFIG_SSD_DISABLE 0
35 
36 struct is31fl32xx_priv;
37 struct is31fl32xx_led_data {
38 	struct led_classdev cdev;
39 	u8 channel; /* 1-based, max priv->cdef->channels */
40 	struct is31fl32xx_priv *priv;
41 };
42 
43 struct is31fl32xx_priv {
44 	const struct is31fl32xx_chipdef *cdef;
45 	struct i2c_client *client;
46 	unsigned int num_leds;
47 	struct is31fl32xx_led_data leds[0];
48 };
49 
50 /**
51  * struct is31fl32xx_chipdef - chip-specific attributes
52  * @channels            : Number of LED channels
53  * @shutdown_reg        : address of Shutdown register (optional)
54  * @pwm_update_reg      : address of PWM Update register
55  * @global_control_reg  : address of Global Control register (optional)
56  * @reset_reg           : address of Reset register (optional)
57  * @pwm_register_base   : address of first PWM register
58  * @pwm_registers_reversed: : true if PWM registers count down instead of up
59  * @led_control_register_base : address of first LED control register (optional)
60  * @enable_bits_per_led_control_register: number of LEDs enable bits in each
61  * @reset_func:         : pointer to reset function
62  *
63  * For all optional register addresses, the sentinel value %IS31FL32XX_REG_NONE
64  * indicates that this chip has no such register.
65  *
66  * If non-NULL, @reset_func will be called during probing to set all
67  * necessary registers to a known initialization state. This is needed
68  * for chips that do not have a @reset_reg.
69  *
70  * @enable_bits_per_led_control_register must be >=1 if
71  * @led_control_register_base != %IS31FL32XX_REG_NONE.
72  */
73 struct is31fl32xx_chipdef {
74 	u8	channels;
75 	u8	shutdown_reg;
76 	u8	pwm_update_reg;
77 	u8	global_control_reg;
78 	u8	reset_reg;
79 	u8	pwm_register_base;
80 	bool	pwm_registers_reversed;
81 	u8	led_control_register_base;
82 	u8	enable_bits_per_led_control_register;
83 	int (*reset_func)(struct is31fl32xx_priv *priv);
84 	int (*sw_shutdown_func)(struct is31fl32xx_priv *priv, bool enable);
85 };
86 
87 static const struct is31fl32xx_chipdef is31fl3236_cdef = {
88 	.channels				= 36,
89 	.shutdown_reg				= 0x00,
90 	.pwm_update_reg				= 0x25,
91 	.global_control_reg			= 0x4a,
92 	.reset_reg				= 0x4f,
93 	.pwm_register_base			= 0x01,
94 	.led_control_register_base		= 0x26,
95 	.enable_bits_per_led_control_register	= 1,
96 };
97 
98 static const struct is31fl32xx_chipdef is31fl3235_cdef = {
99 	.channels				= 28,
100 	.shutdown_reg				= 0x00,
101 	.pwm_update_reg				= 0x25,
102 	.global_control_reg			= 0x4a,
103 	.reset_reg				= 0x4f,
104 	.pwm_register_base			= 0x05,
105 	.led_control_register_base		= 0x2a,
106 	.enable_bits_per_led_control_register	= 1,
107 };
108 
109 static const struct is31fl32xx_chipdef is31fl3218_cdef = {
110 	.channels				= 18,
111 	.shutdown_reg				= 0x00,
112 	.pwm_update_reg				= 0x16,
113 	.global_control_reg			= IS31FL32XX_REG_NONE,
114 	.reset_reg				= 0x17,
115 	.pwm_register_base			= 0x01,
116 	.led_control_register_base		= 0x13,
117 	.enable_bits_per_led_control_register	= 6,
118 };
119 
120 static int is31fl3216_reset(struct is31fl32xx_priv *priv);
121 static int is31fl3216_software_shutdown(struct is31fl32xx_priv *priv,
122 					bool enable);
123 static const struct is31fl32xx_chipdef is31fl3216_cdef = {
124 	.channels				= 16,
125 	.shutdown_reg				= IS31FL32XX_REG_NONE,
126 	.pwm_update_reg				= 0xB0,
127 	.global_control_reg			= IS31FL32XX_REG_NONE,
128 	.reset_reg				= IS31FL32XX_REG_NONE,
129 	.pwm_register_base			= 0x10,
130 	.pwm_registers_reversed			= true,
131 	.led_control_register_base		= 0x01,
132 	.enable_bits_per_led_control_register	= 8,
133 	.reset_func				= is31fl3216_reset,
134 	.sw_shutdown_func			= is31fl3216_software_shutdown,
135 };
136 
137 static int is31fl32xx_write(struct is31fl32xx_priv *priv, u8 reg, u8 val)
138 {
139 	int ret;
140 
141 	dev_dbg(&priv->client->dev, "writing register 0x%02X=0x%02X", reg, val);
142 
143 	ret =  i2c_smbus_write_byte_data(priv->client, reg, val);
144 	if (ret) {
145 		dev_err(&priv->client->dev,
146 			"register write to 0x%02X failed (error %d)",
147 			reg, ret);
148 	}
149 	return ret;
150 }
151 
152 /*
153  * Custom reset function for IS31FL3216 because it does not have a RESET
154  * register the way that the other IS31FL32xx chips do. We don't bother
155  * writing the GPIO and animation registers, because the registers we
156  * do write ensure those will have no effect.
157  */
158 static int is31fl3216_reset(struct is31fl32xx_priv *priv)
159 {
160 	unsigned int i;
161 	int ret;
162 
163 	ret = is31fl32xx_write(priv, IS31FL3216_CONFIG_REG,
164 			       IS31FL3216_CONFIG_SSD_ENABLE);
165 	if (ret)
166 		return ret;
167 	for (i = 0; i < priv->cdef->channels; i++) {
168 		ret = is31fl32xx_write(priv, priv->cdef->pwm_register_base+i,
169 				       0x00);
170 		if (ret)
171 			return ret;
172 	}
173 	ret = is31fl32xx_write(priv, priv->cdef->pwm_update_reg, 0);
174 	if (ret)
175 		return ret;
176 	ret = is31fl32xx_write(priv, IS31FL3216_LIGHTING_EFFECT_REG, 0x00);
177 	if (ret)
178 		return ret;
179 	ret = is31fl32xx_write(priv, IS31FL3216_CHANNEL_CONFIG_REG, 0x00);
180 	if (ret)
181 		return ret;
182 
183 	return 0;
184 }
185 
186 /*
187  * Custom Software-Shutdown function for IS31FL3216 because it does not have
188  * a SHUTDOWN register the way that the other IS31FL32xx chips do.
189  * We don't bother doing a read/modify/write on the CONFIG register because
190  * we only ever use a value of '0' for the other fields in that register.
191  */
192 static int is31fl3216_software_shutdown(struct is31fl32xx_priv *priv,
193 					bool enable)
194 {
195 	u8 value = enable ? IS31FL3216_CONFIG_SSD_ENABLE :
196 			    IS31FL3216_CONFIG_SSD_DISABLE;
197 
198 	return is31fl32xx_write(priv, IS31FL3216_CONFIG_REG, value);
199 }
200 
201 /*
202  * NOTE: A mutex is not needed in this function because:
203  * - All referenced data is read-only after probe()
204  * - The I2C core has a mutex on to protect the bus
205  * - There are no read/modify/write operations
206  * - Intervening operations between the write of the PWM register
207  *   and the Update register are harmless.
208  *
209  * Example:
210  *	PWM_REG_1 write 16
211  *	UPDATE_REG write 0
212  *	PWM_REG_2 write 128
213  *	UPDATE_REG write 0
214  *   vs:
215  *	PWM_REG_1 write 16
216  *	PWM_REG_2 write 128
217  *	UPDATE_REG write 0
218  *	UPDATE_REG write 0
219  * are equivalent. Poking the Update register merely applies all PWM
220  * register writes up to that point.
221  */
222 static int is31fl32xx_brightness_set(struct led_classdev *led_cdev,
223 				     enum led_brightness brightness)
224 {
225 	const struct is31fl32xx_led_data *led_data =
226 		container_of(led_cdev, struct is31fl32xx_led_data, cdev);
227 	const struct is31fl32xx_chipdef *cdef = led_data->priv->cdef;
228 	u8 pwm_register_offset;
229 	int ret;
230 
231 	dev_dbg(led_cdev->dev, "%s: %d\n", __func__, brightness);
232 
233 	/* NOTE: led_data->channel is 1-based */
234 	if (cdef->pwm_registers_reversed)
235 		pwm_register_offset = cdef->channels - led_data->channel;
236 	else
237 		pwm_register_offset = led_data->channel - 1;
238 
239 	ret = is31fl32xx_write(led_data->priv,
240 			       cdef->pwm_register_base + pwm_register_offset,
241 			       brightness);
242 	if (ret)
243 		return ret;
244 
245 	return is31fl32xx_write(led_data->priv, cdef->pwm_update_reg, 0);
246 }
247 
248 static int is31fl32xx_reset_regs(struct is31fl32xx_priv *priv)
249 {
250 	const struct is31fl32xx_chipdef *cdef = priv->cdef;
251 	int ret;
252 
253 	if (cdef->reset_reg != IS31FL32XX_REG_NONE) {
254 		ret = is31fl32xx_write(priv, cdef->reset_reg, 0);
255 		if (ret)
256 			return ret;
257 	}
258 
259 	if (cdef->reset_func)
260 		return cdef->reset_func(priv);
261 
262 	return 0;
263 }
264 
265 static int is31fl32xx_software_shutdown(struct is31fl32xx_priv *priv,
266 					bool enable)
267 {
268 	const struct is31fl32xx_chipdef *cdef = priv->cdef;
269 	int ret;
270 
271 	if (cdef->shutdown_reg != IS31FL32XX_REG_NONE) {
272 		u8 value = enable ? IS31FL32XX_SHUTDOWN_SSD_ENABLE :
273 				    IS31FL32XX_SHUTDOWN_SSD_DISABLE;
274 		ret = is31fl32xx_write(priv, cdef->shutdown_reg, value);
275 		if (ret)
276 			return ret;
277 	}
278 
279 	if (cdef->sw_shutdown_func)
280 		return cdef->sw_shutdown_func(priv, enable);
281 
282 	return 0;
283 }
284 
285 static int is31fl32xx_init_regs(struct is31fl32xx_priv *priv)
286 {
287 	const struct is31fl32xx_chipdef *cdef = priv->cdef;
288 	int ret;
289 
290 	ret = is31fl32xx_reset_regs(priv);
291 	if (ret)
292 		return ret;
293 
294 	/*
295 	 * Set enable bit for all channels.
296 	 * We will control state with PWM registers alone.
297 	 */
298 	if (cdef->led_control_register_base != IS31FL32XX_REG_NONE) {
299 		u8 value =
300 		    GENMASK(cdef->enable_bits_per_led_control_register-1, 0);
301 		u8 num_regs = cdef->channels /
302 				cdef->enable_bits_per_led_control_register;
303 		int i;
304 
305 		for (i = 0; i < num_regs; i++) {
306 			ret = is31fl32xx_write(priv,
307 					       cdef->led_control_register_base+i,
308 					       value);
309 			if (ret)
310 				return ret;
311 		}
312 	}
313 
314 	ret = is31fl32xx_software_shutdown(priv, false);
315 	if (ret)
316 		return ret;
317 
318 	if (cdef->global_control_reg != IS31FL32XX_REG_NONE) {
319 		ret = is31fl32xx_write(priv, cdef->global_control_reg, 0x00);
320 		if (ret)
321 			return ret;
322 	}
323 
324 	return 0;
325 }
326 
327 static int is31fl32xx_parse_child_dt(const struct device *dev,
328 				     const struct device_node *child,
329 				     struct is31fl32xx_led_data *led_data)
330 {
331 	struct led_classdev *cdev = &led_data->cdev;
332 	int ret = 0;
333 	u32 reg;
334 
335 	if (of_property_read_string(child, "label", &cdev->name))
336 		cdev->name = child->name;
337 
338 	ret = of_property_read_u32(child, "reg", &reg);
339 	if (ret || reg < 1 || reg > led_data->priv->cdef->channels) {
340 		dev_err(dev,
341 			"Child node %pOF does not have a valid reg property\n",
342 			child);
343 		return -EINVAL;
344 	}
345 	led_data->channel = reg;
346 
347 	of_property_read_string(child, "linux,default-trigger",
348 				&cdev->default_trigger);
349 
350 	cdev->brightness_set_blocking = is31fl32xx_brightness_set;
351 
352 	return 0;
353 }
354 
355 static struct is31fl32xx_led_data *is31fl32xx_find_led_data(
356 					struct is31fl32xx_priv *priv,
357 					u8 channel)
358 {
359 	size_t i;
360 
361 	for (i = 0; i < priv->num_leds; i++) {
362 		if (priv->leds[i].channel == channel)
363 			return &priv->leds[i];
364 	}
365 
366 	return NULL;
367 }
368 
369 static int is31fl32xx_parse_dt(struct device *dev,
370 			       struct is31fl32xx_priv *priv)
371 {
372 	struct device_node *child;
373 	int ret = 0;
374 
375 	for_each_child_of_node(dev->of_node, child) {
376 		struct is31fl32xx_led_data *led_data =
377 			&priv->leds[priv->num_leds];
378 		const struct is31fl32xx_led_data *other_led_data;
379 
380 		led_data->priv = priv;
381 
382 		ret = is31fl32xx_parse_child_dt(dev, child, led_data);
383 		if (ret)
384 			goto err;
385 
386 		/* Detect if channel is already in use by another child */
387 		other_led_data = is31fl32xx_find_led_data(priv,
388 							  led_data->channel);
389 		if (other_led_data) {
390 			dev_err(dev,
391 				"%s and %s both attempting to use channel %d\n",
392 				led_data->cdev.name,
393 				other_led_data->cdev.name,
394 				led_data->channel);
395 			goto err;
396 		}
397 
398 		ret = devm_led_classdev_register(dev, &led_data->cdev);
399 		if (ret) {
400 			dev_err(dev, "failed to register PWM led for %s: %d\n",
401 				led_data->cdev.name, ret);
402 			goto err;
403 		}
404 
405 		priv->num_leds++;
406 	}
407 
408 	return 0;
409 
410 err:
411 	of_node_put(child);
412 	return ret;
413 }
414 
415 static const struct of_device_id of_is31fl32xx_match[] = {
416 	{ .compatible = "issi,is31fl3236", .data = &is31fl3236_cdef, },
417 	{ .compatible = "issi,is31fl3235", .data = &is31fl3235_cdef, },
418 	{ .compatible = "issi,is31fl3218", .data = &is31fl3218_cdef, },
419 	{ .compatible = "si-en,sn3218",    .data = &is31fl3218_cdef, },
420 	{ .compatible = "issi,is31fl3216", .data = &is31fl3216_cdef, },
421 	{ .compatible = "si-en,sn3216",    .data = &is31fl3216_cdef, },
422 	{},
423 };
424 
425 MODULE_DEVICE_TABLE(of, of_is31fl32xx_match);
426 
427 static int is31fl32xx_probe(struct i2c_client *client,
428 			    const struct i2c_device_id *id)
429 {
430 	const struct is31fl32xx_chipdef *cdef;
431 	const struct of_device_id *of_dev_id;
432 	struct device *dev = &client->dev;
433 	struct is31fl32xx_priv *priv;
434 	int count;
435 	int ret = 0;
436 
437 	of_dev_id = of_match_device(of_is31fl32xx_match, dev);
438 	if (!of_dev_id)
439 		return -EINVAL;
440 
441 	cdef = of_dev_id->data;
442 
443 	count = of_get_child_count(dev->of_node);
444 	if (!count)
445 		return -EINVAL;
446 
447 	priv = devm_kzalloc(dev, struct_size(priv, leds, count),
448 			    GFP_KERNEL);
449 	if (!priv)
450 		return -ENOMEM;
451 
452 	priv->client = client;
453 	priv->cdef = cdef;
454 	i2c_set_clientdata(client, priv);
455 
456 	ret = is31fl32xx_init_regs(priv);
457 	if (ret)
458 		return ret;
459 
460 	ret = is31fl32xx_parse_dt(dev, priv);
461 	if (ret)
462 		return ret;
463 
464 	return 0;
465 }
466 
467 static int is31fl32xx_remove(struct i2c_client *client)
468 {
469 	struct is31fl32xx_priv *priv = i2c_get_clientdata(client);
470 
471 	return is31fl32xx_reset_regs(priv);
472 }
473 
474 /*
475  * i2c-core (and modalias) requires that id_table be properly filled,
476  * even though it is not used for DeviceTree based instantiation.
477  */
478 static const struct i2c_device_id is31fl32xx_id[] = {
479 	{ "is31fl3236" },
480 	{ "is31fl3235" },
481 	{ "is31fl3218" },
482 	{ "sn3218" },
483 	{ "is31fl3216" },
484 	{ "sn3216" },
485 	{},
486 };
487 
488 MODULE_DEVICE_TABLE(i2c, is31fl32xx_id);
489 
490 static struct i2c_driver is31fl32xx_driver = {
491 	.driver = {
492 		.name	= "is31fl32xx",
493 		.of_match_table = of_is31fl32xx_match,
494 	},
495 	.probe		= is31fl32xx_probe,
496 	.remove		= is31fl32xx_remove,
497 	.id_table	= is31fl32xx_id,
498 };
499 
500 module_i2c_driver(is31fl32xx_driver);
501 
502 MODULE_AUTHOR("David Rivshin <drivshin@allworx.com>");
503 MODULE_DESCRIPTION("ISSI IS31FL32xx LED driver");
504 MODULE_LICENSE("GPL v2");
505