1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * lm3533-core.c -- LM3533 Core
4  *
5  * Copyright (C) 2011-2012 Texas Instruments
6  *
7  * Author: Johan Hovold <jhovold@gmail.com>
8  */
9 
10 #include <linux/module.h>
11 #include <linux/init.h>
12 #include <linux/kernel.h>
13 #include <linux/err.h>
14 #include <linux/gpio/consumer.h>
15 #include <linux/i2c.h>
16 #include <linux/mfd/core.h>
17 #include <linux/regmap.h>
18 #include <linux/seq_file.h>
19 #include <linux/slab.h>
20 #include <linux/uaccess.h>
21 
22 #include <linux/mfd/lm3533.h>
23 
24 
25 #define LM3533_BOOST_OVP_MASK		0x06
26 #define LM3533_BOOST_OVP_SHIFT		1
27 
28 #define LM3533_BOOST_FREQ_MASK		0x01
29 #define LM3533_BOOST_FREQ_SHIFT		0
30 
31 #define LM3533_BL_ID_MASK		1
32 #define LM3533_LED_ID_MASK		3
33 #define LM3533_BL_ID_MAX		1
34 #define LM3533_LED_ID_MAX		3
35 
36 #define LM3533_HVLED_ID_MAX		2
37 #define LM3533_LVLED_ID_MAX		5
38 
39 #define LM3533_REG_OUTPUT_CONF1		0x10
40 #define LM3533_REG_OUTPUT_CONF2		0x11
41 #define LM3533_REG_BOOST_PWM		0x2c
42 
43 #define LM3533_REG_MAX			0xb2
44 
45 
46 static struct mfd_cell lm3533_als_devs[] = {
47 	{
48 		.name	= "lm3533-als",
49 		.id	= -1,
50 	},
51 };
52 
53 static struct mfd_cell lm3533_bl_devs[] = {
54 	{
55 		.name	= "lm3533-backlight",
56 		.id	= 0,
57 	},
58 	{
59 		.name	= "lm3533-backlight",
60 		.id	= 1,
61 	},
62 };
63 
64 static struct mfd_cell lm3533_led_devs[] = {
65 	{
66 		.name	= "lm3533-leds",
67 		.id	= 0,
68 	},
69 	{
70 		.name	= "lm3533-leds",
71 		.id	= 1,
72 	},
73 	{
74 		.name	= "lm3533-leds",
75 		.id	= 2,
76 	},
77 	{
78 		.name	= "lm3533-leds",
79 		.id	= 3,
80 	},
81 };
82 
lm3533_read(struct lm3533 * lm3533,u8 reg,u8 * val)83 int lm3533_read(struct lm3533 *lm3533, u8 reg, u8 *val)
84 {
85 	int tmp;
86 	int ret;
87 
88 	ret = regmap_read(lm3533->regmap, reg, &tmp);
89 	if (ret < 0) {
90 		dev_err(lm3533->dev, "failed to read register %02x: %d\n",
91 								reg, ret);
92 		return ret;
93 	}
94 
95 	*val = tmp;
96 
97 	dev_dbg(lm3533->dev, "read [%02x]: %02x\n", reg, *val);
98 
99 	return ret;
100 }
101 EXPORT_SYMBOL_GPL(lm3533_read);
102 
lm3533_write(struct lm3533 * lm3533,u8 reg,u8 val)103 int lm3533_write(struct lm3533 *lm3533, u8 reg, u8 val)
104 {
105 	int ret;
106 
107 	dev_dbg(lm3533->dev, "write [%02x]: %02x\n", reg, val);
108 
109 	ret = regmap_write(lm3533->regmap, reg, val);
110 	if (ret < 0) {
111 		dev_err(lm3533->dev, "failed to write register %02x: %d\n",
112 								reg, ret);
113 	}
114 
115 	return ret;
116 }
117 EXPORT_SYMBOL_GPL(lm3533_write);
118 
lm3533_update(struct lm3533 * lm3533,u8 reg,u8 val,u8 mask)119 int lm3533_update(struct lm3533 *lm3533, u8 reg, u8 val, u8 mask)
120 {
121 	int ret;
122 
123 	dev_dbg(lm3533->dev, "update [%02x]: %02x/%02x\n", reg, val, mask);
124 
125 	ret = regmap_update_bits(lm3533->regmap, reg, mask, val);
126 	if (ret < 0) {
127 		dev_err(lm3533->dev, "failed to update register %02x: %d\n",
128 								reg, ret);
129 	}
130 
131 	return ret;
132 }
133 EXPORT_SYMBOL_GPL(lm3533_update);
134 
lm3533_set_boost_freq(struct lm3533 * lm3533,enum lm3533_boost_freq freq)135 static int lm3533_set_boost_freq(struct lm3533 *lm3533,
136 						enum lm3533_boost_freq freq)
137 {
138 	int ret;
139 
140 	ret = lm3533_update(lm3533, LM3533_REG_BOOST_PWM,
141 					freq << LM3533_BOOST_FREQ_SHIFT,
142 					LM3533_BOOST_FREQ_MASK);
143 	if (ret)
144 		dev_err(lm3533->dev, "failed to set boost frequency\n");
145 
146 	return ret;
147 }
148 
149 
lm3533_set_boost_ovp(struct lm3533 * lm3533,enum lm3533_boost_ovp ovp)150 static int lm3533_set_boost_ovp(struct lm3533 *lm3533,
151 						enum lm3533_boost_ovp ovp)
152 {
153 	int ret;
154 
155 	ret = lm3533_update(lm3533, LM3533_REG_BOOST_PWM,
156 					ovp << LM3533_BOOST_OVP_SHIFT,
157 					LM3533_BOOST_OVP_MASK);
158 	if (ret)
159 		dev_err(lm3533->dev, "failed to set boost ovp\n");
160 
161 	return ret;
162 }
163 
164 /*
165  * HVLED output config -- output hvled controlled by backlight bl
166  */
lm3533_set_hvled_config(struct lm3533 * lm3533,u8 hvled,u8 bl)167 static int lm3533_set_hvled_config(struct lm3533 *lm3533, u8 hvled, u8 bl)
168 {
169 	u8 val;
170 	u8 mask;
171 	int shift;
172 	int ret;
173 
174 	if (hvled == 0 || hvled > LM3533_HVLED_ID_MAX)
175 		return -EINVAL;
176 
177 	if (bl > LM3533_BL_ID_MAX)
178 		return -EINVAL;
179 
180 	shift = hvled - 1;
181 	mask = LM3533_BL_ID_MASK << shift;
182 	val = bl << shift;
183 
184 	ret = lm3533_update(lm3533, LM3533_REG_OUTPUT_CONF1, val, mask);
185 	if (ret)
186 		dev_err(lm3533->dev, "failed to set hvled config\n");
187 
188 	return ret;
189 }
190 
191 /*
192  * LVLED output config -- output lvled controlled by LED led
193  */
lm3533_set_lvled_config(struct lm3533 * lm3533,u8 lvled,u8 led)194 static int lm3533_set_lvled_config(struct lm3533 *lm3533, u8 lvled, u8 led)
195 {
196 	u8 reg;
197 	u8 val;
198 	u8 mask;
199 	int shift;
200 	int ret;
201 
202 	if (lvled == 0 || lvled > LM3533_LVLED_ID_MAX)
203 		return -EINVAL;
204 
205 	if (led > LM3533_LED_ID_MAX)
206 		return -EINVAL;
207 
208 	if (lvled < 4) {
209 		reg = LM3533_REG_OUTPUT_CONF1;
210 		shift = 2 * lvled;
211 	} else {
212 		reg = LM3533_REG_OUTPUT_CONF2;
213 		shift = 2 * (lvled - 4);
214 	}
215 
216 	mask = LM3533_LED_ID_MASK << shift;
217 	val = led << shift;
218 
219 	ret = lm3533_update(lm3533, reg, val, mask);
220 	if (ret)
221 		dev_err(lm3533->dev, "failed to set lvled config\n");
222 
223 	return ret;
224 }
225 
lm3533_enable(struct lm3533 * lm3533)226 static void lm3533_enable(struct lm3533 *lm3533)
227 {
228 	gpiod_set_value(lm3533->hwen, 1);
229 }
230 
lm3533_disable(struct lm3533 * lm3533)231 static void lm3533_disable(struct lm3533 *lm3533)
232 {
233 	gpiod_set_value(lm3533->hwen, 0);
234 }
235 
236 enum lm3533_attribute_type {
237 	LM3533_ATTR_TYPE_BACKLIGHT,
238 	LM3533_ATTR_TYPE_LED,
239 };
240 
241 struct lm3533_device_attribute {
242 	struct device_attribute dev_attr;
243 	enum lm3533_attribute_type type;
244 	union {
245 		struct {
246 			u8 id;
247 		} output;
248 	} u;
249 };
250 
251 #define to_lm3533_dev_attr(_attr) \
252 	container_of(_attr, struct lm3533_device_attribute, dev_attr)
253 
show_output(struct device * dev,struct device_attribute * attr,char * buf)254 static ssize_t show_output(struct device *dev,
255 				struct device_attribute *attr, char *buf)
256 {
257 	struct lm3533 *lm3533 = dev_get_drvdata(dev);
258 	struct lm3533_device_attribute *lattr = to_lm3533_dev_attr(attr);
259 	int id = lattr->u.output.id;
260 	u8 reg;
261 	u8 val;
262 	u8 mask;
263 	int shift;
264 	int ret;
265 
266 	if (lattr->type == LM3533_ATTR_TYPE_BACKLIGHT) {
267 		reg = LM3533_REG_OUTPUT_CONF1;
268 		shift = id - 1;
269 		mask = LM3533_BL_ID_MASK << shift;
270 	} else {
271 		if (id < 4) {
272 			reg = LM3533_REG_OUTPUT_CONF1;
273 			shift = 2 * id;
274 		} else {
275 			reg = LM3533_REG_OUTPUT_CONF2;
276 			shift = 2 * (id - 4);
277 		}
278 		mask = LM3533_LED_ID_MASK << shift;
279 	}
280 
281 	ret = lm3533_read(lm3533, reg, &val);
282 	if (ret)
283 		return ret;
284 
285 	val = (val & mask) >> shift;
286 
287 	return sysfs_emit(buf, "%u\n", val);
288 }
289 
store_output(struct device * dev,struct device_attribute * attr,const char * buf,size_t len)290 static ssize_t store_output(struct device *dev,
291 					struct device_attribute *attr,
292 					const char *buf, size_t len)
293 {
294 	struct lm3533 *lm3533 = dev_get_drvdata(dev);
295 	struct lm3533_device_attribute *lattr = to_lm3533_dev_attr(attr);
296 	int id = lattr->u.output.id;
297 	u8 val;
298 	int ret;
299 
300 	if (kstrtou8(buf, 0, &val))
301 		return -EINVAL;
302 
303 	if (lattr->type == LM3533_ATTR_TYPE_BACKLIGHT)
304 		ret = lm3533_set_hvled_config(lm3533, id, val);
305 	else
306 		ret = lm3533_set_lvled_config(lm3533, id, val);
307 
308 	if (ret)
309 		return ret;
310 
311 	return len;
312 }
313 
314 #define LM3533_OUTPUT_ATTR(_name, _mode, _show, _store, _type, _id) \
315 	struct lm3533_device_attribute lm3533_dev_attr_##_name = \
316 		{ .dev_attr	= __ATTR(_name, _mode, _show, _store), \
317 		  .type		= _type, \
318 		  .u.output	= { .id = _id }, }
319 
320 #define LM3533_OUTPUT_ATTR_RW(_name, _type, _id) \
321 	LM3533_OUTPUT_ATTR(output_##_name, S_IRUGO | S_IWUSR, \
322 					show_output, store_output, _type, _id)
323 
324 #define LM3533_OUTPUT_HVLED_ATTR_RW(_nr) \
325 	LM3533_OUTPUT_ATTR_RW(hvled##_nr, LM3533_ATTR_TYPE_BACKLIGHT, _nr)
326 #define LM3533_OUTPUT_LVLED_ATTR_RW(_nr) \
327 	LM3533_OUTPUT_ATTR_RW(lvled##_nr, LM3533_ATTR_TYPE_LED, _nr)
328 /*
329  * Output config:
330  *
331  * output_hvled<nr>	0-1
332  * output_lvled<nr>	0-3
333  */
334 static LM3533_OUTPUT_HVLED_ATTR_RW(1);
335 static LM3533_OUTPUT_HVLED_ATTR_RW(2);
336 static LM3533_OUTPUT_LVLED_ATTR_RW(1);
337 static LM3533_OUTPUT_LVLED_ATTR_RW(2);
338 static LM3533_OUTPUT_LVLED_ATTR_RW(3);
339 static LM3533_OUTPUT_LVLED_ATTR_RW(4);
340 static LM3533_OUTPUT_LVLED_ATTR_RW(5);
341 
342 static struct attribute *lm3533_attributes[] = {
343 	&lm3533_dev_attr_output_hvled1.dev_attr.attr,
344 	&lm3533_dev_attr_output_hvled2.dev_attr.attr,
345 	&lm3533_dev_attr_output_lvled1.dev_attr.attr,
346 	&lm3533_dev_attr_output_lvled2.dev_attr.attr,
347 	&lm3533_dev_attr_output_lvled3.dev_attr.attr,
348 	&lm3533_dev_attr_output_lvled4.dev_attr.attr,
349 	&lm3533_dev_attr_output_lvled5.dev_attr.attr,
350 	NULL,
351 };
352 
353 #define to_dev_attr(_attr) \
354 	container_of(_attr, struct device_attribute, attr)
355 
lm3533_attr_is_visible(struct kobject * kobj,struct attribute * attr,int n)356 static umode_t lm3533_attr_is_visible(struct kobject *kobj,
357 					     struct attribute *attr, int n)
358 {
359 	struct device *dev = kobj_to_dev(kobj);
360 	struct lm3533 *lm3533 = dev_get_drvdata(dev);
361 	struct device_attribute *dattr = to_dev_attr(attr);
362 	struct lm3533_device_attribute *lattr = to_lm3533_dev_attr(dattr);
363 	enum lm3533_attribute_type type = lattr->type;
364 	umode_t mode = attr->mode;
365 
366 	if (!lm3533->have_backlights && type == LM3533_ATTR_TYPE_BACKLIGHT)
367 		mode = 0;
368 	else if (!lm3533->have_leds && type == LM3533_ATTR_TYPE_LED)
369 		mode = 0;
370 
371 	return mode;
372 };
373 
374 static struct attribute_group lm3533_attribute_group = {
375 	.is_visible	= lm3533_attr_is_visible,
376 	.attrs		= lm3533_attributes
377 };
378 
lm3533_device_als_init(struct lm3533 * lm3533)379 static int lm3533_device_als_init(struct lm3533 *lm3533)
380 {
381 	struct lm3533_platform_data *pdata = dev_get_platdata(lm3533->dev);
382 	int ret;
383 
384 	if (!pdata->als)
385 		return 0;
386 
387 	lm3533_als_devs[0].platform_data = pdata->als;
388 	lm3533_als_devs[0].pdata_size = sizeof(*pdata->als);
389 
390 	ret = mfd_add_devices(lm3533->dev, 0, lm3533_als_devs, 1, NULL,
391 			      0, NULL);
392 	if (ret) {
393 		dev_err(lm3533->dev, "failed to add ALS device\n");
394 		return ret;
395 	}
396 
397 	lm3533->have_als = 1;
398 
399 	return 0;
400 }
401 
lm3533_device_bl_init(struct lm3533 * lm3533)402 static int lm3533_device_bl_init(struct lm3533 *lm3533)
403 {
404 	struct lm3533_platform_data *pdata = dev_get_platdata(lm3533->dev);
405 	int i;
406 	int ret;
407 
408 	if (!pdata->backlights || pdata->num_backlights == 0)
409 		return 0;
410 
411 	if (pdata->num_backlights > ARRAY_SIZE(lm3533_bl_devs))
412 		pdata->num_backlights = ARRAY_SIZE(lm3533_bl_devs);
413 
414 	for (i = 0; i < pdata->num_backlights; ++i) {
415 		lm3533_bl_devs[i].platform_data = &pdata->backlights[i];
416 		lm3533_bl_devs[i].pdata_size = sizeof(pdata->backlights[i]);
417 	}
418 
419 	ret = mfd_add_devices(lm3533->dev, 0, lm3533_bl_devs,
420 			      pdata->num_backlights, NULL, 0, NULL);
421 	if (ret) {
422 		dev_err(lm3533->dev, "failed to add backlight devices\n");
423 		return ret;
424 	}
425 
426 	lm3533->have_backlights = 1;
427 
428 	return 0;
429 }
430 
lm3533_device_led_init(struct lm3533 * lm3533)431 static int lm3533_device_led_init(struct lm3533 *lm3533)
432 {
433 	struct lm3533_platform_data *pdata = dev_get_platdata(lm3533->dev);
434 	int i;
435 	int ret;
436 
437 	if (!pdata->leds || pdata->num_leds == 0)
438 		return 0;
439 
440 	if (pdata->num_leds > ARRAY_SIZE(lm3533_led_devs))
441 		pdata->num_leds = ARRAY_SIZE(lm3533_led_devs);
442 
443 	for (i = 0; i < pdata->num_leds; ++i) {
444 		lm3533_led_devs[i].platform_data = &pdata->leds[i];
445 		lm3533_led_devs[i].pdata_size = sizeof(pdata->leds[i]);
446 	}
447 
448 	ret = mfd_add_devices(lm3533->dev, 0, lm3533_led_devs,
449 			      pdata->num_leds, NULL, 0, NULL);
450 	if (ret) {
451 		dev_err(lm3533->dev, "failed to add LED devices\n");
452 		return ret;
453 	}
454 
455 	lm3533->have_leds = 1;
456 
457 	return 0;
458 }
459 
lm3533_device_setup(struct lm3533 * lm3533,struct lm3533_platform_data * pdata)460 static int lm3533_device_setup(struct lm3533 *lm3533,
461 					struct lm3533_platform_data *pdata)
462 {
463 	int ret;
464 
465 	ret = lm3533_set_boost_freq(lm3533, pdata->boost_freq);
466 	if (ret)
467 		return ret;
468 
469 	return lm3533_set_boost_ovp(lm3533, pdata->boost_ovp);
470 }
471 
lm3533_device_init(struct lm3533 * lm3533)472 static int lm3533_device_init(struct lm3533 *lm3533)
473 {
474 	struct lm3533_platform_data *pdata = dev_get_platdata(lm3533->dev);
475 	int ret;
476 
477 	dev_dbg(lm3533->dev, "%s\n", __func__);
478 
479 	if (!pdata) {
480 		dev_err(lm3533->dev, "no platform data\n");
481 		return -EINVAL;
482 	}
483 
484 	lm3533->hwen = devm_gpiod_get(lm3533->dev, NULL, GPIOD_OUT_LOW);
485 	if (IS_ERR(lm3533->hwen))
486 		return dev_err_probe(lm3533->dev, PTR_ERR(lm3533->hwen), "failed to request HWEN GPIO\n");
487 	gpiod_set_consumer_name(lm3533->hwen, "lm3533-hwen");
488 
489 	lm3533_enable(lm3533);
490 
491 	ret = lm3533_device_setup(lm3533, pdata);
492 	if (ret)
493 		goto err_disable;
494 
495 	lm3533_device_als_init(lm3533);
496 	lm3533_device_bl_init(lm3533);
497 	lm3533_device_led_init(lm3533);
498 
499 	ret = sysfs_create_group(&lm3533->dev->kobj, &lm3533_attribute_group);
500 	if (ret < 0) {
501 		dev_err(lm3533->dev, "failed to create sysfs attributes\n");
502 		goto err_unregister;
503 	}
504 
505 	return 0;
506 
507 err_unregister:
508 	mfd_remove_devices(lm3533->dev);
509 err_disable:
510 	lm3533_disable(lm3533);
511 
512 	return ret;
513 }
514 
lm3533_device_exit(struct lm3533 * lm3533)515 static void lm3533_device_exit(struct lm3533 *lm3533)
516 {
517 	dev_dbg(lm3533->dev, "%s\n", __func__);
518 
519 	sysfs_remove_group(&lm3533->dev->kobj, &lm3533_attribute_group);
520 
521 	mfd_remove_devices(lm3533->dev);
522 	lm3533_disable(lm3533);
523 }
524 
lm3533_readable_register(struct device * dev,unsigned int reg)525 static bool lm3533_readable_register(struct device *dev, unsigned int reg)
526 {
527 	switch (reg) {
528 	case 0x10 ... 0x2c:
529 	case 0x30 ... 0x38:
530 	case 0x40 ... 0x45:
531 	case 0x50 ... 0x57:
532 	case 0x60 ... 0x6e:
533 	case 0x70 ... 0x75:
534 	case 0x80 ... 0x85:
535 	case 0x90 ... 0x95:
536 	case 0xa0 ... 0xa5:
537 	case 0xb0 ... 0xb2:
538 		return true;
539 	default:
540 		return false;
541 	}
542 }
543 
lm3533_volatile_register(struct device * dev,unsigned int reg)544 static bool lm3533_volatile_register(struct device *dev, unsigned int reg)
545 {
546 	switch (reg) {
547 	case 0x34 ... 0x36:	/* zone */
548 	case 0x37 ... 0x38:	/* adc */
549 	case 0xb0 ... 0xb1:	/* fault */
550 		return true;
551 	default:
552 		return false;
553 	}
554 }
555 
lm3533_precious_register(struct device * dev,unsigned int reg)556 static bool lm3533_precious_register(struct device *dev, unsigned int reg)
557 {
558 	switch (reg) {
559 	case 0x34:		/* zone */
560 		return true;
561 	default:
562 		return false;
563 	}
564 }
565 
566 static const struct regmap_config regmap_config = {
567 	.reg_bits	= 8,
568 	.val_bits	= 8,
569 	.max_register	= LM3533_REG_MAX,
570 	.readable_reg	= lm3533_readable_register,
571 	.volatile_reg	= lm3533_volatile_register,
572 	.precious_reg	= lm3533_precious_register,
573 };
574 
lm3533_i2c_probe(struct i2c_client * i2c)575 static int lm3533_i2c_probe(struct i2c_client *i2c)
576 {
577 	struct lm3533 *lm3533;
578 
579 	dev_dbg(&i2c->dev, "%s\n", __func__);
580 
581 	lm3533 = devm_kzalloc(&i2c->dev, sizeof(*lm3533), GFP_KERNEL);
582 	if (!lm3533)
583 		return -ENOMEM;
584 
585 	i2c_set_clientdata(i2c, lm3533);
586 
587 	lm3533->regmap = devm_regmap_init_i2c(i2c, &regmap_config);
588 	if (IS_ERR(lm3533->regmap))
589 		return PTR_ERR(lm3533->regmap);
590 
591 	lm3533->dev = &i2c->dev;
592 	lm3533->irq = i2c->irq;
593 
594 	return lm3533_device_init(lm3533);
595 }
596 
lm3533_i2c_remove(struct i2c_client * i2c)597 static void lm3533_i2c_remove(struct i2c_client *i2c)
598 {
599 	struct lm3533 *lm3533 = i2c_get_clientdata(i2c);
600 
601 	dev_dbg(&i2c->dev, "%s\n", __func__);
602 
603 	lm3533_device_exit(lm3533);
604 }
605 
606 static const struct i2c_device_id lm3533_i2c_ids[] = {
607 	{ "lm3533" },
608 	{ }
609 };
610 MODULE_DEVICE_TABLE(i2c, lm3533_i2c_ids);
611 
612 static struct i2c_driver lm3533_i2c_driver = {
613 	.driver = {
614 		   .name = "lm3533",
615 	},
616 	.id_table	= lm3533_i2c_ids,
617 	.probe		= lm3533_i2c_probe,
618 	.remove		= lm3533_i2c_remove,
619 };
620 
lm3533_i2c_init(void)621 static int __init lm3533_i2c_init(void)
622 {
623 	return i2c_add_driver(&lm3533_i2c_driver);
624 }
625 subsys_initcall(lm3533_i2c_init);
626 
lm3533_i2c_exit(void)627 static void __exit lm3533_i2c_exit(void)
628 {
629 	i2c_del_driver(&lm3533_i2c_driver);
630 }
631 module_exit(lm3533_i2c_exit);
632 
633 MODULE_AUTHOR("Johan Hovold <jhovold@gmail.com>");
634 MODULE_DESCRIPTION("LM3533 Core");
635 MODULE_LICENSE("GPL");
636