]>
Commit | Line | Data |
---|---|---|
36edc939 | 1 | // SPDX-License-Identifier: GPL-2.0-only |
8c40b7d0 NS |
2 | /* |
3 | * Copyright 2015-16 Golden Delicious Computers | |
4 | * | |
5 | * Author: Nikolaus Schaller <hns@goldelico.com> | |
6 | * | |
8c40b7d0 NS |
7 | * LED driver for the IS31FL319{0,1,3,6,9} to drive 1, 3, 6 or 9 light |
8 | * effect LEDs. | |
8c40b7d0 NS |
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> | |
dddb4e38 GF |
19 | #include <linux/delay.h> |
20 | #include <linux/gpio/consumer.h> | |
8c40b7d0 NS |
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; | |
dddb4e38 | 66 | struct gpio_desc *shutdown_gpio; |
8c40b7d0 NS |
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 | { | |
8853c95e | 205 | struct device_node *np = dev_of_node(dev), *child; |
8c40b7d0 NS |
206 | int count; |
207 | int ret; | |
208 | ||
209 | if (!np) | |
210 | return -ENODEV; | |
211 | ||
dddb4e38 GF |
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 | ||
2779f472 | 221 | is31->cdef = device_get_match_data(dev); |
8c40b7d0 | 222 | |
99a013c8 | 223 | count = of_get_available_child_count(np); |
8c40b7d0 | 224 | |
2779f472 | 225 | dev_dbg(dev, "probing with %d leds defined in DT\n", count); |
8c40b7d0 NS |
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 | ||
99a013c8 | 233 | for_each_available_child_of_node(np, child) { |
8c40b7d0 NS |
234 | struct is31fl319x_led *led; |
235 | u32 reg; | |
236 | ||
237 | ret = of_property_read_u32(child, "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; | |
8c40b7d0 NS |
340 | int err; |
341 | int i = 0; | |
342 | u32 aggregated_led_microamp = IS31FL319X_CURRENT_MAX; | |
343 | ||
7d9d60bd | 344 | if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) |
8c40b7d0 NS |
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 | ||
dddb4e38 GF |
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 | ||
8c40b7d0 NS |
363 | is31->client = client; |
364 | is31->regmap = devm_regmap_init_i2c(client, ®map_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"); |