1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * Battery driver for Maxim MAX8925
4  *
5  * Copyright (c) 2009-2010 Marvell International Ltd.
6  *	Haojian Zhuang <haojian.zhuang@marvell.com>
7  */
8 
9 #include <linux/module.h>
10 #include <linux/err.h>
11 #include <linux/slab.h>
12 #include <linux/of.h>
13 #include <linux/i2c.h>
14 #include <linux/interrupt.h>
15 #include <linux/platform_device.h>
16 #include <linux/power_supply.h>
17 #include <linux/mfd/max8925.h>
18 
19 /* registers in GPM */
20 #define MAX8925_OUT5VEN			0x54
21 #define MAX8925_OUT3VEN			0x58
22 #define MAX8925_CHG_CNTL1		0x7c
23 
24 /* bits definition */
25 #define MAX8925_CHG_STAT_VSYSLOW	(1 << 0)
26 #define MAX8925_CHG_STAT_MODE_MASK	(3 << 2)
27 #define MAX8925_CHG_STAT_EN_MASK	(1 << 4)
28 #define MAX8925_CHG_MBDET		(1 << 1)
29 #define MAX8925_CHG_AC_RANGE_MASK	(3 << 6)
30 
31 /* registers in ADC */
32 #define MAX8925_ADC_RES_CNFG1		0x06
33 #define MAX8925_ADC_AVG_CNFG1		0x07
34 #define MAX8925_ADC_ACQ_CNFG1		0x08
35 #define MAX8925_ADC_ACQ_CNFG2		0x09
36 /* 2 bytes registers in below. MSB is 1st, LSB is 2nd. */
37 #define MAX8925_ADC_AUX2		0x62
38 #define MAX8925_ADC_VCHG		0x64
39 #define MAX8925_ADC_VBBATT		0x66
40 #define MAX8925_ADC_VMBATT		0x68
41 #define MAX8925_ADC_ISNS		0x6a
42 #define MAX8925_ADC_THM			0x6c
43 #define MAX8925_ADC_TDIE		0x6e
44 #define MAX8925_CMD_AUX2		0xc8
45 #define MAX8925_CMD_VCHG		0xd0
46 #define MAX8925_CMD_VBBATT		0xd8
47 #define MAX8925_CMD_VMBATT		0xe0
48 #define MAX8925_CMD_ISNS		0xe8
49 #define MAX8925_CMD_THM			0xf0
50 #define MAX8925_CMD_TDIE		0xf8
51 
52 enum {
53 	MEASURE_AUX2,
54 	MEASURE_VCHG,
55 	MEASURE_VBBATT,
56 	MEASURE_VMBATT,
57 	MEASURE_ISNS,
58 	MEASURE_THM,
59 	MEASURE_TDIE,
60 	MEASURE_MAX,
61 };
62 
63 struct max8925_power_info {
64 	struct max8925_chip	*chip;
65 	struct i2c_client	*gpm;
66 	struct i2c_client	*adc;
67 
68 	struct power_supply	*ac;
69 	struct power_supply	*usb;
70 	struct power_supply	*battery;
71 	int			irq_base;
72 	unsigned		ac_online:1;
73 	unsigned		usb_online:1;
74 	unsigned		bat_online:1;
75 	unsigned		chg_mode:2;
76 	unsigned		batt_detect:1;	/* detecing MB by ID pin */
77 	unsigned		topoff_threshold:2;
78 	unsigned		fast_charge:3;
79 	unsigned		no_temp_support:1;
80 	unsigned		no_insert_detect:1;
81 
82 	int (*set_charger) (int);
83 };
84 
85 static int __set_charger(struct max8925_power_info *info, int enable)
86 {
87 	struct max8925_chip *chip = info->chip;
88 	if (enable) {
89 		/* enable charger in platform */
90 		if (info->set_charger)
91 			info->set_charger(1);
92 		/* enable charger */
93 		max8925_set_bits(info->gpm, MAX8925_CHG_CNTL1, 1 << 7, 0);
94 	} else {
95 		/* disable charge */
96 		max8925_set_bits(info->gpm, MAX8925_CHG_CNTL1, 1 << 7, 1 << 7);
97 		if (info->set_charger)
98 			info->set_charger(0);
99 	}
100 	dev_dbg(chip->dev, "%s\n", (enable) ? "Enable charger"
101 		: "Disable charger");
102 	return 0;
103 }
104 
105 static irqreturn_t max8925_charger_handler(int irq, void *data)
106 {
107 	struct max8925_power_info *info = (struct max8925_power_info *)data;
108 	struct max8925_chip *chip = info->chip;
109 
110 	switch (irq - chip->irq_base) {
111 	case MAX8925_IRQ_VCHG_DC_R:
112 		info->ac_online = 1;
113 		__set_charger(info, 1);
114 		dev_dbg(chip->dev, "Adapter inserted\n");
115 		break;
116 	case MAX8925_IRQ_VCHG_DC_F:
117 		info->ac_online = 0;
118 		__set_charger(info, 0);
119 		dev_dbg(chip->dev, "Adapter removed\n");
120 		break;
121 	case MAX8925_IRQ_VCHG_THM_OK_F:
122 		/* Battery is not ready yet */
123 		dev_dbg(chip->dev, "Battery temperature is out of range\n");
124 		/* Fall through */
125 	case MAX8925_IRQ_VCHG_DC_OVP:
126 		dev_dbg(chip->dev, "Error detection\n");
127 		__set_charger(info, 0);
128 		break;
129 	case MAX8925_IRQ_VCHG_THM_OK_R:
130 		/* Battery is ready now */
131 		dev_dbg(chip->dev, "Battery temperature is in range\n");
132 		break;
133 	case MAX8925_IRQ_VCHG_SYSLOW_R:
134 		/* VSYS is low */
135 		dev_info(chip->dev, "Sys power is too low\n");
136 		break;
137 	case MAX8925_IRQ_VCHG_SYSLOW_F:
138 		dev_dbg(chip->dev, "Sys power is above low threshold\n");
139 		break;
140 	case MAX8925_IRQ_VCHG_DONE:
141 		__set_charger(info, 0);
142 		dev_dbg(chip->dev, "Charging is done\n");
143 		break;
144 	case MAX8925_IRQ_VCHG_TOPOFF:
145 		dev_dbg(chip->dev, "Charging in top-off mode\n");
146 		break;
147 	case MAX8925_IRQ_VCHG_TMR_FAULT:
148 		__set_charger(info, 0);
149 		dev_dbg(chip->dev, "Safe timer is expired\n");
150 		break;
151 	case MAX8925_IRQ_VCHG_RST:
152 		__set_charger(info, 0);
153 		dev_dbg(chip->dev, "Charger is reset\n");
154 		break;
155 	}
156 	return IRQ_HANDLED;
157 }
158 
159 static int start_measure(struct max8925_power_info *info, int type)
160 {
161 	unsigned char buf[2] = {0, 0};
162 	int meas_cmd;
163 	int meas_reg = 0, ret;
164 
165 	switch (type) {
166 	case MEASURE_VCHG:
167 		meas_cmd = MAX8925_CMD_VCHG;
168 		meas_reg = MAX8925_ADC_VCHG;
169 		break;
170 	case MEASURE_VBBATT:
171 		meas_cmd = MAX8925_CMD_VBBATT;
172 		meas_reg = MAX8925_ADC_VBBATT;
173 		break;
174 	case MEASURE_VMBATT:
175 		meas_cmd = MAX8925_CMD_VMBATT;
176 		meas_reg = MAX8925_ADC_VMBATT;
177 		break;
178 	case MEASURE_ISNS:
179 		meas_cmd = MAX8925_CMD_ISNS;
180 		meas_reg = MAX8925_ADC_ISNS;
181 		break;
182 	default:
183 		return -EINVAL;
184 	}
185 
186 	max8925_reg_write(info->adc, meas_cmd, 0);
187 	max8925_bulk_read(info->adc, meas_reg, 2, buf);
188 	ret = ((buf[0]<<8) | buf[1]) >> 4;
189 
190 	return ret;
191 }
192 
193 static int max8925_ac_get_prop(struct power_supply *psy,
194 			       enum power_supply_property psp,
195 			       union power_supply_propval *val)
196 {
197 	struct max8925_power_info *info = dev_get_drvdata(psy->dev.parent);
198 	int ret = 0;
199 
200 	switch (psp) {
201 	case POWER_SUPPLY_PROP_ONLINE:
202 		val->intval = info->ac_online;
203 		break;
204 	case POWER_SUPPLY_PROP_VOLTAGE_NOW:
205 		if (info->ac_online) {
206 			ret = start_measure(info, MEASURE_VCHG);
207 			if (ret >= 0) {
208 				val->intval = ret * 2000;	/* unit is uV */
209 				goto out;
210 			}
211 		}
212 		ret = -ENODATA;
213 		break;
214 	default:
215 		ret = -ENODEV;
216 		break;
217 	}
218 out:
219 	return ret;
220 }
221 
222 static enum power_supply_property max8925_ac_props[] = {
223 	POWER_SUPPLY_PROP_ONLINE,
224 	POWER_SUPPLY_PROP_VOLTAGE_NOW,
225 };
226 
227 static int max8925_usb_get_prop(struct power_supply *psy,
228 				enum power_supply_property psp,
229 				union power_supply_propval *val)
230 {
231 	struct max8925_power_info *info = dev_get_drvdata(psy->dev.parent);
232 	int ret = 0;
233 
234 	switch (psp) {
235 	case POWER_SUPPLY_PROP_ONLINE:
236 		val->intval = info->usb_online;
237 		break;
238 	case POWER_SUPPLY_PROP_VOLTAGE_NOW:
239 		if (info->usb_online) {
240 			ret = start_measure(info, MEASURE_VCHG);
241 			if (ret >= 0) {
242 				val->intval = ret * 2000;	/* unit is uV */
243 				goto out;
244 			}
245 		}
246 		ret = -ENODATA;
247 		break;
248 	default:
249 		ret = -ENODEV;
250 		break;
251 	}
252 out:
253 	return ret;
254 }
255 
256 static enum power_supply_property max8925_usb_props[] = {
257 	POWER_SUPPLY_PROP_ONLINE,
258 	POWER_SUPPLY_PROP_VOLTAGE_NOW,
259 };
260 
261 static int max8925_bat_get_prop(struct power_supply *psy,
262 				enum power_supply_property psp,
263 				union power_supply_propval *val)
264 {
265 	struct max8925_power_info *info = dev_get_drvdata(psy->dev.parent);
266 	int ret = 0;
267 
268 	switch (psp) {
269 	case POWER_SUPPLY_PROP_ONLINE:
270 		val->intval = info->bat_online;
271 		break;
272 	case POWER_SUPPLY_PROP_VOLTAGE_NOW:
273 		if (info->bat_online) {
274 			ret = start_measure(info, MEASURE_VMBATT);
275 			if (ret >= 0) {
276 				val->intval = ret * 2000;	/* unit is uV */
277 				ret = 0;
278 				break;
279 			}
280 		}
281 		ret = -ENODATA;
282 		break;
283 	case POWER_SUPPLY_PROP_CURRENT_NOW:
284 		if (info->bat_online) {
285 			ret = start_measure(info, MEASURE_ISNS);
286 			if (ret >= 0) {
287 				/* assume r_sns is 0.02 */
288 				ret = ((ret * 6250) - 3125) /* uA */;
289 				val->intval = 0;
290 				if (ret > 0)
291 					val->intval = ret; /* unit is mA */
292 				ret = 0;
293 				break;
294 			}
295 		}
296 		ret = -ENODATA;
297 		break;
298 	case POWER_SUPPLY_PROP_CHARGE_TYPE:
299 		if (!info->bat_online) {
300 			ret = -ENODATA;
301 			break;
302 		}
303 		ret = max8925_reg_read(info->gpm, MAX8925_CHG_STATUS);
304 		ret = (ret & MAX8925_CHG_STAT_MODE_MASK) >> 2;
305 		switch (ret) {
306 		case 1:
307 			val->intval = POWER_SUPPLY_CHARGE_TYPE_FAST;
308 			break;
309 		case 0:
310 		case 2:
311 			val->intval = POWER_SUPPLY_CHARGE_TYPE_TRICKLE;
312 			break;
313 		case 3:
314 			val->intval = POWER_SUPPLY_CHARGE_TYPE_NONE;
315 			break;
316 		}
317 		ret = 0;
318 		break;
319 	case POWER_SUPPLY_PROP_STATUS:
320 		if (!info->bat_online) {
321 			ret = -ENODATA;
322 			break;
323 		}
324 		ret = max8925_reg_read(info->gpm, MAX8925_CHG_STATUS);
325 		if (info->usb_online || info->ac_online) {
326 			val->intval = POWER_SUPPLY_STATUS_NOT_CHARGING;
327 			if (ret & MAX8925_CHG_STAT_EN_MASK)
328 				val->intval = POWER_SUPPLY_STATUS_CHARGING;
329 		} else
330 			val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
331 		ret = 0;
332 		break;
333 	default:
334 		ret = -ENODEV;
335 		break;
336 	}
337 	return ret;
338 }
339 
340 static enum power_supply_property max8925_battery_props[] = {
341 	POWER_SUPPLY_PROP_ONLINE,
342 	POWER_SUPPLY_PROP_VOLTAGE_NOW,
343 	POWER_SUPPLY_PROP_CURRENT_NOW,
344 	POWER_SUPPLY_PROP_CHARGE_TYPE,
345 	POWER_SUPPLY_PROP_STATUS,
346 };
347 
348 static const struct power_supply_desc ac_desc = {
349 	.name		= "max8925-ac",
350 	.type		= POWER_SUPPLY_TYPE_MAINS,
351 	.properties	= max8925_ac_props,
352 	.num_properties	= ARRAY_SIZE(max8925_ac_props),
353 	.get_property	= max8925_ac_get_prop,
354 };
355 
356 static const struct power_supply_desc usb_desc = {
357 	.name		= "max8925-usb",
358 	.type		= POWER_SUPPLY_TYPE_USB,
359 	.properties	= max8925_usb_props,
360 	.num_properties	= ARRAY_SIZE(max8925_usb_props),
361 	.get_property	= max8925_usb_get_prop,
362 };
363 
364 static const struct power_supply_desc battery_desc = {
365 	.name		= "max8925-battery",
366 	.type		= POWER_SUPPLY_TYPE_BATTERY,
367 	.properties	= max8925_battery_props,
368 	.num_properties	= ARRAY_SIZE(max8925_battery_props),
369 	.get_property	= max8925_bat_get_prop,
370 };
371 
372 #define REQUEST_IRQ(_irq, _name)					\
373 do {									\
374 	ret = request_threaded_irq(chip->irq_base + _irq, NULL,		\
375 				    max8925_charger_handler,		\
376 				    IRQF_ONESHOT, _name, info);		\
377 	if (ret)							\
378 		dev_err(chip->dev, "Failed to request IRQ #%d: %d\n",	\
379 			_irq, ret);					\
380 } while (0)
381 
382 static int max8925_init_charger(struct max8925_chip *chip,
383 					  struct max8925_power_info *info)
384 {
385 	int ret;
386 
387 	REQUEST_IRQ(MAX8925_IRQ_VCHG_DC_OVP, "ac-ovp");
388 	if (!info->no_insert_detect) {
389 		REQUEST_IRQ(MAX8925_IRQ_VCHG_DC_F, "ac-remove");
390 		REQUEST_IRQ(MAX8925_IRQ_VCHG_DC_R, "ac-insert");
391 	}
392 	if (!info->no_temp_support) {
393 		REQUEST_IRQ(MAX8925_IRQ_VCHG_THM_OK_R, "batt-temp-in-range");
394 		REQUEST_IRQ(MAX8925_IRQ_VCHG_THM_OK_F, "batt-temp-out-range");
395 	}
396 	REQUEST_IRQ(MAX8925_IRQ_VCHG_SYSLOW_F, "vsys-high");
397 	REQUEST_IRQ(MAX8925_IRQ_VCHG_SYSLOW_R, "vsys-low");
398 	REQUEST_IRQ(MAX8925_IRQ_VCHG_RST, "charger-reset");
399 	REQUEST_IRQ(MAX8925_IRQ_VCHG_DONE, "charger-done");
400 	REQUEST_IRQ(MAX8925_IRQ_VCHG_TOPOFF, "charger-topoff");
401 	REQUEST_IRQ(MAX8925_IRQ_VCHG_TMR_FAULT, "charger-timer-expire");
402 
403 	info->usb_online = 0;
404 	info->bat_online = 0;
405 
406 	/* check for power - can miss interrupt at boot time */
407 	if (start_measure(info, MEASURE_VCHG) * 2000 > 500000)
408 		info->ac_online = 1;
409 	else
410 		info->ac_online = 0;
411 
412 	ret = max8925_reg_read(info->gpm, MAX8925_CHG_STATUS);
413 	if (ret >= 0) {
414 		/*
415 		 * If battery detection is enabled, ID pin of battery is
416 		 * connected to MBDET pin of MAX8925. It could be used to
417 		 * detect battery presence.
418 		 * Otherwise, we have to assume that battery is always on.
419 		 */
420 		if (info->batt_detect)
421 			info->bat_online = (ret & MAX8925_CHG_MBDET) ? 0 : 1;
422 		else
423 			info->bat_online = 1;
424 		if (ret & MAX8925_CHG_AC_RANGE_MASK)
425 			info->ac_online = 1;
426 		else
427 			info->ac_online = 0;
428 	}
429 	/* disable charge */
430 	max8925_set_bits(info->gpm, MAX8925_CHG_CNTL1, 1 << 7, 1 << 7);
431 	/* set charging current in charge topoff mode */
432 	max8925_set_bits(info->gpm, MAX8925_CHG_CNTL1, 3 << 5,
433 			 info->topoff_threshold << 5);
434 	/* set charing current in fast charge mode */
435 	max8925_set_bits(info->gpm, MAX8925_CHG_CNTL1, 7, info->fast_charge);
436 
437 	return 0;
438 }
439 
440 static int max8925_deinit_charger(struct max8925_power_info *info)
441 {
442 	struct max8925_chip *chip = info->chip;
443 	int irq;
444 
445 	irq = chip->irq_base + MAX8925_IRQ_VCHG_DC_OVP;
446 	for (; irq <= chip->irq_base + MAX8925_IRQ_VCHG_TMR_FAULT; irq++)
447 		free_irq(irq, info);
448 
449 	return 0;
450 }
451 
452 #ifdef CONFIG_OF
453 static struct max8925_power_pdata *
454 max8925_power_dt_init(struct platform_device *pdev)
455 {
456 	struct device_node *nproot = pdev->dev.parent->of_node;
457 	struct device_node *np;
458 	int batt_detect;
459 	int topoff_threshold;
460 	int fast_charge;
461 	int no_temp_support;
462 	int no_insert_detect;
463 	struct max8925_power_pdata *pdata;
464 
465 	if (!nproot)
466 		return pdev->dev.platform_data;
467 
468 	np = of_get_child_by_name(nproot, "charger");
469 	if (!np) {
470 		dev_err(&pdev->dev, "failed to find charger node\n");
471 		return NULL;
472 	}
473 
474 	pdata = devm_kzalloc(&pdev->dev,
475 			sizeof(struct max8925_power_pdata),
476 			GFP_KERNEL);
477 	if (!pdata)
478 		goto ret;
479 
480 	of_property_read_u32(np, "topoff-threshold", &topoff_threshold);
481 	of_property_read_u32(np, "batt-detect", &batt_detect);
482 	of_property_read_u32(np, "fast-charge", &fast_charge);
483 	of_property_read_u32(np, "no-insert-detect", &no_insert_detect);
484 	of_property_read_u32(np, "no-temp-support", &no_temp_support);
485 
486 	pdata->batt_detect = batt_detect;
487 	pdata->fast_charge = fast_charge;
488 	pdata->topoff_threshold = topoff_threshold;
489 	pdata->no_insert_detect = no_insert_detect;
490 	pdata->no_temp_support = no_temp_support;
491 
492 ret:
493 	of_node_put(np);
494 	return pdata;
495 }
496 #else
497 static struct max8925_power_pdata *
498 max8925_power_dt_init(struct platform_device *pdev)
499 {
500 	return pdev->dev.platform_data;
501 }
502 #endif
503 
504 static int max8925_power_probe(struct platform_device *pdev)
505 {
506 	struct max8925_chip *chip = dev_get_drvdata(pdev->dev.parent);
507 	struct power_supply_config psy_cfg = {}; /* Only for ac and usb */
508 	struct max8925_power_pdata *pdata = NULL;
509 	struct max8925_power_info *info;
510 	int ret;
511 
512 	pdata = max8925_power_dt_init(pdev);
513 	if (!pdata) {
514 		dev_err(&pdev->dev, "platform data isn't assigned to "
515 			"power supply\n");
516 		return -EINVAL;
517 	}
518 
519 	info = devm_kzalloc(&pdev->dev, sizeof(struct max8925_power_info),
520 				GFP_KERNEL);
521 	if (!info)
522 		return -ENOMEM;
523 	info->chip = chip;
524 	info->gpm = chip->i2c;
525 	info->adc = chip->adc;
526 	platform_set_drvdata(pdev, info);
527 
528 	psy_cfg.supplied_to = pdata->supplied_to;
529 	psy_cfg.num_supplicants = pdata->num_supplicants;
530 
531 	info->ac = power_supply_register(&pdev->dev, &ac_desc, &psy_cfg);
532 	if (IS_ERR(info->ac)) {
533 		ret = PTR_ERR(info->ac);
534 		goto out;
535 	}
536 	info->ac->dev.parent = &pdev->dev;
537 
538 	info->usb = power_supply_register(&pdev->dev, &usb_desc, &psy_cfg);
539 	if (IS_ERR(info->usb)) {
540 		ret = PTR_ERR(info->usb);
541 		goto out_unregister_ac;
542 	}
543 	info->usb->dev.parent = &pdev->dev;
544 
545 	info->battery = power_supply_register(&pdev->dev, &battery_desc, NULL);
546 	if (IS_ERR(info->battery)) {
547 		ret = PTR_ERR(info->battery);
548 		goto out_unregister_usb;
549 	}
550 	info->battery->dev.parent = &pdev->dev;
551 
552 	info->batt_detect = pdata->batt_detect;
553 	info->topoff_threshold = pdata->topoff_threshold;
554 	info->fast_charge = pdata->fast_charge;
555 	info->set_charger = pdata->set_charger;
556 	info->no_temp_support = pdata->no_temp_support;
557 	info->no_insert_detect = pdata->no_insert_detect;
558 
559 	max8925_init_charger(chip, info);
560 	return 0;
561 out_unregister_usb:
562 	power_supply_unregister(info->usb);
563 out_unregister_ac:
564 	power_supply_unregister(info->ac);
565 out:
566 	return ret;
567 }
568 
569 static int max8925_power_remove(struct platform_device *pdev)
570 {
571 	struct max8925_power_info *info = platform_get_drvdata(pdev);
572 
573 	if (info) {
574 		power_supply_unregister(info->ac);
575 		power_supply_unregister(info->usb);
576 		power_supply_unregister(info->battery);
577 		max8925_deinit_charger(info);
578 	}
579 	return 0;
580 }
581 
582 static struct platform_driver max8925_power_driver = {
583 	.probe	= max8925_power_probe,
584 	.remove	= max8925_power_remove,
585 	.driver	= {
586 		.name	= "max8925-power",
587 	},
588 };
589 
590 module_platform_driver(max8925_power_driver);
591 
592 MODULE_LICENSE("GPL");
593 MODULE_DESCRIPTION("Power supply driver for MAX8925");
594 MODULE_ALIAS("platform:max8925-power");
595