xref: /linux/drivers/power/supply/da9150-charger.c (revision bfd5bb6f90af092aa345b15cd78143956a13c2a8)
1 /*
2  * DA9150 Charger Driver
3  *
4  * Copyright (c) 2014 Dialog Semiconductor
5  *
6  * Author: Adam Thomson <Adam.Thomson.Opensource@diasemi.com>
7  *
8  * This program is free software; you can redistribute  it and/or modify it
9  * under  the terms of  the GNU General  Public License as published by the
10  * Free Software Foundation;  either version 2 of the  License, or (at your
11  * option) any later version.
12  */
13 
14 #include <linux/kernel.h>
15 #include <linux/slab.h>
16 #include <linux/module.h>
17 #include <linux/platform_device.h>
18 #include <linux/of.h>
19 #include <linux/of_platform.h>
20 #include <linux/interrupt.h>
21 #include <linux/power_supply.h>
22 #include <linux/notifier.h>
23 #include <linux/usb/phy.h>
24 #include <linux/iio/consumer.h>
25 #include <linux/mfd/da9150/core.h>
26 #include <linux/mfd/da9150/registers.h>
27 
28 /* Private data */
29 struct da9150_charger {
30 	struct da9150 *da9150;
31 	struct device *dev;
32 
33 	struct power_supply *usb;
34 	struct power_supply *battery;
35 	struct power_supply *supply_online;
36 
37 	struct usb_phy *usb_phy;
38 	struct notifier_block otg_nb;
39 	struct work_struct otg_work;
40 	unsigned long usb_event;
41 
42 	struct iio_channel *ibus_chan;
43 	struct iio_channel *vbus_chan;
44 	struct iio_channel *tjunc_chan;
45 	struct iio_channel *vbat_chan;
46 };
47 
48 static inline int da9150_charger_supply_online(struct da9150_charger *charger,
49 					       struct power_supply *psy,
50 					       union power_supply_propval *val)
51 {
52 	val->intval = (psy == charger->supply_online) ? 1 : 0;
53 
54 	return 0;
55 }
56 
57 /* Charger Properties */
58 static int da9150_charger_vbus_voltage_now(struct da9150_charger *charger,
59 					   union power_supply_propval *val)
60 {
61 	int v_val, ret;
62 
63 	/* Read processed value - mV units */
64 	ret = iio_read_channel_processed(charger->vbus_chan, &v_val);
65 	if (ret < 0)
66 		return ret;
67 
68 	/* Convert voltage to expected uV units */
69 	val->intval = v_val * 1000;
70 
71 	return 0;
72 }
73 
74 static int da9150_charger_ibus_current_avg(struct da9150_charger *charger,
75 					   union power_supply_propval *val)
76 {
77 	int i_val, ret;
78 
79 	/* Read processed value - mA units */
80 	ret = iio_read_channel_processed(charger->ibus_chan, &i_val);
81 	if (ret < 0)
82 		return ret;
83 
84 	/* Convert current to expected uA units */
85 	val->intval = i_val * 1000;
86 
87 	return 0;
88 }
89 
90 static int da9150_charger_tjunc_temp(struct da9150_charger *charger,
91 				     union power_supply_propval *val)
92 {
93 	int t_val, ret;
94 
95 	/* Read processed value - 0.001 degrees C units */
96 	ret = iio_read_channel_processed(charger->tjunc_chan, &t_val);
97 	if (ret < 0)
98 		return ret;
99 
100 	/* Convert temp to expect 0.1 degrees C units */
101 	val->intval = t_val / 100;
102 
103 	return 0;
104 }
105 
106 static enum power_supply_property da9150_charger_props[] = {
107 	POWER_SUPPLY_PROP_ONLINE,
108 	POWER_SUPPLY_PROP_VOLTAGE_NOW,
109 	POWER_SUPPLY_PROP_CURRENT_AVG,
110 	POWER_SUPPLY_PROP_TEMP,
111 };
112 
113 static int da9150_charger_get_prop(struct power_supply *psy,
114 				   enum power_supply_property psp,
115 				   union power_supply_propval *val)
116 {
117 	struct da9150_charger *charger = dev_get_drvdata(psy->dev.parent);
118 	int ret;
119 
120 	switch (psp) {
121 	case POWER_SUPPLY_PROP_ONLINE:
122 		ret = da9150_charger_supply_online(charger, psy, val);
123 		break;
124 	case POWER_SUPPLY_PROP_VOLTAGE_NOW:
125 		ret = da9150_charger_vbus_voltage_now(charger, val);
126 		break;
127 	case POWER_SUPPLY_PROP_CURRENT_AVG:
128 		ret = da9150_charger_ibus_current_avg(charger, val);
129 		break;
130 	case POWER_SUPPLY_PROP_TEMP:
131 		ret = da9150_charger_tjunc_temp(charger, val);
132 		break;
133 	default:
134 		ret = -EINVAL;
135 		break;
136 	}
137 
138 	return ret;
139 }
140 
141 /* Battery Properties */
142 static int da9150_charger_battery_status(struct da9150_charger *charger,
143 					 union power_supply_propval *val)
144 {
145 	u8 reg;
146 
147 	/* Check to see if battery is discharging */
148 	reg = da9150_reg_read(charger->da9150, DA9150_STATUS_H);
149 
150 	if (((reg & DA9150_VBUS_STAT_MASK) == DA9150_VBUS_STAT_OFF) ||
151 	    ((reg & DA9150_VBUS_STAT_MASK) == DA9150_VBUS_STAT_WAIT)) {
152 		val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
153 
154 		return 0;
155 	}
156 
157 	reg = da9150_reg_read(charger->da9150, DA9150_STATUS_J);
158 
159 	/* Now check for other states */
160 	switch (reg & DA9150_CHG_STAT_MASK) {
161 	case DA9150_CHG_STAT_ACT:
162 	case DA9150_CHG_STAT_PRE:
163 	case DA9150_CHG_STAT_CC:
164 	case DA9150_CHG_STAT_CV:
165 		val->intval = POWER_SUPPLY_STATUS_CHARGING;
166 		break;
167 	case DA9150_CHG_STAT_OFF:
168 	case DA9150_CHG_STAT_SUSP:
169 	case DA9150_CHG_STAT_TEMP:
170 	case DA9150_CHG_STAT_TIME:
171 	case DA9150_CHG_STAT_BAT:
172 		val->intval = POWER_SUPPLY_STATUS_NOT_CHARGING;
173 		break;
174 	case DA9150_CHG_STAT_FULL:
175 		val->intval = POWER_SUPPLY_STATUS_FULL;
176 		break;
177 	default:
178 		val->intval = POWER_SUPPLY_STATUS_UNKNOWN;
179 		break;
180 	}
181 
182 	return 0;
183 }
184 
185 static int da9150_charger_battery_health(struct da9150_charger *charger,
186 					 union power_supply_propval *val)
187 {
188 	u8 reg;
189 
190 	reg = da9150_reg_read(charger->da9150, DA9150_STATUS_J);
191 
192 	/* Check if temperature limit reached */
193 	switch (reg & DA9150_CHG_TEMP_MASK) {
194 	case DA9150_CHG_TEMP_UNDER:
195 		val->intval = POWER_SUPPLY_HEALTH_COLD;
196 		return 0;
197 	case DA9150_CHG_TEMP_OVER:
198 		val->intval = POWER_SUPPLY_HEALTH_OVERHEAT;
199 		return 0;
200 	default:
201 		break;
202 	}
203 
204 	/* Check for other health states */
205 	switch (reg & DA9150_CHG_STAT_MASK) {
206 	case DA9150_CHG_STAT_ACT:
207 	case DA9150_CHG_STAT_PRE:
208 		val->intval = POWER_SUPPLY_HEALTH_DEAD;
209 		break;
210 	case DA9150_CHG_STAT_TIME:
211 		val->intval = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
212 		break;
213 	default:
214 		val->intval = POWER_SUPPLY_HEALTH_GOOD;
215 		break;
216 	}
217 
218 	return 0;
219 }
220 
221 static int da9150_charger_battery_present(struct da9150_charger *charger,
222 					  union power_supply_propval *val)
223 {
224 	u8 reg;
225 
226 	/* Check if battery present or removed */
227 	reg = da9150_reg_read(charger->da9150, DA9150_STATUS_J);
228 	if ((reg & DA9150_CHG_STAT_MASK) == DA9150_CHG_STAT_BAT)
229 		val->intval = 0;
230 	else
231 		val->intval = 1;
232 
233 	return 0;
234 }
235 
236 static int da9150_charger_battery_charge_type(struct da9150_charger *charger,
237 					      union power_supply_propval *val)
238 {
239 	u8 reg;
240 
241 	reg = da9150_reg_read(charger->da9150, DA9150_STATUS_J);
242 
243 	switch (reg & DA9150_CHG_STAT_MASK) {
244 	case DA9150_CHG_STAT_CC:
245 		val->intval = POWER_SUPPLY_CHARGE_TYPE_FAST;
246 		break;
247 	case DA9150_CHG_STAT_ACT:
248 	case DA9150_CHG_STAT_PRE:
249 	case DA9150_CHG_STAT_CV:
250 		val->intval = POWER_SUPPLY_CHARGE_TYPE_TRICKLE;
251 		break;
252 	default:
253 		val->intval = POWER_SUPPLY_CHARGE_TYPE_NONE;
254 		break;
255 	}
256 
257 	return 0;
258 }
259 
260 static int da9150_charger_battery_voltage_min(struct da9150_charger *charger,
261 					      union power_supply_propval *val)
262 {
263 	u8 reg;
264 
265 	reg = da9150_reg_read(charger->da9150, DA9150_PPR_CHGCTRL_C);
266 
267 	/* Value starts at 2500 mV, 50 mV increments, presented in uV */
268 	val->intval = ((reg & DA9150_CHG_VFAULT_MASK) * 50000) + 2500000;
269 
270 	return 0;
271 }
272 
273 static int da9150_charger_battery_voltage_now(struct da9150_charger *charger,
274 					      union power_supply_propval *val)
275 {
276 	int v_val, ret;
277 
278 	/* Read processed value - mV units */
279 	ret = iio_read_channel_processed(charger->vbat_chan, &v_val);
280 	if (ret < 0)
281 		return ret;
282 
283 	val->intval = v_val * 1000;
284 
285 	return 0;
286 }
287 
288 static int da9150_charger_battery_current_max(struct da9150_charger *charger,
289 					      union power_supply_propval *val)
290 {
291 	int reg;
292 
293 	reg = da9150_reg_read(charger->da9150, DA9150_PPR_CHGCTRL_D);
294 
295 	/* 25mA increments */
296 	val->intval = reg * 25000;
297 
298 	return 0;
299 }
300 
301 static int da9150_charger_battery_voltage_max(struct da9150_charger *charger,
302 					      union power_supply_propval *val)
303 {
304 	u8 reg;
305 
306 	reg = da9150_reg_read(charger->da9150, DA9150_PPR_CHGCTRL_B);
307 
308 	/* Value starts at 3650 mV, 25 mV increments, presented in uV */
309 	val->intval = ((reg & DA9150_CHG_VBAT_MASK) * 25000) + 3650000;
310 	return 0;
311 }
312 
313 static enum power_supply_property da9150_charger_bat_props[] = {
314 	POWER_SUPPLY_PROP_STATUS,
315 	POWER_SUPPLY_PROP_ONLINE,
316 	POWER_SUPPLY_PROP_HEALTH,
317 	POWER_SUPPLY_PROP_PRESENT,
318 	POWER_SUPPLY_PROP_CHARGE_TYPE,
319 	POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
320 	POWER_SUPPLY_PROP_VOLTAGE_NOW,
321 	POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX,
322 	POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX,
323 };
324 
325 static int da9150_charger_battery_get_prop(struct power_supply *psy,
326 					   enum power_supply_property psp,
327 					   union power_supply_propval *val)
328 {
329 	struct da9150_charger *charger = dev_get_drvdata(psy->dev.parent);
330 	int ret;
331 
332 	switch (psp) {
333 	case POWER_SUPPLY_PROP_STATUS:
334 		ret = da9150_charger_battery_status(charger, val);
335 		break;
336 	case POWER_SUPPLY_PROP_ONLINE:
337 		ret = da9150_charger_supply_online(charger, psy, val);
338 		break;
339 	case POWER_SUPPLY_PROP_HEALTH:
340 		ret = da9150_charger_battery_health(charger, val);
341 		break;
342 	case POWER_SUPPLY_PROP_PRESENT:
343 		ret = da9150_charger_battery_present(charger, val);
344 		break;
345 	case POWER_SUPPLY_PROP_CHARGE_TYPE:
346 		ret = da9150_charger_battery_charge_type(charger, val);
347 		break;
348 	case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN:
349 		ret = da9150_charger_battery_voltage_min(charger, val);
350 		break;
351 	case POWER_SUPPLY_PROP_VOLTAGE_NOW:
352 		ret = da9150_charger_battery_voltage_now(charger, val);
353 		break;
354 	case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX:
355 		ret = da9150_charger_battery_current_max(charger, val);
356 		break;
357 	case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX:
358 		ret = da9150_charger_battery_voltage_max(charger, val);
359 		break;
360 	default:
361 		ret = -EINVAL;
362 		break;
363 	}
364 
365 	return ret;
366 }
367 
368 static irqreturn_t da9150_charger_chg_irq(int irq, void *data)
369 {
370 	struct da9150_charger *charger = data;
371 
372 	power_supply_changed(charger->battery);
373 
374 	return IRQ_HANDLED;
375 }
376 
377 static irqreturn_t da9150_charger_tjunc_irq(int irq, void *data)
378 {
379 	struct da9150_charger *charger = data;
380 
381 	/* Nothing we can really do except report this. */
382 	dev_crit(charger->dev, "TJunc over temperature!!!\n");
383 	power_supply_changed(charger->usb);
384 
385 	return IRQ_HANDLED;
386 }
387 
388 static irqreturn_t da9150_charger_vfault_irq(int irq, void *data)
389 {
390 	struct da9150_charger *charger = data;
391 
392 	/* Nothing we can really do except report this. */
393 	dev_crit(charger->dev, "VSYS under voltage!!!\n");
394 	power_supply_changed(charger->usb);
395 	power_supply_changed(charger->battery);
396 
397 	return IRQ_HANDLED;
398 }
399 
400 static irqreturn_t da9150_charger_vbus_irq(int irq, void *data)
401 {
402 	struct da9150_charger *charger = data;
403 	u8 reg;
404 
405 	reg = da9150_reg_read(charger->da9150, DA9150_STATUS_H);
406 
407 	/* Charger plugged in or battery only */
408 	switch (reg & DA9150_VBUS_STAT_MASK) {
409 	case DA9150_VBUS_STAT_OFF:
410 	case DA9150_VBUS_STAT_WAIT:
411 		charger->supply_online = charger->battery;
412 		break;
413 	case DA9150_VBUS_STAT_CHG:
414 		charger->supply_online = charger->usb;
415 		break;
416 	default:
417 		dev_warn(charger->dev, "Unknown VBUS state - reg = 0x%x\n",
418 			 reg);
419 		charger->supply_online = NULL;
420 		break;
421 	}
422 
423 	power_supply_changed(charger->usb);
424 	power_supply_changed(charger->battery);
425 
426 	return IRQ_HANDLED;
427 }
428 
429 static void da9150_charger_otg_work(struct work_struct *data)
430 {
431 	struct da9150_charger *charger =
432 		container_of(data, struct da9150_charger, otg_work);
433 
434 	switch (charger->usb_event) {
435 	case USB_EVENT_ID:
436 		/* Enable OTG Boost */
437 		da9150_set_bits(charger->da9150, DA9150_PPR_BKCTRL_A,
438 				DA9150_VBUS_MODE_MASK, DA9150_VBUS_MODE_OTG);
439 		break;
440 	case USB_EVENT_NONE:
441 		/* Revert to charge mode */
442 		power_supply_changed(charger->usb);
443 		power_supply_changed(charger->battery);
444 		da9150_set_bits(charger->da9150, DA9150_PPR_BKCTRL_A,
445 				DA9150_VBUS_MODE_MASK, DA9150_VBUS_MODE_CHG);
446 		break;
447 	}
448 }
449 
450 static int da9150_charger_otg_ncb(struct notifier_block *nb, unsigned long val,
451 				  void *priv)
452 {
453 	struct da9150_charger *charger =
454 		container_of(nb, struct da9150_charger, otg_nb);
455 
456 	dev_dbg(charger->dev, "DA9150 OTG notify %lu\n", val);
457 
458 	charger->usb_event = val;
459 	schedule_work(&charger->otg_work);
460 
461 	return NOTIFY_OK;
462 }
463 
464 static int da9150_charger_register_irq(struct platform_device *pdev,
465 				       irq_handler_t handler,
466 				       const char *irq_name)
467 {
468 	struct device *dev = &pdev->dev;
469 	struct da9150_charger *charger = platform_get_drvdata(pdev);
470 	int irq, ret;
471 
472 	irq = platform_get_irq_byname(pdev, irq_name);
473 	if (irq < 0) {
474 		dev_err(dev, "Failed to get IRQ CHG_STATUS: %d\n", irq);
475 		return irq;
476 	}
477 
478 	ret = request_threaded_irq(irq, NULL, handler, IRQF_ONESHOT, irq_name,
479 				   charger);
480 	if (ret)
481 		dev_err(dev, "Failed to request IRQ %d: %d\n", irq, ret);
482 
483 	return ret;
484 }
485 
486 static void da9150_charger_unregister_irq(struct platform_device *pdev,
487 					  const char *irq_name)
488 {
489 	struct device *dev = &pdev->dev;
490 	struct da9150_charger *charger = platform_get_drvdata(pdev);
491 	int irq;
492 
493 	irq = platform_get_irq_byname(pdev, irq_name);
494 	if (irq < 0) {
495 		dev_err(dev, "Failed to get IRQ CHG_STATUS: %d\n", irq);
496 		return;
497 	}
498 
499 	free_irq(irq, charger);
500 }
501 
502 static const struct power_supply_desc usb_desc = {
503 	.name		= "da9150-usb",
504 	.type		= POWER_SUPPLY_TYPE_USB,
505 	.properties	= da9150_charger_props,
506 	.num_properties	= ARRAY_SIZE(da9150_charger_props),
507 	.get_property	= da9150_charger_get_prop,
508 };
509 
510 static const struct power_supply_desc battery_desc = {
511 	.name		= "da9150-battery",
512 	.type		= POWER_SUPPLY_TYPE_BATTERY,
513 	.properties	= da9150_charger_bat_props,
514 	.num_properties	= ARRAY_SIZE(da9150_charger_bat_props),
515 	.get_property	= da9150_charger_battery_get_prop,
516 };
517 
518 static int da9150_charger_probe(struct platform_device *pdev)
519 {
520 	struct device *dev = &pdev->dev;
521 	struct da9150 *da9150 = dev_get_drvdata(dev->parent);
522 	struct da9150_charger *charger;
523 	u8 reg;
524 	int ret;
525 
526 	charger = devm_kzalloc(dev, sizeof(struct da9150_charger), GFP_KERNEL);
527 	if (!charger)
528 		return -ENOMEM;
529 
530 	platform_set_drvdata(pdev, charger);
531 	charger->da9150 = da9150;
532 	charger->dev = dev;
533 
534 	/* Acquire ADC channels */
535 	charger->ibus_chan = iio_channel_get(dev, "CHAN_IBUS");
536 	if (IS_ERR(charger->ibus_chan)) {
537 		ret = PTR_ERR(charger->ibus_chan);
538 		goto ibus_chan_fail;
539 	}
540 
541 	charger->vbus_chan = iio_channel_get(dev, "CHAN_VBUS");
542 	if (IS_ERR(charger->vbus_chan)) {
543 		ret = PTR_ERR(charger->vbus_chan);
544 		goto vbus_chan_fail;
545 	}
546 
547 	charger->tjunc_chan = iio_channel_get(dev, "CHAN_TJUNC");
548 	if (IS_ERR(charger->tjunc_chan)) {
549 		ret = PTR_ERR(charger->tjunc_chan);
550 		goto tjunc_chan_fail;
551 	}
552 
553 	charger->vbat_chan = iio_channel_get(dev, "CHAN_VBAT");
554 	if (IS_ERR(charger->vbat_chan)) {
555 		ret = PTR_ERR(charger->vbat_chan);
556 		goto vbat_chan_fail;
557 	}
558 
559 	/* Register power supplies */
560 	charger->usb = power_supply_register(dev, &usb_desc, NULL);
561 	if (IS_ERR(charger->usb)) {
562 		ret = PTR_ERR(charger->usb);
563 		goto usb_fail;
564 	}
565 
566 	charger->battery = power_supply_register(dev, &battery_desc, NULL);
567 	if (IS_ERR(charger->battery)) {
568 		ret = PTR_ERR(charger->battery);
569 		goto battery_fail;
570 	}
571 
572 	/* Get initial online supply */
573 	reg = da9150_reg_read(da9150, DA9150_STATUS_H);
574 
575 	switch (reg & DA9150_VBUS_STAT_MASK) {
576 	case DA9150_VBUS_STAT_OFF:
577 	case DA9150_VBUS_STAT_WAIT:
578 		charger->supply_online = charger->battery;
579 		break;
580 	case DA9150_VBUS_STAT_CHG:
581 		charger->supply_online = charger->usb;
582 		break;
583 	default:
584 		dev_warn(dev, "Unknown VBUS state - reg = 0x%x\n", reg);
585 		charger->supply_online = NULL;
586 		break;
587 	}
588 
589 	/* Setup OTG reporting & configuration */
590 	charger->usb_phy = devm_usb_get_phy(dev, USB_PHY_TYPE_USB2);
591 	if (!IS_ERR_OR_NULL(charger->usb_phy)) {
592 		INIT_WORK(&charger->otg_work, da9150_charger_otg_work);
593 		charger->otg_nb.notifier_call = da9150_charger_otg_ncb;
594 		usb_register_notifier(charger->usb_phy, &charger->otg_nb);
595 	}
596 
597 	/* Register IRQs */
598 	ret = da9150_charger_register_irq(pdev, da9150_charger_chg_irq,
599 					  "CHG_STATUS");
600 	if (ret < 0)
601 		goto chg_irq_fail;
602 
603 	ret = da9150_charger_register_irq(pdev, da9150_charger_tjunc_irq,
604 					  "CHG_TJUNC");
605 	if (ret < 0)
606 		goto tjunc_irq_fail;
607 
608 	ret = da9150_charger_register_irq(pdev, da9150_charger_vfault_irq,
609 					  "CHG_VFAULT");
610 	if (ret < 0)
611 		goto vfault_irq_fail;
612 
613 	ret = da9150_charger_register_irq(pdev, da9150_charger_vbus_irq,
614 					  "CHG_VBUS");
615 	if (ret < 0)
616 		goto vbus_irq_fail;
617 
618 	return 0;
619 
620 
621 vbus_irq_fail:
622 	da9150_charger_unregister_irq(pdev, "CHG_VFAULT");
623 vfault_irq_fail:
624 	da9150_charger_unregister_irq(pdev, "CHG_TJUNC");
625 tjunc_irq_fail:
626 	da9150_charger_unregister_irq(pdev, "CHG_STATUS");
627 chg_irq_fail:
628 	if (!IS_ERR_OR_NULL(charger->usb_phy))
629 		usb_unregister_notifier(charger->usb_phy, &charger->otg_nb);
630 battery_fail:
631 	power_supply_unregister(charger->usb);
632 
633 usb_fail:
634 	iio_channel_release(charger->vbat_chan);
635 
636 vbat_chan_fail:
637 	iio_channel_release(charger->tjunc_chan);
638 
639 tjunc_chan_fail:
640 	iio_channel_release(charger->vbus_chan);
641 
642 vbus_chan_fail:
643 	iio_channel_release(charger->ibus_chan);
644 
645 ibus_chan_fail:
646 	return ret;
647 }
648 
649 static int da9150_charger_remove(struct platform_device *pdev)
650 {
651 	struct da9150_charger *charger = platform_get_drvdata(pdev);
652 	int irq;
653 
654 	/* Make sure IRQs are released before unregistering power supplies */
655 	irq = platform_get_irq_byname(pdev, "CHG_VBUS");
656 	free_irq(irq, charger);
657 
658 	irq = platform_get_irq_byname(pdev, "CHG_VFAULT");
659 	free_irq(irq, charger);
660 
661 	irq = platform_get_irq_byname(pdev, "CHG_TJUNC");
662 	free_irq(irq, charger);
663 
664 	irq = platform_get_irq_byname(pdev, "CHG_STATUS");
665 	free_irq(irq, charger);
666 
667 	if (!IS_ERR_OR_NULL(charger->usb_phy))
668 		usb_unregister_notifier(charger->usb_phy, &charger->otg_nb);
669 
670 	power_supply_unregister(charger->battery);
671 	power_supply_unregister(charger->usb);
672 
673 	/* Release ADC channels */
674 	iio_channel_release(charger->ibus_chan);
675 	iio_channel_release(charger->vbus_chan);
676 	iio_channel_release(charger->tjunc_chan);
677 	iio_channel_release(charger->vbat_chan);
678 
679 	return 0;
680 }
681 
682 static struct platform_driver da9150_charger_driver = {
683 	.driver = {
684 		.name = "da9150-charger",
685 	},
686 	.probe = da9150_charger_probe,
687 	.remove = da9150_charger_remove,
688 };
689 
690 module_platform_driver(da9150_charger_driver);
691 
692 MODULE_DESCRIPTION("Charger Driver for DA9150");
693 MODULE_AUTHOR("Adam Thomson <Adam.Thomson.Opensource@diasemi.com>");
694 MODULE_LICENSE("GPL");
695