1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * Power supply driver for the Active-semi ACT8945A PMIC
4  *
5  * Copyright (C) 2015 Atmel Corporation
6  *
7  * Author: Wenyou Yang <wenyou.yang@atmel.com>
8  */
9 #include <linux/interrupt.h>
10 #include <linux/module.h>
11 #include <linux/of.h>
12 #include <linux/of_irq.h>
13 #include <linux/platform_device.h>
14 #include <linux/power_supply.h>
15 #include <linux/regmap.h>
16 #include <linux/gpio/consumer.h>
17 
18 static const char *act8945a_charger_model = "ACT8945A";
19 static const char *act8945a_charger_manufacturer = "Active-semi";
20 
21 /*
22  * ACT8945A Charger Register Map
23  */
24 
25 /* 0x70: Reserved */
26 #define ACT8945A_APCH_CFG		0x71
27 #define ACT8945A_APCH_STATUS		0x78
28 #define ACT8945A_APCH_CTRL		0x79
29 #define ACT8945A_APCH_STATE		0x7A
30 
31 /* ACT8945A_APCH_CFG */
32 #define APCH_CFG_OVPSET			(0x3 << 0)
33 #define APCH_CFG_OVPSET_6V6		(0x0 << 0)
34 #define APCH_CFG_OVPSET_7V		(0x1 << 0)
35 #define APCH_CFG_OVPSET_7V5		(0x2 << 0)
36 #define APCH_CFG_OVPSET_8V		(0x3 << 0)
37 #define APCH_CFG_PRETIMO		(0x3 << 2)
38 #define APCH_CFG_PRETIMO_40_MIN		(0x0 << 2)
39 #define APCH_CFG_PRETIMO_60_MIN		(0x1 << 2)
40 #define APCH_CFG_PRETIMO_80_MIN		(0x2 << 2)
41 #define APCH_CFG_PRETIMO_DISABLED	(0x3 << 2)
42 #define APCH_CFG_TOTTIMO		(0x3 << 4)
43 #define APCH_CFG_TOTTIMO_3_HOUR		(0x0 << 4)
44 #define APCH_CFG_TOTTIMO_4_HOUR		(0x1 << 4)
45 #define APCH_CFG_TOTTIMO_5_HOUR		(0x2 << 4)
46 #define APCH_CFG_TOTTIMO_DISABLED	(0x3 << 4)
47 #define APCH_CFG_SUSCHG			(0x1 << 7)
48 
49 #define APCH_STATUS_CHGDAT		BIT(0)
50 #define APCH_STATUS_INDAT		BIT(1)
51 #define APCH_STATUS_TEMPDAT		BIT(2)
52 #define APCH_STATUS_TIMRDAT		BIT(3)
53 #define APCH_STATUS_CHGSTAT		BIT(4)
54 #define APCH_STATUS_INSTAT		BIT(5)
55 #define APCH_STATUS_TEMPSTAT		BIT(6)
56 #define APCH_STATUS_TIMRSTAT		BIT(7)
57 
58 #define APCH_CTRL_CHGEOCOUT		BIT(0)
59 #define APCH_CTRL_INDIS			BIT(1)
60 #define APCH_CTRL_TEMPOUT		BIT(2)
61 #define APCH_CTRL_TIMRPRE		BIT(3)
62 #define APCH_CTRL_CHGEOCIN		BIT(4)
63 #define APCH_CTRL_INCON			BIT(5)
64 #define APCH_CTRL_TEMPIN		BIT(6)
65 #define APCH_CTRL_TIMRTOT		BIT(7)
66 
67 #define APCH_STATE_ACINSTAT		(0x1 << 1)
68 #define APCH_STATE_CSTATE		(0x3 << 4)
69 #define APCH_STATE_CSTATE_SHIFT		4
70 #define APCH_STATE_CSTATE_DISABLED	0x00
71 #define APCH_STATE_CSTATE_EOC		0x01
72 #define APCH_STATE_CSTATE_FAST		0x02
73 #define APCH_STATE_CSTATE_PRE		0x03
74 
75 struct act8945a_charger {
76 	struct power_supply *psy;
77 	struct power_supply_desc desc;
78 	struct regmap *regmap;
79 	struct work_struct work;
80 
81 	bool init_done;
82 	struct gpio_desc *lbo_gpio;
83 	struct gpio_desc *chglev_gpio;
84 };
85 
86 static int act8945a_get_charger_state(struct regmap *regmap, int *val)
87 {
88 	int ret;
89 	unsigned int status, state;
90 
91 	ret = regmap_read(regmap, ACT8945A_APCH_STATUS, &status);
92 	if (ret < 0)
93 		return ret;
94 
95 	ret = regmap_read(regmap, ACT8945A_APCH_STATE, &state);
96 	if (ret < 0)
97 		return ret;
98 
99 	state &= APCH_STATE_CSTATE;
100 	state >>= APCH_STATE_CSTATE_SHIFT;
101 
102 	switch (state) {
103 	case APCH_STATE_CSTATE_PRE:
104 	case APCH_STATE_CSTATE_FAST:
105 		*val = POWER_SUPPLY_STATUS_CHARGING;
106 		break;
107 	case APCH_STATE_CSTATE_EOC:
108 		if (status & APCH_STATUS_CHGDAT)
109 			*val = POWER_SUPPLY_STATUS_FULL;
110 		else
111 			*val = POWER_SUPPLY_STATUS_CHARGING;
112 		break;
113 	case APCH_STATE_CSTATE_DISABLED:
114 	default:
115 		if (!(status & APCH_STATUS_INDAT))
116 			*val = POWER_SUPPLY_STATUS_DISCHARGING;
117 		else
118 			*val = POWER_SUPPLY_STATUS_NOT_CHARGING;
119 		break;
120 	}
121 
122 	return 0;
123 }
124 
125 static int act8945a_get_charge_type(struct regmap *regmap, int *val)
126 {
127 	int ret;
128 	unsigned int status, state;
129 
130 	ret = regmap_read(regmap, ACT8945A_APCH_STATUS, &status);
131 	if (ret < 0)
132 		return ret;
133 
134 	ret = regmap_read(regmap, ACT8945A_APCH_STATE, &state);
135 	if (ret < 0)
136 		return ret;
137 
138 	state &= APCH_STATE_CSTATE;
139 	state >>= APCH_STATE_CSTATE_SHIFT;
140 
141 	switch (state) {
142 	case APCH_STATE_CSTATE_PRE:
143 		*val = POWER_SUPPLY_CHARGE_TYPE_TRICKLE;
144 		break;
145 	case APCH_STATE_CSTATE_FAST:
146 		*val = POWER_SUPPLY_CHARGE_TYPE_FAST;
147 		break;
148 	case APCH_STATE_CSTATE_EOC:
149 		*val = POWER_SUPPLY_CHARGE_TYPE_NONE;
150 		break;
151 	case APCH_STATE_CSTATE_DISABLED:
152 	default:
153 		if (!(status & APCH_STATUS_INDAT))
154 			*val = POWER_SUPPLY_CHARGE_TYPE_NONE;
155 		else
156 			*val = POWER_SUPPLY_CHARGE_TYPE_UNKNOWN;
157 		break;
158 	}
159 
160 	return 0;
161 }
162 
163 static int act8945a_get_battery_health(struct regmap *regmap, int *val)
164 {
165 	int ret;
166 	unsigned int status, state, config;
167 
168 	ret = regmap_read(regmap, ACT8945A_APCH_STATUS, &status);
169 	if (ret < 0)
170 		return ret;
171 
172 	ret = regmap_read(regmap, ACT8945A_APCH_CFG, &config);
173 	if (ret < 0)
174 		return ret;
175 
176 	ret = regmap_read(regmap, ACT8945A_APCH_STATE, &state);
177 	if (ret < 0)
178 		return ret;
179 
180 	state &= APCH_STATE_CSTATE;
181 	state >>= APCH_STATE_CSTATE_SHIFT;
182 
183 	switch (state) {
184 	case APCH_STATE_CSTATE_DISABLED:
185 		if (config & APCH_CFG_SUSCHG) {
186 			*val = POWER_SUPPLY_HEALTH_UNKNOWN;
187 		} else if (status & APCH_STATUS_INDAT) {
188 			if (!(status & APCH_STATUS_TEMPDAT))
189 				*val = POWER_SUPPLY_HEALTH_OVERHEAT;
190 			else if (status & APCH_STATUS_TIMRDAT)
191 				*val = POWER_SUPPLY_HEALTH_SAFETY_TIMER_EXPIRE;
192 			else
193 				*val = POWER_SUPPLY_HEALTH_OVERVOLTAGE;
194 		} else {
195 			*val = POWER_SUPPLY_HEALTH_GOOD;
196 		}
197 		break;
198 	case APCH_STATE_CSTATE_PRE:
199 	case APCH_STATE_CSTATE_FAST:
200 	case APCH_STATE_CSTATE_EOC:
201 	default:
202 		*val = POWER_SUPPLY_HEALTH_GOOD;
203 		break;
204 	}
205 
206 	return 0;
207 }
208 
209 static int act8945a_get_capacity_level(struct act8945a_charger *charger,
210 				       struct regmap *regmap, int *val)
211 {
212 	int ret;
213 	unsigned int status, state, config;
214 	int lbo_level = gpiod_get_value(charger->lbo_gpio);
215 
216 	ret = regmap_read(regmap, ACT8945A_APCH_STATUS, &status);
217 	if (ret < 0)
218 		return ret;
219 
220 	ret = regmap_read(regmap, ACT8945A_APCH_CFG, &config);
221 	if (ret < 0)
222 		return ret;
223 
224 	ret = regmap_read(regmap, ACT8945A_APCH_STATE, &state);
225 	if (ret < 0)
226 		return ret;
227 
228 	state &= APCH_STATE_CSTATE;
229 	state >>= APCH_STATE_CSTATE_SHIFT;
230 
231 	switch (state) {
232 	case APCH_STATE_CSTATE_PRE:
233 		*val = POWER_SUPPLY_CAPACITY_LEVEL_LOW;
234 		break;
235 	case APCH_STATE_CSTATE_FAST:
236 		if (lbo_level)
237 			*val = POWER_SUPPLY_CAPACITY_LEVEL_HIGH;
238 		else
239 			*val = POWER_SUPPLY_CAPACITY_LEVEL_LOW;
240 		break;
241 	case APCH_STATE_CSTATE_EOC:
242 		if (status & APCH_STATUS_CHGDAT)
243 			*val = POWER_SUPPLY_CAPACITY_LEVEL_FULL;
244 		else
245 			*val = POWER_SUPPLY_CAPACITY_LEVEL_NORMAL;
246 		break;
247 	case APCH_STATE_CSTATE_DISABLED:
248 	default:
249 		if (config & APCH_CFG_SUSCHG) {
250 			*val = POWER_SUPPLY_CAPACITY_LEVEL_UNKNOWN;
251 		} else {
252 			*val = POWER_SUPPLY_CAPACITY_LEVEL_NORMAL;
253 			if (!(status & APCH_STATUS_INDAT)) {
254 				if (!lbo_level)
255 					*val = POWER_SUPPLY_CAPACITY_LEVEL_CRITICAL;
256 			}
257 		}
258 		break;
259 	}
260 
261 	return 0;
262 }
263 
264 #define MAX_CURRENT_USB_HIGH	450000
265 #define MAX_CURRENT_USB_LOW	90000
266 #define MAX_CURRENT_USB_PRE	45000
267 /*
268  * Riset(K) = 2336 * (1V/Ichg(mA)) - 0.205
269  * Riset = 2.43K
270  */
271 #define MAX_CURRENT_AC_HIGH		886527
272 #define MAX_CURRENT_AC_LOW		117305
273 #define MAX_CURRENT_AC_HIGH_PRE		88653
274 #define MAX_CURRENT_AC_LOW_PRE		11731
275 
276 static int act8945a_get_current_max(struct act8945a_charger *charger,
277 				    struct regmap *regmap, int *val)
278 {
279 	int ret;
280 	unsigned int status, state;
281 	unsigned int acin_state;
282 	int chgin_level = gpiod_get_value(charger->chglev_gpio);
283 
284 	ret = regmap_read(regmap, ACT8945A_APCH_STATUS, &status);
285 	if (ret < 0)
286 		return ret;
287 
288 	ret = regmap_read(regmap, ACT8945A_APCH_STATE, &state);
289 	if (ret < 0)
290 		return ret;
291 
292 	acin_state = (state & APCH_STATE_ACINSTAT) >> 1;
293 
294 	state &= APCH_STATE_CSTATE;
295 	state >>= APCH_STATE_CSTATE_SHIFT;
296 
297 	switch (state) {
298 	case APCH_STATE_CSTATE_PRE:
299 		if (acin_state) {
300 			if (chgin_level)
301 				*val = MAX_CURRENT_AC_HIGH_PRE;
302 			else
303 				*val = MAX_CURRENT_AC_LOW_PRE;
304 		} else {
305 			*val = MAX_CURRENT_USB_PRE;
306 		}
307 		break;
308 	case APCH_STATE_CSTATE_FAST:
309 		if (acin_state) {
310 			if (chgin_level)
311 				*val = MAX_CURRENT_AC_HIGH;
312 			else
313 				*val = MAX_CURRENT_AC_LOW;
314 		} else {
315 			if (chgin_level)
316 				*val = MAX_CURRENT_USB_HIGH;
317 			else
318 				*val = MAX_CURRENT_USB_LOW;
319 		}
320 		break;
321 	case APCH_STATE_CSTATE_EOC:
322 	case APCH_STATE_CSTATE_DISABLED:
323 	default:
324 		*val = 0;
325 		break;
326 	}
327 
328 	return 0;
329 }
330 
331 static enum power_supply_property act8945a_charger_props[] = {
332 	POWER_SUPPLY_PROP_STATUS,
333 	POWER_SUPPLY_PROP_CHARGE_TYPE,
334 	POWER_SUPPLY_PROP_TECHNOLOGY,
335 	POWER_SUPPLY_PROP_HEALTH,
336 	POWER_SUPPLY_PROP_CAPACITY_LEVEL,
337 	POWER_SUPPLY_PROP_CURRENT_MAX,
338 	POWER_SUPPLY_PROP_MODEL_NAME,
339 	POWER_SUPPLY_PROP_MANUFACTURER
340 };
341 
342 static int act8945a_charger_get_property(struct power_supply *psy,
343 					 enum power_supply_property prop,
344 					 union power_supply_propval *val)
345 {
346 	struct act8945a_charger *charger = power_supply_get_drvdata(psy);
347 	struct regmap *regmap = charger->regmap;
348 	int ret = 0;
349 
350 	switch (prop) {
351 	case POWER_SUPPLY_PROP_STATUS:
352 		ret = act8945a_get_charger_state(regmap, &val->intval);
353 		break;
354 	case POWER_SUPPLY_PROP_CHARGE_TYPE:
355 		ret = act8945a_get_charge_type(regmap, &val->intval);
356 		break;
357 	case POWER_SUPPLY_PROP_TECHNOLOGY:
358 		val->intval = POWER_SUPPLY_TECHNOLOGY_LION;
359 		break;
360 	case POWER_SUPPLY_PROP_HEALTH:
361 		ret = act8945a_get_battery_health(regmap, &val->intval);
362 		break;
363 	case POWER_SUPPLY_PROP_CAPACITY_LEVEL:
364 		ret = act8945a_get_capacity_level(charger,
365 						  regmap, &val->intval);
366 		break;
367 	case POWER_SUPPLY_PROP_CURRENT_MAX:
368 		ret = act8945a_get_current_max(charger,
369 					       regmap, &val->intval);
370 		break;
371 	case POWER_SUPPLY_PROP_MODEL_NAME:
372 		val->strval = act8945a_charger_model;
373 		break;
374 	case POWER_SUPPLY_PROP_MANUFACTURER:
375 		val->strval = act8945a_charger_manufacturer;
376 		break;
377 	default:
378 		return -EINVAL;
379 	}
380 
381 	return ret;
382 }
383 
384 static int act8945a_enable_interrupt(struct act8945a_charger *charger)
385 {
386 	struct regmap *regmap = charger->regmap;
387 	unsigned char ctrl;
388 	int ret;
389 
390 	ctrl = APCH_CTRL_CHGEOCOUT | APCH_CTRL_CHGEOCIN |
391 	       APCH_CTRL_INDIS | APCH_CTRL_INCON |
392 	       APCH_CTRL_TEMPOUT | APCH_CTRL_TEMPIN |
393 	       APCH_CTRL_TIMRPRE | APCH_CTRL_TIMRTOT;
394 	ret = regmap_write(regmap, ACT8945A_APCH_CTRL, ctrl);
395 	if (ret)
396 		return ret;
397 
398 	ctrl = APCH_STATUS_CHGSTAT | APCH_STATUS_INSTAT |
399 	       APCH_STATUS_TEMPSTAT | APCH_STATUS_TIMRSTAT;
400 	ret = regmap_write(regmap, ACT8945A_APCH_STATUS, ctrl);
401 	if (ret)
402 		return ret;
403 
404 	return 0;
405 }
406 
407 static unsigned int act8945a_set_supply_type(struct act8945a_charger *charger,
408 					     unsigned int *type)
409 {
410 	unsigned int status, state;
411 	int ret;
412 
413 	ret = regmap_read(charger->regmap, ACT8945A_APCH_STATUS, &status);
414 	if (ret < 0)
415 		return ret;
416 
417 	ret = regmap_read(charger->regmap, ACT8945A_APCH_STATE, &state);
418 	if (ret < 0)
419 		return ret;
420 
421 	if (status & APCH_STATUS_INDAT) {
422 		if (state & APCH_STATE_ACINSTAT)
423 			*type = POWER_SUPPLY_TYPE_MAINS;
424 		else
425 			*type = POWER_SUPPLY_TYPE_USB;
426 	} else {
427 		*type = POWER_SUPPLY_TYPE_BATTERY;
428 	}
429 
430 	return 0;
431 }
432 
433 static void act8945a_work(struct work_struct *work)
434 {
435 	struct act8945a_charger *charger =
436 			container_of(work, struct act8945a_charger, work);
437 
438 	act8945a_set_supply_type(charger, &charger->desc.type);
439 
440 	power_supply_changed(charger->psy);
441 }
442 
443 static irqreturn_t act8945a_status_changed(int irq, void *dev_id)
444 {
445 	struct act8945a_charger *charger = dev_id;
446 
447 	if (charger->init_done)
448 		schedule_work(&charger->work);
449 
450 	return IRQ_HANDLED;
451 }
452 
453 #define DEFAULT_TOTAL_TIME_OUT		3
454 #define DEFAULT_PRE_TIME_OUT		40
455 #define DEFAULT_INPUT_OVP_THRESHOLD	6600
456 
457 static int act8945a_charger_config(struct device *dev,
458 				   struct act8945a_charger *charger)
459 {
460 	struct device_node *np = dev->of_node;
461 	struct regmap *regmap = charger->regmap;
462 
463 	u32 total_time_out;
464 	u32 pre_time_out;
465 	u32 input_voltage_threshold;
466 	int err, ret;
467 
468 	unsigned int tmp;
469 	unsigned int value = 0;
470 
471 	if (!np) {
472 		dev_err(dev, "no charger of node\n");
473 		return -EINVAL;
474 	}
475 
476 	ret = regmap_read(regmap, ACT8945A_APCH_CFG, &tmp);
477 	if (ret)
478 		return ret;
479 
480 	if (tmp & APCH_CFG_SUSCHG) {
481 		value |= APCH_CFG_SUSCHG;
482 		dev_info(dev, "have been suspended\n");
483 	}
484 
485 	charger->lbo_gpio = devm_gpiod_get_optional(dev, "active-semi,lbo",
486 						    GPIOD_IN);
487 	if (IS_ERR(charger->lbo_gpio)) {
488 		err = PTR_ERR(charger->lbo_gpio);
489 		dev_err(dev, "unable to claim gpio \"lbo\": %d\n", err);
490 		return err;
491 	}
492 
493 	ret = devm_request_irq(dev, gpiod_to_irq(charger->lbo_gpio),
494 			       act8945a_status_changed,
495 			       (IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING),
496 			       "act8945a_lbo_detect", charger);
497 	if (ret)
498 		dev_info(dev, "failed to request gpio \"lbo\" IRQ\n");
499 
500 	charger->chglev_gpio = devm_gpiod_get_optional(dev,
501 						       "active-semi,chglev",
502 						       GPIOD_IN);
503 	if (IS_ERR(charger->chglev_gpio)) {
504 		err = PTR_ERR(charger->chglev_gpio);
505 		dev_err(dev, "unable to claim gpio \"chglev\": %d\n", err);
506 		return err;
507 	}
508 
509 	if (of_property_read_u32(np,
510 				 "active-semi,input-voltage-threshold-microvolt",
511 				 &input_voltage_threshold))
512 		input_voltage_threshold = DEFAULT_INPUT_OVP_THRESHOLD;
513 
514 	if (of_property_read_u32(np,
515 				 "active-semi,precondition-timeout",
516 				 &pre_time_out))
517 		pre_time_out = DEFAULT_PRE_TIME_OUT;
518 
519 	if (of_property_read_u32(np, "active-semi,total-timeout",
520 				 &total_time_out))
521 		total_time_out = DEFAULT_TOTAL_TIME_OUT;
522 
523 	switch (input_voltage_threshold) {
524 	case 8000:
525 		value |= APCH_CFG_OVPSET_8V;
526 		break;
527 	case 7500:
528 		value |= APCH_CFG_OVPSET_7V5;
529 		break;
530 	case 7000:
531 		value |= APCH_CFG_OVPSET_7V;
532 		break;
533 	case 6600:
534 	default:
535 		value |= APCH_CFG_OVPSET_6V6;
536 		break;
537 	}
538 
539 	switch (pre_time_out) {
540 	case 60:
541 		value |= APCH_CFG_PRETIMO_60_MIN;
542 		break;
543 	case 80:
544 		value |= APCH_CFG_PRETIMO_80_MIN;
545 		break;
546 	case 0:
547 		value |= APCH_CFG_PRETIMO_DISABLED;
548 		break;
549 	case 40:
550 	default:
551 		value |= APCH_CFG_PRETIMO_40_MIN;
552 		break;
553 	}
554 
555 	switch (total_time_out) {
556 	case 4:
557 		value |= APCH_CFG_TOTTIMO_4_HOUR;
558 		break;
559 	case 5:
560 		value |= APCH_CFG_TOTTIMO_5_HOUR;
561 		break;
562 	case 0:
563 		value |= APCH_CFG_TOTTIMO_DISABLED;
564 		break;
565 	case 3:
566 	default:
567 		value |= APCH_CFG_TOTTIMO_3_HOUR;
568 		break;
569 	}
570 
571 	return regmap_write(regmap, ACT8945A_APCH_CFG, value);
572 }
573 
574 static int act8945a_charger_probe(struct platform_device *pdev)
575 {
576 	struct act8945a_charger *charger;
577 	struct power_supply_config psy_cfg = {};
578 	int irq, ret;
579 
580 	charger = devm_kzalloc(&pdev->dev, sizeof(*charger), GFP_KERNEL);
581 	if (!charger)
582 		return -ENOMEM;
583 
584 	charger->regmap = dev_get_regmap(pdev->dev.parent, NULL);
585 	if (!charger->regmap) {
586 		dev_err(&pdev->dev, "Parent did not provide regmap\n");
587 		return -EINVAL;
588 	}
589 
590 	ret = act8945a_charger_config(&pdev->dev, charger);
591 	if (ret)
592 		return ret;
593 
594 	irq = of_irq_get(pdev->dev.of_node, 0);
595 	if (irq <= 0) {
596 		dev_err(&pdev->dev, "failed to find IRQ number\n");
597 		return irq ?: -ENXIO;
598 	}
599 
600 	ret = devm_request_irq(&pdev->dev, irq, act8945a_status_changed,
601 			       IRQF_TRIGGER_FALLING, "act8945a_interrupt",
602 			       charger);
603 	if (ret) {
604 		dev_err(&pdev->dev, "failed to request nIRQ pin IRQ\n");
605 		return ret;
606 	}
607 
608 	charger->desc.name = "act8945a-charger";
609 	charger->desc.get_property = act8945a_charger_get_property;
610 	charger->desc.properties = act8945a_charger_props;
611 	charger->desc.num_properties = ARRAY_SIZE(act8945a_charger_props);
612 
613 	ret = act8945a_set_supply_type(charger, &charger->desc.type);
614 	if (ret)
615 		return -EINVAL;
616 
617 	psy_cfg.of_node	= pdev->dev.of_node;
618 	psy_cfg.drv_data = charger;
619 
620 	charger->psy = devm_power_supply_register(&pdev->dev,
621 						  &charger->desc,
622 						  &psy_cfg);
623 	if (IS_ERR(charger->psy)) {
624 		dev_err(&pdev->dev, "failed to register power supply\n");
625 		return PTR_ERR(charger->psy);
626 	}
627 
628 	platform_set_drvdata(pdev, charger);
629 
630 	INIT_WORK(&charger->work, act8945a_work);
631 
632 	ret = act8945a_enable_interrupt(charger);
633 	if (ret)
634 		return -EIO;
635 
636 	charger->init_done = true;
637 
638 	return 0;
639 }
640 
641 static int act8945a_charger_remove(struct platform_device *pdev)
642 {
643 	struct act8945a_charger *charger = platform_get_drvdata(pdev);
644 
645 	charger->init_done = false;
646 	cancel_work_sync(&charger->work);
647 
648 	return 0;
649 }
650 
651 static struct platform_driver act8945a_charger_driver = {
652 	.driver	= {
653 		.name = "act8945a-charger",
654 	},
655 	.probe	= act8945a_charger_probe,
656 	.remove = act8945a_charger_remove,
657 };
658 module_platform_driver(act8945a_charger_driver);
659 
660 MODULE_DESCRIPTION("Active-semi ACT8945A ActivePath charger driver");
661 MODULE_AUTHOR("Wenyou Yang <wenyou.yang@atmel.com>");
662 MODULE_LICENSE("GPL");
663