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