1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * Copyright 2015-16 Golden Delicious Computers
4  *
5  * Author: Nikolaus Schaller <hns@goldelico.com>
6  *
7  * LED driver for the IS31FL319{0,1,3,6,9} to drive 1, 3, 6 or 9 light
8  * effect LEDs.
9  */
10 
11 #include <linux/err.h>
12 #include <linux/i2c.h>
13 #include <linux/leds.h>
14 #include <linux/module.h>
15 #include <linux/of.h>
16 #include <linux/of_device.h>
17 #include <linux/regmap.h>
18 #include <linux/slab.h>
19 #include <linux/delay.h>
20 #include <linux/gpio/consumer.h>
21 
22 /* register numbers */
23 #define IS31FL319X_SHUTDOWN		0x00
24 #define IS31FL319X_CTRL1		0x01
25 #define IS31FL319X_CTRL2		0x02
26 #define IS31FL319X_CONFIG1		0x03
27 #define IS31FL319X_CONFIG2		0x04
28 #define IS31FL319X_RAMP_MODE		0x05
29 #define IS31FL319X_BREATH_MASK		0x06
30 #define IS31FL319X_PWM(channel)		(0x07 + channel)
31 #define IS31FL319X_DATA_UPDATE		0x10
32 #define IS31FL319X_T0(channel)		(0x11 + channel)
33 #define IS31FL319X_T123_1		0x1a
34 #define IS31FL319X_T123_2		0x1b
35 #define IS31FL319X_T123_3		0x1c
36 #define IS31FL319X_T4(channel)		(0x1d + channel)
37 #define IS31FL319X_TIME_UPDATE		0x26
38 #define IS31FL319X_RESET		0xff
39 
40 #define IS31FL319X_REG_CNT		(IS31FL319X_RESET + 1)
41 
42 #define IS31FL319X_MAX_LEDS		9
43 
44 /* CS (Current Setting) in CONFIG2 register */
45 #define IS31FL319X_CONFIG2_CS_SHIFT	4
46 #define IS31FL319X_CONFIG2_CS_MASK	0x7
47 #define IS31FL319X_CONFIG2_CS_STEP_REF	12
48 
49 #define IS31FL319X_CURRENT_MIN		((u32)5000)
50 #define IS31FL319X_CURRENT_MAX		((u32)40000)
51 #define IS31FL319X_CURRENT_STEP		((u32)5000)
52 #define IS31FL319X_CURRENT_DEFAULT	((u32)20000)
53 
54 /* Audio gain in CONFIG2 register */
55 #define IS31FL319X_AUDIO_GAIN_DB_MAX	((u32)21)
56 #define IS31FL319X_AUDIO_GAIN_DB_STEP	((u32)3)
57 
58 /*
59  * regmap is used as a cache of chip's register space,
60  * to avoid reading back brightness values from chip,
61  * which is known to hang.
62  */
63 struct is31fl319x_chip {
64 	const struct is31fl319x_chipdef *cdef;
65 	struct i2c_client               *client;
66 	struct gpio_desc		*shutdown_gpio;
67 	struct regmap                   *regmap;
68 	struct mutex                    lock;
69 	u32                             audio_gain_db;
70 
71 	struct is31fl319x_led {
72 		struct is31fl319x_chip  *chip;
73 		struct led_classdev     cdev;
74 		u32                     max_microamp;
75 		bool                    configured;
76 	} leds[IS31FL319X_MAX_LEDS];
77 };
78 
79 struct is31fl319x_chipdef {
80 	int num_leds;
81 };
82 
83 static const struct is31fl319x_chipdef is31fl3190_cdef = {
84 	.num_leds = 1,
85 };
86 
87 static const struct is31fl319x_chipdef is31fl3193_cdef = {
88 	.num_leds = 3,
89 };
90 
91 static const struct is31fl319x_chipdef is31fl3196_cdef = {
92 	.num_leds = 6,
93 };
94 
95 static const struct is31fl319x_chipdef is31fl3199_cdef = {
96 	.num_leds = 9,
97 };
98 
99 static const struct of_device_id of_is31fl319x_match[] = {
100 	{ .compatible = "issi,is31fl3190", .data = &is31fl3190_cdef, },
101 	{ .compatible = "issi,is31fl3191", .data = &is31fl3190_cdef, },
102 	{ .compatible = "issi,is31fl3193", .data = &is31fl3193_cdef, },
103 	{ .compatible = "issi,is31fl3196", .data = &is31fl3196_cdef, },
104 	{ .compatible = "issi,is31fl3199", .data = &is31fl3199_cdef, },
105 	{ .compatible = "si-en,sn3199",    .data = &is31fl3199_cdef, },
106 	{ }
107 };
108 MODULE_DEVICE_TABLE(of, of_is31fl319x_match);
109 
110 static int is31fl319x_brightness_set(struct led_classdev *cdev,
111 				     enum led_brightness brightness)
112 {
113 	struct is31fl319x_led *led = container_of(cdev, struct is31fl319x_led,
114 						  cdev);
115 	struct is31fl319x_chip *is31 = led->chip;
116 	int chan = led - is31->leds;
117 	int ret;
118 	int i;
119 	u8 ctrl1 = 0, ctrl2 = 0;
120 
121 	dev_dbg(&is31->client->dev, "%s %d: %d\n", __func__, chan, brightness);
122 
123 	mutex_lock(&is31->lock);
124 
125 	/* update PWM register */
126 	ret = regmap_write(is31->regmap, IS31FL319X_PWM(chan), brightness);
127 	if (ret < 0)
128 		goto out;
129 
130 	/* read current brightness of all PWM channels */
131 	for (i = 0; i < is31->cdef->num_leds; i++) {
132 		unsigned int pwm_value;
133 		bool on;
134 
135 		/*
136 		 * since neither cdev nor the chip can provide
137 		 * the current setting, we read from the regmap cache
138 		 */
139 
140 		ret = regmap_read(is31->regmap, IS31FL319X_PWM(i), &pwm_value);
141 		dev_dbg(&is31->client->dev, "%s read %d: ret=%d: %d\n",
142 			__func__, i, ret, pwm_value);
143 		on = ret >= 0 && pwm_value > LED_OFF;
144 
145 		if (i < 3)
146 			ctrl1 |= on << i;       /* 0..2 => bit 0..2 */
147 		else if (i < 6)
148 			ctrl1 |= on << (i + 1); /* 3..5 => bit 4..6 */
149 		else
150 			ctrl2 |= on << (i - 6); /* 6..8 => bit 0..2 */
151 	}
152 
153 	if (ctrl1 > 0 || ctrl2 > 0) {
154 		dev_dbg(&is31->client->dev, "power up %02x %02x\n",
155 			ctrl1, ctrl2);
156 		regmap_write(is31->regmap, IS31FL319X_CTRL1, ctrl1);
157 		regmap_write(is31->regmap, IS31FL319X_CTRL2, ctrl2);
158 		/* update PWMs */
159 		regmap_write(is31->regmap, IS31FL319X_DATA_UPDATE, 0x00);
160 		/* enable chip from shut down */
161 		ret = regmap_write(is31->regmap, IS31FL319X_SHUTDOWN, 0x01);
162 	} else {
163 		dev_dbg(&is31->client->dev, "power down\n");
164 		/* shut down (no need to clear CTRL1/2) */
165 		ret = regmap_write(is31->regmap, IS31FL319X_SHUTDOWN, 0x00);
166 	}
167 
168 out:
169 	mutex_unlock(&is31->lock);
170 
171 	return ret;
172 }
173 
174 static int is31fl319x_parse_child_dt(const struct device *dev,
175 				     const struct device_node *child,
176 				     struct is31fl319x_led *led)
177 {
178 	struct led_classdev *cdev = &led->cdev;
179 	int ret;
180 
181 	if (of_property_read_string(child, "label", &cdev->name))
182 		cdev->name = child->name;
183 
184 	ret = of_property_read_string(child, "linux,default-trigger",
185 				      &cdev->default_trigger);
186 	if (ret < 0 && ret != -EINVAL) /* is optional */
187 		return ret;
188 
189 	led->max_microamp = IS31FL319X_CURRENT_DEFAULT;
190 	ret = of_property_read_u32(child, "led-max-microamp",
191 				   &led->max_microamp);
192 	if (!ret) {
193 		if (led->max_microamp < IS31FL319X_CURRENT_MIN)
194 			return -EINVAL;	/* not supported */
195 		led->max_microamp = min(led->max_microamp,
196 					  IS31FL319X_CURRENT_MAX);
197 	}
198 
199 	return 0;
200 }
201 
202 static int is31fl319x_parse_dt(struct device *dev,
203 			       struct is31fl319x_chip *is31)
204 {
205 	struct device_node *np = dev_of_node(dev), *child;
206 	int count;
207 	int ret;
208 
209 	if (!np)
210 		return -ENODEV;
211 
212 	is31->shutdown_gpio = devm_gpiod_get_optional(dev,
213 						"shutdown",
214 						GPIOD_OUT_HIGH);
215 	if (IS_ERR(is31->shutdown_gpio)) {
216 		ret = PTR_ERR(is31->shutdown_gpio);
217 		dev_err(dev, "Failed to get shutdown gpio: %d\n", ret);
218 		return ret;
219 	}
220 
221 	is31->cdef = device_get_match_data(dev);
222 
223 	count = of_get_available_child_count(np);
224 
225 	dev_dbg(dev, "probing with %d leds defined in DT\n", count);
226 
227 	if (!count || count > is31->cdef->num_leds) {
228 		dev_err(dev, "Number of leds defined must be between 1 and %u\n",
229 			is31->cdef->num_leds);
230 		return -ENODEV;
231 	}
232 
233 	for_each_available_child_of_node(np, child) {
234 		struct is31fl319x_led *led;
235 		u32 reg;
236 
237 		ret = of_property_read_u32(child, "reg", &reg);
238 		if (ret) {
239 			dev_err(dev, "Failed to read led 'reg' property\n");
240 			goto put_child_node;
241 		}
242 
243 		if (reg < 1 || reg > is31->cdef->num_leds) {
244 			dev_err(dev, "invalid led reg %u\n", reg);
245 			ret = -EINVAL;
246 			goto put_child_node;
247 		}
248 
249 		led = &is31->leds[reg - 1];
250 
251 		if (led->configured) {
252 			dev_err(dev, "led %u is already configured\n", reg);
253 			ret = -EINVAL;
254 			goto put_child_node;
255 		}
256 
257 		ret = is31fl319x_parse_child_dt(dev, child, led);
258 		if (ret) {
259 			dev_err(dev, "led %u DT parsing failed\n", reg);
260 			goto put_child_node;
261 		}
262 
263 		led->configured = true;
264 	}
265 
266 	is31->audio_gain_db = 0;
267 	ret = of_property_read_u32(np, "audio-gain-db", &is31->audio_gain_db);
268 	if (!ret)
269 		is31->audio_gain_db = min(is31->audio_gain_db,
270 					  IS31FL319X_AUDIO_GAIN_DB_MAX);
271 
272 	return 0;
273 
274 put_child_node:
275 	of_node_put(child);
276 	return ret;
277 }
278 
279 static bool is31fl319x_readable_reg(struct device *dev, unsigned int reg)
280 { /* we have no readable registers */
281 	return false;
282 }
283 
284 static bool is31fl319x_volatile_reg(struct device *dev, unsigned int reg)
285 { /* volatile registers are not cached */
286 	switch (reg) {
287 	case IS31FL319X_DATA_UPDATE:
288 	case IS31FL319X_TIME_UPDATE:
289 	case IS31FL319X_RESET:
290 		return true; /* always write-through */
291 	default:
292 		return false;
293 	}
294 }
295 
296 static const struct reg_default is31fl319x_reg_defaults[] = {
297 	{ IS31FL319X_CONFIG1, 0x00},
298 	{ IS31FL319X_CONFIG2, 0x00},
299 	{ IS31FL319X_PWM(0), 0x00},
300 	{ IS31FL319X_PWM(1), 0x00},
301 	{ IS31FL319X_PWM(2), 0x00},
302 	{ IS31FL319X_PWM(3), 0x00},
303 	{ IS31FL319X_PWM(4), 0x00},
304 	{ IS31FL319X_PWM(5), 0x00},
305 	{ IS31FL319X_PWM(6), 0x00},
306 	{ IS31FL319X_PWM(7), 0x00},
307 	{ IS31FL319X_PWM(8), 0x00},
308 };
309 
310 static struct regmap_config regmap_config = {
311 	.reg_bits = 8,
312 	.val_bits = 8,
313 	.max_register = IS31FL319X_REG_CNT,
314 	.cache_type = REGCACHE_FLAT,
315 	.readable_reg = is31fl319x_readable_reg,
316 	.volatile_reg = is31fl319x_volatile_reg,
317 	.reg_defaults = is31fl319x_reg_defaults,
318 	.num_reg_defaults = ARRAY_SIZE(is31fl319x_reg_defaults),
319 };
320 
321 static inline int is31fl319x_microamp_to_cs(struct device *dev, u32 microamp)
322 { /* round down to nearest supported value (range check done by caller) */
323 	u32 step = microamp / IS31FL319X_CURRENT_STEP;
324 
325 	return ((IS31FL319X_CONFIG2_CS_STEP_REF - step) &
326 		IS31FL319X_CONFIG2_CS_MASK) <<
327 		IS31FL319X_CONFIG2_CS_SHIFT; /* CS encoding */
328 }
329 
330 static inline int is31fl319x_db_to_gain(u32 dezibel)
331 { /* round down to nearest supported value (range check done by caller) */
332 	return dezibel / IS31FL319X_AUDIO_GAIN_DB_STEP;
333 }
334 
335 static int is31fl319x_probe(struct i2c_client *client,
336 			    const struct i2c_device_id *id)
337 {
338 	struct is31fl319x_chip *is31;
339 	struct device *dev = &client->dev;
340 	int err;
341 	int i = 0;
342 	u32 aggregated_led_microamp = IS31FL319X_CURRENT_MAX;
343 
344 	if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C))
345 		return -EIO;
346 
347 	is31 = devm_kzalloc(&client->dev, sizeof(*is31), GFP_KERNEL);
348 	if (!is31)
349 		return -ENOMEM;
350 
351 	mutex_init(&is31->lock);
352 
353 	err = is31fl319x_parse_dt(&client->dev, is31);
354 	if (err)
355 		goto free_mutex;
356 
357 	if (is31->shutdown_gpio) {
358 		gpiod_direction_output(is31->shutdown_gpio, 0);
359 		mdelay(5);
360 		gpiod_direction_output(is31->shutdown_gpio, 1);
361 	}
362 
363 	is31->client = client;
364 	is31->regmap = devm_regmap_init_i2c(client, &regmap_config);
365 	if (IS_ERR(is31->regmap)) {
366 		dev_err(&client->dev, "failed to allocate register map\n");
367 		err = PTR_ERR(is31->regmap);
368 		goto free_mutex;
369 	}
370 
371 	i2c_set_clientdata(client, is31);
372 
373 	/* check for write-reply from chip (we can't read any registers) */
374 	err = regmap_write(is31->regmap, IS31FL319X_RESET, 0x00);
375 	if (err < 0) {
376 		dev_err(&client->dev, "no response from chip write: err = %d\n",
377 			err);
378 		err = -EIO; /* does not answer */
379 		goto free_mutex;
380 	}
381 
382 	/*
383 	 * Kernel conventions require per-LED led-max-microamp property.
384 	 * But the chip does not allow to limit individual LEDs.
385 	 * So we take minimum from all subnodes for safety of hardware.
386 	 */
387 	for (i = 0; i < is31->cdef->num_leds; i++)
388 		if (is31->leds[i].configured &&
389 		    is31->leds[i].max_microamp < aggregated_led_microamp)
390 			aggregated_led_microamp = is31->leds[i].max_microamp;
391 
392 	regmap_write(is31->regmap, IS31FL319X_CONFIG2,
393 		     is31fl319x_microamp_to_cs(dev, aggregated_led_microamp) |
394 		     is31fl319x_db_to_gain(is31->audio_gain_db));
395 
396 	for (i = 0; i < is31->cdef->num_leds; i++) {
397 		struct is31fl319x_led *led = &is31->leds[i];
398 
399 		if (!led->configured)
400 			continue;
401 
402 		led->chip = is31;
403 		led->cdev.brightness_set_blocking = is31fl319x_brightness_set;
404 
405 		err = devm_led_classdev_register(&client->dev, &led->cdev);
406 		if (err < 0)
407 			goto free_mutex;
408 	}
409 
410 	return 0;
411 
412 free_mutex:
413 	mutex_destroy(&is31->lock);
414 	return err;
415 }
416 
417 static int is31fl319x_remove(struct i2c_client *client)
418 {
419 	struct is31fl319x_chip *is31 = i2c_get_clientdata(client);
420 
421 	mutex_destroy(&is31->lock);
422 	return 0;
423 }
424 
425 /*
426  * i2c-core (and modalias) requires that id_table be properly filled,
427  * even though it is not used for DeviceTree based instantiation.
428  */
429 static const struct i2c_device_id is31fl319x_id[] = {
430 	{ "is31fl3190" },
431 	{ "is31fl3191" },
432 	{ "is31fl3193" },
433 	{ "is31fl3196" },
434 	{ "is31fl3199" },
435 	{ "sn3199" },
436 	{},
437 };
438 MODULE_DEVICE_TABLE(i2c, is31fl319x_id);
439 
440 static struct i2c_driver is31fl319x_driver = {
441 	.driver   = {
442 		.name           = "leds-is31fl319x",
443 		.of_match_table = of_match_ptr(of_is31fl319x_match),
444 	},
445 	.probe    = is31fl319x_probe,
446 	.remove   = is31fl319x_remove,
447 	.id_table = is31fl319x_id,
448 };
449 
450 module_i2c_driver(is31fl319x_driver);
451 
452 MODULE_AUTHOR("H. Nikolaus Schaller <hns@goldelico.com>");
453 MODULE_AUTHOR("Andrey Utkin <andrey_utkin@fastmail.com>");
454 MODULE_DESCRIPTION("IS31FL319X LED driver");
455 MODULE_LICENSE("GPL v2");
456