1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * Copyright (C) ST-Ericsson SA 2012
4  * Copyright (c) 2012 Sony Mobile Communications AB
5  *
6  * Charging algorithm driver for AB8500
7  *
8  * Authors:
9  *	Johan Palsson <johan.palsson@stericsson.com>
10  *	Karl Komierowski <karl.komierowski@stericsson.com>
11  *	Arun R Murthy <arun.murthy@stericsson.com>
12  *	Author: Imre Sunyi <imre.sunyi@sonymobile.com>
13  */
14 
15 #include <linux/init.h>
16 #include <linux/module.h>
17 #include <linux/device.h>
18 #include <linux/component.h>
19 #include <linux/hrtimer.h>
20 #include <linux/interrupt.h>
21 #include <linux/delay.h>
22 #include <linux/slab.h>
23 #include <linux/platform_device.h>
24 #include <linux/power_supply.h>
25 #include <linux/completion.h>
26 #include <linux/workqueue.h>
27 #include <linux/kobject.h>
28 #include <linux/of.h>
29 #include <linux/mfd/core.h>
30 #include <linux/mfd/abx500.h>
31 #include <linux/mfd/abx500/ab8500.h>
32 #include <linux/notifier.h>
33 
34 #include "ab8500-bm.h"
35 #include "ab8500-chargalg.h"
36 
37 /* Watchdog kick interval */
38 #define CHG_WD_INTERVAL			(6 * HZ)
39 
40 /* End-of-charge criteria counter */
41 #define EOC_COND_CNT			10
42 
43 /* One hour expressed in seconds */
44 #define ONE_HOUR_IN_SECONDS            3600
45 
46 /* Five minutes expressed in seconds */
47 #define FIVE_MINUTES_IN_SECONDS        300
48 
49 /*
50  * This is the battery capacity limit that will trigger a new
51  * full charging cycle in the case where maintenance charging
52  * has been disabled
53  */
54 #define AB8500_RECHARGE_CAP		95
55 
56 enum ab8500_chargers {
57 	NO_CHG,
58 	AC_CHG,
59 	USB_CHG,
60 };
61 
62 struct ab8500_chargalg_charger_info {
63 	enum ab8500_chargers conn_chg;
64 	enum ab8500_chargers prev_conn_chg;
65 	enum ab8500_chargers online_chg;
66 	enum ab8500_chargers prev_online_chg;
67 	enum ab8500_chargers charger_type;
68 	bool usb_chg_ok;
69 	bool ac_chg_ok;
70 	int usb_volt_uv;
71 	int usb_curr_ua;
72 	int ac_volt_uv;
73 	int ac_curr_ua;
74 	int usb_vset_uv;
75 	int usb_iset_ua;
76 	int ac_vset_uv;
77 	int ac_iset_ua;
78 };
79 
80 struct ab8500_chargalg_battery_data {
81 	int temp;
82 	int volt_uv;
83 	int avg_curr_ua;
84 	int inst_curr_ua;
85 	int percent;
86 };
87 
88 enum ab8500_chargalg_states {
89 	STATE_HANDHELD_INIT,
90 	STATE_HANDHELD,
91 	STATE_CHG_NOT_OK_INIT,
92 	STATE_CHG_NOT_OK,
93 	STATE_HW_TEMP_PROTECT_INIT,
94 	STATE_HW_TEMP_PROTECT,
95 	STATE_NORMAL_INIT,
96 	STATE_NORMAL,
97 	STATE_WAIT_FOR_RECHARGE_INIT,
98 	STATE_WAIT_FOR_RECHARGE,
99 	STATE_MAINTENANCE_A_INIT,
100 	STATE_MAINTENANCE_A,
101 	STATE_MAINTENANCE_B_INIT,
102 	STATE_MAINTENANCE_B,
103 	STATE_TEMP_UNDEROVER_INIT,
104 	STATE_TEMP_UNDEROVER,
105 	STATE_TEMP_LOWHIGH_INIT,
106 	STATE_TEMP_LOWHIGH,
107 	STATE_OVV_PROTECT_INIT,
108 	STATE_OVV_PROTECT,
109 	STATE_SAFETY_TIMER_EXPIRED_INIT,
110 	STATE_SAFETY_TIMER_EXPIRED,
111 	STATE_BATT_REMOVED_INIT,
112 	STATE_BATT_REMOVED,
113 	STATE_WD_EXPIRED_INIT,
114 	STATE_WD_EXPIRED,
115 };
116 
117 static const char * const states[] = {
118 	"HANDHELD_INIT",
119 	"HANDHELD",
120 	"CHG_NOT_OK_INIT",
121 	"CHG_NOT_OK",
122 	"HW_TEMP_PROTECT_INIT",
123 	"HW_TEMP_PROTECT",
124 	"NORMAL_INIT",
125 	"NORMAL",
126 	"WAIT_FOR_RECHARGE_INIT",
127 	"WAIT_FOR_RECHARGE",
128 	"MAINTENANCE_A_INIT",
129 	"MAINTENANCE_A",
130 	"MAINTENANCE_B_INIT",
131 	"MAINTENANCE_B",
132 	"TEMP_UNDEROVER_INIT",
133 	"TEMP_UNDEROVER",
134 	"TEMP_LOWHIGH_INIT",
135 	"TEMP_LOWHIGH",
136 	"OVV_PROTECT_INIT",
137 	"OVV_PROTECT",
138 	"SAFETY_TIMER_EXPIRED_INIT",
139 	"SAFETY_TIMER_EXPIRED",
140 	"BATT_REMOVED_INIT",
141 	"BATT_REMOVED",
142 	"WD_EXPIRED_INIT",
143 	"WD_EXPIRED",
144 };
145 
146 struct ab8500_chargalg_events {
147 	bool batt_unknown;
148 	bool mainextchnotok;
149 	bool batt_ovv;
150 	bool batt_rem;
151 	bool btemp_underover;
152 	bool btemp_low;
153 	bool btemp_high;
154 	bool main_thermal_prot;
155 	bool usb_thermal_prot;
156 	bool main_ovv;
157 	bool vbus_ovv;
158 	bool usbchargernotok;
159 	bool safety_timer_expired;
160 	bool maintenance_timer_expired;
161 	bool ac_wd_expired;
162 	bool usb_wd_expired;
163 	bool ac_cv_active;
164 	bool usb_cv_active;
165 	bool vbus_collapsed;
166 };
167 
168 /**
169  * struct ab8500_charge_curr_maximization - Charger maximization parameters
170  * @original_iset_ua:	the non optimized/maximised charger current
171  * @current_iset_ua:	the charging current used at this moment
172  * @condition_cnt:	number of iterations needed before a new charger current
173 			is set
174  * @max_current_ua:	maximum charger current
175  * @wait_cnt:		to avoid too fast current step down in case of charger
176  *			voltage collapse, we insert this delay between step
177  *			down
178  * @level:		tells in how many steps the charging current has been
179 			increased
180  */
181 struct ab8500_charge_curr_maximization {
182 	int original_iset_ua;
183 	int current_iset_ua;
184 	int condition_cnt;
185 	int max_current_ua;
186 	int wait_cnt;
187 	u8 level;
188 };
189 
190 enum maxim_ret {
191 	MAXIM_RET_NOACTION,
192 	MAXIM_RET_CHANGE,
193 	MAXIM_RET_IBAT_TOO_HIGH,
194 };
195 
196 /**
197  * struct ab8500_chargalg - ab8500 Charging algorithm device information
198  * @dev:		pointer to the structure device
199  * @charge_status:	battery operating status
200  * @eoc_cnt:		counter used to determine end-of_charge
201  * @maintenance_chg:	indicate if maintenance charge is active
202  * @t_hyst_norm		temperature hysteresis when the temperature has been
203  *			over or under normal limits
204  * @t_hyst_lowhigh	temperature hysteresis when the temperature has been
205  *			over or under the high or low limits
206  * @charge_state:	current state of the charging algorithm
207  * @ccm			charging current maximization parameters
208  * @chg_info:		information about connected charger types
209  * @batt_data:		data of the battery
210  * @bm:           	Platform specific battery management information
211  * @parent:		pointer to the struct ab8500
212  * @chargalg_psy:	structure that holds the battery properties exposed by
213  *			the charging algorithm
214  * @events:		structure for information about events triggered
215  * @chargalg_wq:		work queue for running the charging algorithm
216  * @chargalg_periodic_work:	work to run the charging algorithm periodically
217  * @chargalg_wd_work:		work to kick the charger watchdog periodically
218  * @chargalg_work:		work to run the charging algorithm instantly
219  * @safety_timer:		charging safety timer
220  * @maintenance_timer:		maintenance charging timer
221  * @chargalg_kobject:		structure of type kobject
222  */
223 struct ab8500_chargalg {
224 	struct device *dev;
225 	int charge_status;
226 	int eoc_cnt;
227 	bool maintenance_chg;
228 	int t_hyst_norm;
229 	int t_hyst_lowhigh;
230 	enum ab8500_chargalg_states charge_state;
231 	struct ab8500_charge_curr_maximization ccm;
232 	struct ab8500_chargalg_charger_info chg_info;
233 	struct ab8500_chargalg_battery_data batt_data;
234 	struct ab8500 *parent;
235 	struct ab8500_bm_data *bm;
236 	struct power_supply *chargalg_psy;
237 	struct ux500_charger *ac_chg;
238 	struct ux500_charger *usb_chg;
239 	struct ab8500_chargalg_events events;
240 	struct workqueue_struct *chargalg_wq;
241 	struct delayed_work chargalg_periodic_work;
242 	struct delayed_work chargalg_wd_work;
243 	struct work_struct chargalg_work;
244 	struct hrtimer safety_timer;
245 	struct hrtimer maintenance_timer;
246 	struct kobject chargalg_kobject;
247 };
248 
249 /* Main battery properties */
250 static enum power_supply_property ab8500_chargalg_props[] = {
251 	POWER_SUPPLY_PROP_STATUS,
252 	POWER_SUPPLY_PROP_HEALTH,
253 };
254 
255 /**
256  * ab8500_chargalg_safety_timer_expired() - Expiration of the safety timer
257  * @timer:     pointer to the hrtimer structure
258  *
259  * This function gets called when the safety timer for the charger
260  * expires
261  */
262 static enum hrtimer_restart
263 ab8500_chargalg_safety_timer_expired(struct hrtimer *timer)
264 {
265 	struct ab8500_chargalg *di = container_of(timer, struct ab8500_chargalg,
266 						  safety_timer);
267 	dev_err(di->dev, "Safety timer expired\n");
268 	di->events.safety_timer_expired = true;
269 
270 	/* Trigger execution of the algorithm instantly */
271 	queue_work(di->chargalg_wq, &di->chargalg_work);
272 
273 	return HRTIMER_NORESTART;
274 }
275 
276 /**
277  * ab8500_chargalg_maintenance_timer_expired() - Expiration of
278  * the maintenance timer
279  * @timer:     pointer to the timer structure
280  *
281  * This function gets called when the maintenance timer
282  * expires
283  */
284 static enum hrtimer_restart
285 ab8500_chargalg_maintenance_timer_expired(struct hrtimer *timer)
286 {
287 
288 	struct ab8500_chargalg *di = container_of(timer, struct ab8500_chargalg,
289 						  maintenance_timer);
290 
291 	dev_dbg(di->dev, "Maintenance timer expired\n");
292 	di->events.maintenance_timer_expired = true;
293 
294 	/* Trigger execution of the algorithm instantly */
295 	queue_work(di->chargalg_wq, &di->chargalg_work);
296 
297 	return HRTIMER_NORESTART;
298 }
299 
300 /**
301  * ab8500_chargalg_state_to() - Change charge state
302  * @di:		pointer to the ab8500_chargalg structure
303  *
304  * This function gets called when a charge state change should occur
305  */
306 static void ab8500_chargalg_state_to(struct ab8500_chargalg *di,
307 	enum ab8500_chargalg_states state)
308 {
309 	dev_dbg(di->dev,
310 		"State changed: %s (From state: [%d] %s =to=> [%d] %s )\n",
311 		di->charge_state == state ? "NO" : "YES",
312 		di->charge_state,
313 		states[di->charge_state],
314 		state,
315 		states[state]);
316 
317 	di->charge_state = state;
318 }
319 
320 static int ab8500_chargalg_check_charger_enable(struct ab8500_chargalg *di)
321 {
322 	struct power_supply_battery_info *bi = di->bm->bi;
323 
324 	switch (di->charge_state) {
325 	case STATE_NORMAL:
326 	case STATE_MAINTENANCE_A:
327 	case STATE_MAINTENANCE_B:
328 		break;
329 	default:
330 		return 0;
331 	}
332 
333 	if (di->chg_info.charger_type & USB_CHG) {
334 		return di->usb_chg->ops.check_enable(di->usb_chg,
335 			bi->constant_charge_voltage_max_uv,
336 			bi->constant_charge_current_max_ua);
337 	} else if (di->chg_info.charger_type & AC_CHG) {
338 		return di->ac_chg->ops.check_enable(di->ac_chg,
339 			bi->constant_charge_voltage_max_uv,
340 			bi->constant_charge_current_max_ua);
341 	}
342 	return 0;
343 }
344 
345 /**
346  * ab8500_chargalg_check_charger_connection() - Check charger connection change
347  * @di:		pointer to the ab8500_chargalg structure
348  *
349  * This function will check if there is a change in the charger connection
350  * and change charge state accordingly. AC has precedence over USB.
351  */
352 static int ab8500_chargalg_check_charger_connection(struct ab8500_chargalg *di)
353 {
354 	if (di->chg_info.conn_chg != di->chg_info.prev_conn_chg) {
355 		/* Charger state changed since last update */
356 		if (di->chg_info.conn_chg & AC_CHG) {
357 			dev_info(di->dev, "Charging source is AC\n");
358 			if (di->chg_info.charger_type != AC_CHG) {
359 				di->chg_info.charger_type = AC_CHG;
360 				ab8500_chargalg_state_to(di, STATE_NORMAL_INIT);
361 			}
362 		} else if (di->chg_info.conn_chg & USB_CHG) {
363 			dev_info(di->dev, "Charging source is USB\n");
364 			di->chg_info.charger_type = USB_CHG;
365 			ab8500_chargalg_state_to(di, STATE_NORMAL_INIT);
366 		} else {
367 			dev_dbg(di->dev, "Charging source is OFF\n");
368 			di->chg_info.charger_type = NO_CHG;
369 			ab8500_chargalg_state_to(di, STATE_HANDHELD_INIT);
370 		}
371 		di->chg_info.prev_conn_chg = di->chg_info.conn_chg;
372 	}
373 	return di->chg_info.conn_chg;
374 }
375 
376 /**
377  * ab8500_chargalg_start_safety_timer() - Start charging safety timer
378  * @di:		pointer to the ab8500_chargalg structure
379  *
380  * The safety timer is used to avoid overcharging of old or bad batteries.
381  * There are different timers for AC and USB
382  */
383 static void ab8500_chargalg_start_safety_timer(struct ab8500_chargalg *di)
384 {
385 	/* Charger-dependent expiration time in hours*/
386 	int timer_expiration = 0;
387 
388 	switch (di->chg_info.charger_type) {
389 	case AC_CHG:
390 		timer_expiration = di->bm->main_safety_tmr_h;
391 		break;
392 
393 	case USB_CHG:
394 		timer_expiration = di->bm->usb_safety_tmr_h;
395 		break;
396 
397 	default:
398 		dev_err(di->dev, "Unknown charger to charge from\n");
399 		break;
400 	}
401 
402 	di->events.safety_timer_expired = false;
403 	hrtimer_set_expires_range(&di->safety_timer,
404 		ktime_set(timer_expiration * ONE_HOUR_IN_SECONDS, 0),
405 		ktime_set(FIVE_MINUTES_IN_SECONDS, 0));
406 	hrtimer_start_expires(&di->safety_timer, HRTIMER_MODE_REL);
407 }
408 
409 /**
410  * ab8500_chargalg_stop_safety_timer() - Stop charging safety timer
411  * @di:		pointer to the ab8500_chargalg structure
412  *
413  * The safety timer is stopped whenever the NORMAL state is exited
414  */
415 static void ab8500_chargalg_stop_safety_timer(struct ab8500_chargalg *di)
416 {
417 	if (hrtimer_try_to_cancel(&di->safety_timer) >= 0)
418 		di->events.safety_timer_expired = false;
419 }
420 
421 /**
422  * ab8500_chargalg_start_maintenance_timer() - Start charging maintenance timer
423  * @di:		pointer to the ab8500_chargalg structure
424  * @duration:	duration of the maintenance timer in minutes
425  *
426  * The maintenance timer is used to maintain the charge in the battery once
427  * the battery is considered full. These timers are chosen to match the
428  * discharge curve of the battery
429  */
430 static void ab8500_chargalg_start_maintenance_timer(struct ab8500_chargalg *di,
431 	int duration)
432 {
433 	/* Set a timer in minutes with a 30 second range */
434 	hrtimer_set_expires_range(&di->maintenance_timer,
435 		ktime_set(duration * 60, 0),
436 		ktime_set(30, 0));
437 	di->events.maintenance_timer_expired = false;
438 	hrtimer_start_expires(&di->maintenance_timer, HRTIMER_MODE_REL);
439 }
440 
441 /**
442  * ab8500_chargalg_stop_maintenance_timer() - Stop maintenance timer
443  * @di:		pointer to the ab8500_chargalg structure
444  *
445  * The maintenance timer is stopped whenever maintenance ends or when another
446  * state is entered
447  */
448 static void ab8500_chargalg_stop_maintenance_timer(struct ab8500_chargalg *di)
449 {
450 	if (hrtimer_try_to_cancel(&di->maintenance_timer) >= 0)
451 		di->events.maintenance_timer_expired = false;
452 }
453 
454 /**
455  * ab8500_chargalg_kick_watchdog() - Kick charger watchdog
456  * @di:		pointer to the ab8500_chargalg structure
457  *
458  * The charger watchdog have to be kicked periodically whenever the charger is
459  * on, else the ABB will reset the system
460  */
461 static int ab8500_chargalg_kick_watchdog(struct ab8500_chargalg *di)
462 {
463 	/* Check if charger exists and kick watchdog if charging */
464 	if (di->ac_chg && di->ac_chg->ops.kick_wd &&
465 	    di->chg_info.online_chg & AC_CHG) {
466 		return di->ac_chg->ops.kick_wd(di->ac_chg);
467 	} else if (di->usb_chg && di->usb_chg->ops.kick_wd &&
468 			di->chg_info.online_chg & USB_CHG)
469 		return di->usb_chg->ops.kick_wd(di->usb_chg);
470 
471 	return -ENXIO;
472 }
473 
474 /**
475  * ab8500_chargalg_ac_en() - Turn on/off the AC charger
476  * @di:		pointer to the ab8500_chargalg structure
477  * @enable:	charger on/off
478  * @vset_uv:	requested charger output voltage in microvolt
479  * @iset_ua:	requested charger output current in microampere
480  *
481  * The AC charger will be turned on/off with the requested charge voltage and
482  * current
483  */
484 static int ab8500_chargalg_ac_en(struct ab8500_chargalg *di, int enable,
485 	int vset_uv, int iset_ua)
486 {
487 	if (!di->ac_chg || !di->ac_chg->ops.enable)
488 		return -ENXIO;
489 
490 	/* Select maximum of what both the charger and the battery supports */
491 	if (di->ac_chg->max_out_volt_uv)
492 		vset_uv = min(vset_uv, di->ac_chg->max_out_volt_uv);
493 	if (di->ac_chg->max_out_curr_ua)
494 		iset_ua = min(iset_ua, di->ac_chg->max_out_curr_ua);
495 
496 	di->chg_info.ac_iset_ua = iset_ua;
497 	di->chg_info.ac_vset_uv = vset_uv;
498 
499 	return di->ac_chg->ops.enable(di->ac_chg, enable, vset_uv, iset_ua);
500 }
501 
502 /**
503  * ab8500_chargalg_usb_en() - Turn on/off the USB charger
504  * @di:		pointer to the ab8500_chargalg structure
505  * @enable:	charger on/off
506  * @vset_uv:	requested charger output voltage in microvolt
507  * @iset_ua:	requested charger output current in microampere
508  *
509  * The USB charger will be turned on/off with the requested charge voltage and
510  * current
511  */
512 static int ab8500_chargalg_usb_en(struct ab8500_chargalg *di, int enable,
513 	int vset_uv, int iset_ua)
514 {
515 	if (!di->usb_chg || !di->usb_chg->ops.enable)
516 		return -ENXIO;
517 
518 	/* Select maximum of what both the charger and the battery supports */
519 	if (di->usb_chg->max_out_volt_uv)
520 		vset_uv = min(vset_uv, di->usb_chg->max_out_volt_uv);
521 	if (di->usb_chg->max_out_curr_ua)
522 		iset_ua = min(iset_ua, di->usb_chg->max_out_curr_ua);
523 
524 	di->chg_info.usb_iset_ua = iset_ua;
525 	di->chg_info.usb_vset_uv = vset_uv;
526 
527 	return di->usb_chg->ops.enable(di->usb_chg, enable, vset_uv, iset_ua);
528 }
529 
530 /**
531  * ab8500_chargalg_update_chg_curr() - Update charger current
532  * @di:		pointer to the ab8500_chargalg structure
533  * @iset_ua:	requested charger output current in microampere
534  *
535  * The charger output current will be updated for the charger
536  * that is currently in use
537  */
538 static int ab8500_chargalg_update_chg_curr(struct ab8500_chargalg *di,
539 		int iset_ua)
540 {
541 	/* Check if charger exists and update current if charging */
542 	if (di->ac_chg && di->ac_chg->ops.update_curr &&
543 			di->chg_info.charger_type & AC_CHG) {
544 		/*
545 		 * Select maximum of what both the charger
546 		 * and the battery supports
547 		 */
548 		if (di->ac_chg->max_out_curr_ua)
549 			iset_ua = min(iset_ua, di->ac_chg->max_out_curr_ua);
550 
551 		di->chg_info.ac_iset_ua = iset_ua;
552 
553 		return di->ac_chg->ops.update_curr(di->ac_chg, iset_ua);
554 	} else if (di->usb_chg && di->usb_chg->ops.update_curr &&
555 			di->chg_info.charger_type & USB_CHG) {
556 		/*
557 		 * Select maximum of what both the charger
558 		 * and the battery supports
559 		 */
560 		if (di->usb_chg->max_out_curr_ua)
561 			iset_ua = min(iset_ua, di->usb_chg->max_out_curr_ua);
562 
563 		di->chg_info.usb_iset_ua = iset_ua;
564 
565 		return di->usb_chg->ops.update_curr(di->usb_chg, iset_ua);
566 	}
567 
568 	return -ENXIO;
569 }
570 
571 /**
572  * ab8500_chargalg_stop_charging() - Stop charging
573  * @di:		pointer to the ab8500_chargalg structure
574  *
575  * This function is called from any state where charging should be stopped.
576  * All charging is disabled and all status parameters and timers are changed
577  * accordingly
578  */
579 static void ab8500_chargalg_stop_charging(struct ab8500_chargalg *di)
580 {
581 	ab8500_chargalg_ac_en(di, false, 0, 0);
582 	ab8500_chargalg_usb_en(di, false, 0, 0);
583 	ab8500_chargalg_stop_safety_timer(di);
584 	ab8500_chargalg_stop_maintenance_timer(di);
585 	di->charge_status = POWER_SUPPLY_STATUS_NOT_CHARGING;
586 	di->maintenance_chg = false;
587 	cancel_delayed_work(&di->chargalg_wd_work);
588 	power_supply_changed(di->chargalg_psy);
589 }
590 
591 /**
592  * ab8500_chargalg_hold_charging() - Pauses charging
593  * @di:		pointer to the ab8500_chargalg structure
594  *
595  * This function is called in the case where maintenance charging has been
596  * disabled and instead a battery voltage mode is entered to check when the
597  * battery voltage has reached a certain recharge voltage
598  */
599 static void ab8500_chargalg_hold_charging(struct ab8500_chargalg *di)
600 {
601 	ab8500_chargalg_ac_en(di, false, 0, 0);
602 	ab8500_chargalg_usb_en(di, false, 0, 0);
603 	ab8500_chargalg_stop_safety_timer(di);
604 	ab8500_chargalg_stop_maintenance_timer(di);
605 	di->charge_status = POWER_SUPPLY_STATUS_CHARGING;
606 	di->maintenance_chg = false;
607 	cancel_delayed_work(&di->chargalg_wd_work);
608 	power_supply_changed(di->chargalg_psy);
609 }
610 
611 /**
612  * ab8500_chargalg_start_charging() - Start the charger
613  * @di:		pointer to the ab8500_chargalg structure
614  * @vset_uv:	requested charger output voltage in microvolt
615  * @iset_ua:	requested charger output current in microampere
616  *
617  * A charger will be enabled depending on the requested charger type that was
618  * detected previously.
619  */
620 static void ab8500_chargalg_start_charging(struct ab8500_chargalg *di,
621 	int vset_uv, int iset_ua)
622 {
623 	switch (di->chg_info.charger_type) {
624 	case AC_CHG:
625 		dev_dbg(di->dev,
626 			"AC parameters: Vset %d, Ich %d\n", vset_uv, iset_ua);
627 		ab8500_chargalg_usb_en(di, false, 0, 0);
628 		ab8500_chargalg_ac_en(di, true, vset_uv, iset_ua);
629 		break;
630 
631 	case USB_CHG:
632 		dev_dbg(di->dev,
633 			"USB parameters: Vset %d, Ich %d\n", vset_uv, iset_ua);
634 		ab8500_chargalg_ac_en(di, false, 0, 0);
635 		ab8500_chargalg_usb_en(di, true, vset_uv, iset_ua);
636 		break;
637 
638 	default:
639 		dev_err(di->dev, "Unknown charger to charge from\n");
640 		break;
641 	}
642 }
643 
644 /**
645  * ab8500_chargalg_check_temp() - Check battery temperature ranges
646  * @di:		pointer to the ab8500_chargalg structure
647  *
648  * The battery temperature is checked against the predefined limits and the
649  * charge state is changed accordingly
650  */
651 static void ab8500_chargalg_check_temp(struct ab8500_chargalg *di)
652 {
653 	struct power_supply_battery_info *bi = di->bm->bi;
654 
655 	if (di->batt_data.temp > (bi->temp_alert_min + di->t_hyst_norm) &&
656 		di->batt_data.temp < (bi->temp_alert_max - di->t_hyst_norm)) {
657 		/* Temp OK! */
658 		di->events.btemp_underover = false;
659 		di->events.btemp_low = false;
660 		di->events.btemp_high = false;
661 		di->t_hyst_norm = 0;
662 		di->t_hyst_lowhigh = 0;
663 	} else {
664 		if ((di->batt_data.temp >= bi->temp_alert_max) &&
665 		    (di->batt_data.temp < (bi->temp_max - di->t_hyst_lowhigh))) {
666 			/* Alert zone for high temperature */
667 			di->events.btemp_underover = false;
668 			di->events.btemp_high = true;
669 			di->t_hyst_norm = di->bm->temp_hysteresis;
670 			di->t_hyst_lowhigh = 0;
671 		} else if ((di->batt_data.temp > (bi->temp_min + di->t_hyst_lowhigh)) &&
672 			   (di->batt_data.temp <= bi->temp_alert_min)) {
673 			/* Alert zone for low temperature */
674 			di->events.btemp_underover = false;
675 			di->events.btemp_low = true;
676 			di->t_hyst_norm = di->bm->temp_hysteresis;
677 			di->t_hyst_lowhigh = 0;
678 		} else if (di->batt_data.temp <= bi->temp_min ||
679 			di->batt_data.temp >= bi->temp_max) {
680 			/* TEMP major!!!!! */
681 			di->events.btemp_underover = true;
682 			di->events.btemp_low = false;
683 			di->events.btemp_high = false;
684 			di->t_hyst_norm = 0;
685 			di->t_hyst_lowhigh = di->bm->temp_hysteresis;
686 		} else {
687 			/* Within hysteresis */
688 			dev_dbg(di->dev, "Within hysteresis limit temp: %d "
689 				"hyst_lowhigh %d, hyst normal %d\n",
690 				di->batt_data.temp, di->t_hyst_lowhigh,
691 				di->t_hyst_norm);
692 		}
693 	}
694 }
695 
696 /**
697  * ab8500_chargalg_check_charger_voltage() - Check charger voltage
698  * @di:		pointer to the ab8500_chargalg structure
699  *
700  * Charger voltage is checked against maximum limit
701  */
702 static void ab8500_chargalg_check_charger_voltage(struct ab8500_chargalg *di)
703 {
704 	if (di->chg_info.usb_volt_uv > di->bm->chg_params->usb_volt_max_uv)
705 		di->chg_info.usb_chg_ok = false;
706 	else
707 		di->chg_info.usb_chg_ok = true;
708 
709 	if (di->chg_info.ac_volt_uv > di->bm->chg_params->ac_volt_max_uv)
710 		di->chg_info.ac_chg_ok = false;
711 	else
712 		di->chg_info.ac_chg_ok = true;
713 
714 }
715 
716 /**
717  * ab8500_chargalg_end_of_charge() - Check if end-of-charge criteria is fulfilled
718  * @di:		pointer to the ab8500_chargalg structure
719  *
720  * End-of-charge criteria is fulfilled when the battery voltage is above a
721  * certain limit and the battery current is below a certain limit for a
722  * predefined number of consecutive seconds. If true, the battery is full
723  */
724 static void ab8500_chargalg_end_of_charge(struct ab8500_chargalg *di)
725 {
726 	if (di->charge_status == POWER_SUPPLY_STATUS_CHARGING &&
727 		di->charge_state == STATE_NORMAL &&
728 		!di->maintenance_chg && (di->batt_data.volt_uv >=
729 		di->bm->bi->voltage_max_design_uv ||
730 		di->events.usb_cv_active || di->events.ac_cv_active) &&
731 		di->batt_data.avg_curr_ua <
732 		di->bm->bi->charge_term_current_ua &&
733 		di->batt_data.avg_curr_ua > 0) {
734 		if (++di->eoc_cnt >= EOC_COND_CNT) {
735 			di->eoc_cnt = 0;
736 			di->charge_status = POWER_SUPPLY_STATUS_FULL;
737 			di->maintenance_chg = true;
738 			dev_dbg(di->dev, "EOC reached!\n");
739 			power_supply_changed(di->chargalg_psy);
740 		} else {
741 			dev_dbg(di->dev,
742 				" EOC limit reached for the %d"
743 				" time, out of %d before EOC\n",
744 				di->eoc_cnt,
745 				EOC_COND_CNT);
746 		}
747 	} else {
748 		di->eoc_cnt = 0;
749 	}
750 }
751 
752 static void init_maxim_chg_curr(struct ab8500_chargalg *di)
753 {
754 	struct power_supply_battery_info *bi = di->bm->bi;
755 
756 	di->ccm.original_iset_ua = bi->constant_charge_current_max_ua;
757 	di->ccm.current_iset_ua = bi->constant_charge_current_max_ua;
758 	di->ccm.max_current_ua = di->bm->maxi->chg_curr_ua;
759 	di->ccm.condition_cnt = di->bm->maxi->wait_cycles;
760 	di->ccm.level = 0;
761 }
762 
763 /**
764  * ab8500_chargalg_chg_curr_maxim - increases the charger current to
765  *			compensate for the system load
766  * @di		pointer to the ab8500_chargalg structure
767  *
768  * This maximization function is used to raise the charger current to get the
769  * battery current as close to the optimal value as possible. The battery
770  * current during charging is affected by the system load
771  */
772 static enum maxim_ret ab8500_chargalg_chg_curr_maxim(struct ab8500_chargalg *di)
773 {
774 
775 	if (!di->bm->maxi->ena_maxi)
776 		return MAXIM_RET_NOACTION;
777 
778 	if (di->events.vbus_collapsed) {
779 		dev_dbg(di->dev, "Charger voltage has collapsed %d\n",
780 				di->ccm.wait_cnt);
781 		if (di->ccm.wait_cnt == 0) {
782 			dev_dbg(di->dev, "lowering current\n");
783 			di->ccm.wait_cnt++;
784 			di->ccm.condition_cnt = di->bm->maxi->wait_cycles;
785 			di->ccm.max_current_ua = di->ccm.current_iset_ua;
786 			di->ccm.current_iset_ua = di->ccm.max_current_ua;
787 			di->ccm.level--;
788 			return MAXIM_RET_CHANGE;
789 		} else {
790 			dev_dbg(di->dev, "waiting\n");
791 			/* Let's go in here twice before lowering curr again */
792 			di->ccm.wait_cnt = (di->ccm.wait_cnt + 1) % 3;
793 			return MAXIM_RET_NOACTION;
794 		}
795 	}
796 
797 	di->ccm.wait_cnt = 0;
798 
799 	if (di->batt_data.inst_curr_ua > di->ccm.original_iset_ua) {
800 		dev_dbg(di->dev, " Maximization Ibat (%duA) too high"
801 			" (limit %duA) (current iset: %duA)!\n",
802 			di->batt_data.inst_curr_ua, di->ccm.original_iset_ua,
803 			di->ccm.current_iset_ua);
804 
805 		if (di->ccm.current_iset_ua == di->ccm.original_iset_ua)
806 			return MAXIM_RET_NOACTION;
807 
808 		di->ccm.condition_cnt = di->bm->maxi->wait_cycles;
809 		di->ccm.current_iset_ua = di->ccm.original_iset_ua;
810 		di->ccm.level = 0;
811 
812 		return MAXIM_RET_IBAT_TOO_HIGH;
813 	}
814 
815 	di->ccm.condition_cnt = di->bm->maxi->wait_cycles;
816 	return MAXIM_RET_NOACTION;
817 }
818 
819 static void handle_maxim_chg_curr(struct ab8500_chargalg *di)
820 {
821 	struct power_supply_battery_info *bi = di->bm->bi;
822 	enum maxim_ret ret;
823 	int result;
824 
825 	ret = ab8500_chargalg_chg_curr_maxim(di);
826 	switch (ret) {
827 	case MAXIM_RET_CHANGE:
828 		result = ab8500_chargalg_update_chg_curr(di,
829 			di->ccm.current_iset_ua);
830 		if (result)
831 			dev_err(di->dev, "failed to set chg curr\n");
832 		break;
833 	case MAXIM_RET_IBAT_TOO_HIGH:
834 		result = ab8500_chargalg_update_chg_curr(di,
835 			bi->constant_charge_current_max_ua);
836 		if (result)
837 			dev_err(di->dev, "failed to set chg curr\n");
838 		break;
839 
840 	case MAXIM_RET_NOACTION:
841 	default:
842 		/* Do nothing..*/
843 		break;
844 	}
845 }
846 
847 static int ab8500_chargalg_get_ext_psy_data(struct device *dev, void *data)
848 {
849 	struct power_supply *psy;
850 	struct power_supply *ext = dev_get_drvdata(dev);
851 	const char **supplicants = (const char **)ext->supplied_to;
852 	struct ab8500_chargalg *di;
853 	union power_supply_propval ret;
854 	int j;
855 	bool capacity_updated = false;
856 
857 	psy = (struct power_supply *)data;
858 	di = power_supply_get_drvdata(psy);
859 	/* For all psy where the driver name appears in any supplied_to */
860 	j = match_string(supplicants, ext->num_supplicants, psy->desc->name);
861 	if (j < 0)
862 		return 0;
863 
864 	/*
865 	 *  If external is not registering 'POWER_SUPPLY_PROP_CAPACITY' to its
866 	 * property because of handling that sysfs entry on its own, this is
867 	 * the place to get the battery capacity.
868 	 */
869 	if (!power_supply_get_property(ext, POWER_SUPPLY_PROP_CAPACITY, &ret)) {
870 		di->batt_data.percent = ret.intval;
871 		capacity_updated = true;
872 	}
873 
874 	/* Go through all properties for the psy */
875 	for (j = 0; j < ext->desc->num_properties; j++) {
876 		enum power_supply_property prop;
877 		prop = ext->desc->properties[j];
878 
879 		/*
880 		 * Initialize chargers if not already done.
881 		 * The ab8500_charger*/
882 		if (!di->ac_chg &&
883 			ext->desc->type == POWER_SUPPLY_TYPE_MAINS)
884 			di->ac_chg = psy_to_ux500_charger(ext);
885 		else if (!di->usb_chg &&
886 			ext->desc->type == POWER_SUPPLY_TYPE_USB)
887 			di->usb_chg = psy_to_ux500_charger(ext);
888 
889 		if (power_supply_get_property(ext, prop, &ret))
890 			continue;
891 		switch (prop) {
892 		case POWER_SUPPLY_PROP_PRESENT:
893 			switch (ext->desc->type) {
894 			case POWER_SUPPLY_TYPE_BATTERY:
895 				/* Battery present */
896 				if (ret.intval)
897 					di->events.batt_rem = false;
898 				/* Battery removed */
899 				else
900 					di->events.batt_rem = true;
901 				break;
902 			case POWER_SUPPLY_TYPE_MAINS:
903 				/* AC disconnected */
904 				if (!ret.intval &&
905 					(di->chg_info.conn_chg & AC_CHG)) {
906 					di->chg_info.prev_conn_chg =
907 						di->chg_info.conn_chg;
908 					di->chg_info.conn_chg &= ~AC_CHG;
909 				}
910 				/* AC connected */
911 				else if (ret.intval &&
912 					!(di->chg_info.conn_chg & AC_CHG)) {
913 					di->chg_info.prev_conn_chg =
914 						di->chg_info.conn_chg;
915 					di->chg_info.conn_chg |= AC_CHG;
916 				}
917 				break;
918 			case POWER_SUPPLY_TYPE_USB:
919 				/* USB disconnected */
920 				if (!ret.intval &&
921 					(di->chg_info.conn_chg & USB_CHG)) {
922 					di->chg_info.prev_conn_chg =
923 						di->chg_info.conn_chg;
924 					di->chg_info.conn_chg &= ~USB_CHG;
925 				}
926 				/* USB connected */
927 				else if (ret.intval &&
928 					!(di->chg_info.conn_chg & USB_CHG)) {
929 					di->chg_info.prev_conn_chg =
930 						di->chg_info.conn_chg;
931 					di->chg_info.conn_chg |= USB_CHG;
932 				}
933 				break;
934 			default:
935 				break;
936 			}
937 			break;
938 
939 		case POWER_SUPPLY_PROP_ONLINE:
940 			switch (ext->desc->type) {
941 			case POWER_SUPPLY_TYPE_BATTERY:
942 				break;
943 			case POWER_SUPPLY_TYPE_MAINS:
944 				/* AC offline */
945 				if (!ret.intval &&
946 					(di->chg_info.online_chg & AC_CHG)) {
947 					di->chg_info.prev_online_chg =
948 						di->chg_info.online_chg;
949 					di->chg_info.online_chg &= ~AC_CHG;
950 				}
951 				/* AC online */
952 				else if (ret.intval &&
953 					!(di->chg_info.online_chg & AC_CHG)) {
954 					di->chg_info.prev_online_chg =
955 						di->chg_info.online_chg;
956 					di->chg_info.online_chg |= AC_CHG;
957 					queue_delayed_work(di->chargalg_wq,
958 						&di->chargalg_wd_work, 0);
959 				}
960 				break;
961 			case POWER_SUPPLY_TYPE_USB:
962 				/* USB offline */
963 				if (!ret.intval &&
964 					(di->chg_info.online_chg & USB_CHG)) {
965 					di->chg_info.prev_online_chg =
966 						di->chg_info.online_chg;
967 					di->chg_info.online_chg &= ~USB_CHG;
968 				}
969 				/* USB online */
970 				else if (ret.intval &&
971 					!(di->chg_info.online_chg & USB_CHG)) {
972 					di->chg_info.prev_online_chg =
973 						di->chg_info.online_chg;
974 					di->chg_info.online_chg |= USB_CHG;
975 					queue_delayed_work(di->chargalg_wq,
976 						&di->chargalg_wd_work, 0);
977 				}
978 				break;
979 			default:
980 				break;
981 			}
982 			break;
983 
984 		case POWER_SUPPLY_PROP_HEALTH:
985 			switch (ext->desc->type) {
986 			case POWER_SUPPLY_TYPE_BATTERY:
987 				break;
988 			case POWER_SUPPLY_TYPE_MAINS:
989 				switch (ret.intval) {
990 				case POWER_SUPPLY_HEALTH_UNSPEC_FAILURE:
991 					di->events.mainextchnotok = true;
992 					di->events.main_thermal_prot = false;
993 					di->events.main_ovv = false;
994 					di->events.ac_wd_expired = false;
995 					break;
996 				case POWER_SUPPLY_HEALTH_DEAD:
997 					di->events.ac_wd_expired = true;
998 					di->events.mainextchnotok = false;
999 					di->events.main_ovv = false;
1000 					di->events.main_thermal_prot = false;
1001 					break;
1002 				case POWER_SUPPLY_HEALTH_COLD:
1003 				case POWER_SUPPLY_HEALTH_OVERHEAT:
1004 					di->events.main_thermal_prot = true;
1005 					di->events.mainextchnotok = false;
1006 					di->events.main_ovv = false;
1007 					di->events.ac_wd_expired = false;
1008 					break;
1009 				case POWER_SUPPLY_HEALTH_OVERVOLTAGE:
1010 					di->events.main_ovv = true;
1011 					di->events.mainextchnotok = false;
1012 					di->events.main_thermal_prot = false;
1013 					di->events.ac_wd_expired = false;
1014 					break;
1015 				case POWER_SUPPLY_HEALTH_GOOD:
1016 					di->events.main_thermal_prot = false;
1017 					di->events.mainextchnotok = false;
1018 					di->events.main_ovv = false;
1019 					di->events.ac_wd_expired = false;
1020 					break;
1021 				default:
1022 					break;
1023 				}
1024 				break;
1025 
1026 			case POWER_SUPPLY_TYPE_USB:
1027 				switch (ret.intval) {
1028 				case POWER_SUPPLY_HEALTH_UNSPEC_FAILURE:
1029 					di->events.usbchargernotok = true;
1030 					di->events.usb_thermal_prot = false;
1031 					di->events.vbus_ovv = false;
1032 					di->events.usb_wd_expired = false;
1033 					break;
1034 				case POWER_SUPPLY_HEALTH_DEAD:
1035 					di->events.usb_wd_expired = true;
1036 					di->events.usbchargernotok = false;
1037 					di->events.usb_thermal_prot = false;
1038 					di->events.vbus_ovv = false;
1039 					break;
1040 				case POWER_SUPPLY_HEALTH_COLD:
1041 				case POWER_SUPPLY_HEALTH_OVERHEAT:
1042 					di->events.usb_thermal_prot = true;
1043 					di->events.usbchargernotok = false;
1044 					di->events.vbus_ovv = false;
1045 					di->events.usb_wd_expired = false;
1046 					break;
1047 				case POWER_SUPPLY_HEALTH_OVERVOLTAGE:
1048 					di->events.vbus_ovv = true;
1049 					di->events.usbchargernotok = false;
1050 					di->events.usb_thermal_prot = false;
1051 					di->events.usb_wd_expired = false;
1052 					break;
1053 				case POWER_SUPPLY_HEALTH_GOOD:
1054 					di->events.usbchargernotok = false;
1055 					di->events.usb_thermal_prot = false;
1056 					di->events.vbus_ovv = false;
1057 					di->events.usb_wd_expired = false;
1058 					break;
1059 				default:
1060 					break;
1061 				}
1062 				break;
1063 			default:
1064 				break;
1065 			}
1066 			break;
1067 
1068 		case POWER_SUPPLY_PROP_VOLTAGE_NOW:
1069 			switch (ext->desc->type) {
1070 			case POWER_SUPPLY_TYPE_BATTERY:
1071 				di->batt_data.volt_uv = ret.intval;
1072 				break;
1073 			case POWER_SUPPLY_TYPE_MAINS:
1074 				di->chg_info.ac_volt_uv = ret.intval;
1075 				break;
1076 			case POWER_SUPPLY_TYPE_USB:
1077 				di->chg_info.usb_volt_uv = ret.intval;
1078 				break;
1079 			default:
1080 				break;
1081 			}
1082 			break;
1083 
1084 		case POWER_SUPPLY_PROP_VOLTAGE_AVG:
1085 			switch (ext->desc->type) {
1086 			case POWER_SUPPLY_TYPE_MAINS:
1087 				/* AVG is used to indicate when we are
1088 				 * in CV mode */
1089 				if (ret.intval)
1090 					di->events.ac_cv_active = true;
1091 				else
1092 					di->events.ac_cv_active = false;
1093 
1094 				break;
1095 			case POWER_SUPPLY_TYPE_USB:
1096 				/* AVG is used to indicate when we are
1097 				 * in CV mode */
1098 				if (ret.intval)
1099 					di->events.usb_cv_active = true;
1100 				else
1101 					di->events.usb_cv_active = false;
1102 
1103 				break;
1104 			default:
1105 				break;
1106 			}
1107 			break;
1108 
1109 		case POWER_SUPPLY_PROP_TECHNOLOGY:
1110 			switch (ext->desc->type) {
1111 			case POWER_SUPPLY_TYPE_BATTERY:
1112 				if (ret.intval)
1113 					di->events.batt_unknown = false;
1114 				else
1115 					di->events.batt_unknown = true;
1116 
1117 				break;
1118 			default:
1119 				break;
1120 			}
1121 			break;
1122 
1123 		case POWER_SUPPLY_PROP_TEMP:
1124 			di->batt_data.temp = ret.intval / 10;
1125 			break;
1126 
1127 		case POWER_SUPPLY_PROP_CURRENT_NOW:
1128 			switch (ext->desc->type) {
1129 			case POWER_SUPPLY_TYPE_MAINS:
1130 				di->chg_info.ac_curr_ua = ret.intval;
1131 				break;
1132 			case POWER_SUPPLY_TYPE_USB:
1133 				di->chg_info.usb_curr_ua = ret.intval;
1134 				break;
1135 			case POWER_SUPPLY_TYPE_BATTERY:
1136 				di->batt_data.inst_curr_ua = ret.intval;
1137 				break;
1138 			default:
1139 				break;
1140 			}
1141 			break;
1142 
1143 		case POWER_SUPPLY_PROP_CURRENT_AVG:
1144 			switch (ext->desc->type) {
1145 			case POWER_SUPPLY_TYPE_BATTERY:
1146 				di->batt_data.avg_curr_ua = ret.intval;
1147 				break;
1148 			case POWER_SUPPLY_TYPE_USB:
1149 				if (ret.intval)
1150 					di->events.vbus_collapsed = true;
1151 				else
1152 					di->events.vbus_collapsed = false;
1153 				break;
1154 			default:
1155 				break;
1156 			}
1157 			break;
1158 		case POWER_SUPPLY_PROP_CAPACITY:
1159 			if (!capacity_updated)
1160 				di->batt_data.percent = ret.intval;
1161 			break;
1162 		default:
1163 			break;
1164 		}
1165 	}
1166 	return 0;
1167 }
1168 
1169 /**
1170  * ab8500_chargalg_external_power_changed() - callback for power supply changes
1171  * @psy:       pointer to the structure power_supply
1172  *
1173  * This function is the entry point of the pointer external_power_changed
1174  * of the structure power_supply.
1175  * This function gets executed when there is a change in any external power
1176  * supply that this driver needs to be notified of.
1177  */
1178 static void ab8500_chargalg_external_power_changed(struct power_supply *psy)
1179 {
1180 	struct ab8500_chargalg *di = power_supply_get_drvdata(psy);
1181 
1182 	/*
1183 	 * Trigger execution of the algorithm instantly and read
1184 	 * all power_supply properties there instead
1185 	 */
1186 	if (di->chargalg_wq)
1187 		queue_work(di->chargalg_wq, &di->chargalg_work);
1188 }
1189 
1190 /**
1191  * ab8500_chargalg_time_to_restart() - time to restart CC/CV charging?
1192  * @di: charging algorithm state
1193  *
1194  * This checks if the voltage or capacity of the battery has fallen so
1195  * low that we need to restart the CC/CV charge cycle.
1196  */
1197 static bool ab8500_chargalg_time_to_restart(struct ab8500_chargalg *di)
1198 {
1199 	struct power_supply_battery_info *bi = di->bm->bi;
1200 
1201 	/* Sanity check - these need to have some reasonable values */
1202 	if (!di->batt_data.volt_uv || !di->batt_data.percent)
1203 		return false;
1204 
1205 	/* Some batteries tell us at which voltage we should restart charging */
1206 	if (bi->charge_restart_voltage_uv > 0) {
1207 		if (di->batt_data.volt_uv <= bi->charge_restart_voltage_uv)
1208 			return true;
1209 		/* Else we restart as we reach a certain capacity */
1210 	} else {
1211 		if (di->batt_data.percent <= AB8500_RECHARGE_CAP)
1212 			return true;
1213 	}
1214 
1215 	return false;
1216 }
1217 
1218 /**
1219  * ab8500_chargalg_algorithm() - Main function for the algorithm
1220  * @di:		pointer to the ab8500_chargalg structure
1221  *
1222  * This is the main control function for the charging algorithm.
1223  * It is called periodically or when something happens that will
1224  * trigger a state change
1225  */
1226 static void ab8500_chargalg_algorithm(struct ab8500_chargalg *di)
1227 {
1228 	struct power_supply_battery_info *bi = di->bm->bi;
1229 	struct power_supply_maintenance_charge_table *mt;
1230 	int charger_status;
1231 	int ret;
1232 
1233 	/* Collect data from all power_supply class devices */
1234 	class_for_each_device(power_supply_class, NULL,
1235 		di->chargalg_psy, ab8500_chargalg_get_ext_psy_data);
1236 
1237 	ab8500_chargalg_end_of_charge(di);
1238 	ab8500_chargalg_check_temp(di);
1239 	ab8500_chargalg_check_charger_voltage(di);
1240 
1241 	charger_status = ab8500_chargalg_check_charger_connection(di);
1242 
1243 	if (is_ab8500(di->parent)) {
1244 		ret = ab8500_chargalg_check_charger_enable(di);
1245 		if (ret < 0)
1246 			dev_err(di->dev, "Checking charger is enabled error"
1247 					": Returned Value %d\n", ret);
1248 	}
1249 
1250 	/*
1251 	 * First check if we have a charger connected.
1252 	 * Also we don't allow charging of unknown batteries if configured
1253 	 * this way
1254 	 */
1255 	if (!charger_status ||
1256 		(di->events.batt_unknown && !di->bm->chg_unknown_bat)) {
1257 		if (di->charge_state != STATE_HANDHELD) {
1258 			di->events.safety_timer_expired = false;
1259 			ab8500_chargalg_state_to(di, STATE_HANDHELD_INIT);
1260 		}
1261 	}
1262 
1263 	/* Safety timer expiration */
1264 	else if (di->events.safety_timer_expired) {
1265 		if (di->charge_state != STATE_SAFETY_TIMER_EXPIRED)
1266 			ab8500_chargalg_state_to(di,
1267 				STATE_SAFETY_TIMER_EXPIRED_INIT);
1268 	}
1269 	/*
1270 	 * Check if any interrupts has occurred
1271 	 * that will prevent us from charging
1272 	 */
1273 
1274 	/* Battery removed */
1275 	else if (di->events.batt_rem) {
1276 		if (di->charge_state != STATE_BATT_REMOVED)
1277 			ab8500_chargalg_state_to(di, STATE_BATT_REMOVED_INIT);
1278 	}
1279 	/* Main or USB charger not ok. */
1280 	else if (di->events.mainextchnotok || di->events.usbchargernotok) {
1281 		/*
1282 		 * If vbus_collapsed is set, we have to lower the charger
1283 		 * current, which is done in the normal state below
1284 		 */
1285 		if (di->charge_state != STATE_CHG_NOT_OK &&
1286 				!di->events.vbus_collapsed)
1287 			ab8500_chargalg_state_to(di, STATE_CHG_NOT_OK_INIT);
1288 	}
1289 	/* VBUS, Main or VBAT OVV. */
1290 	else if (di->events.vbus_ovv ||
1291 			di->events.main_ovv ||
1292 			di->events.batt_ovv ||
1293 			!di->chg_info.usb_chg_ok ||
1294 			!di->chg_info.ac_chg_ok) {
1295 		if (di->charge_state != STATE_OVV_PROTECT)
1296 			ab8500_chargalg_state_to(di, STATE_OVV_PROTECT_INIT);
1297 	}
1298 	/* USB Thermal, stop charging */
1299 	else if (di->events.main_thermal_prot ||
1300 		di->events.usb_thermal_prot) {
1301 		if (di->charge_state != STATE_HW_TEMP_PROTECT)
1302 			ab8500_chargalg_state_to(di,
1303 				STATE_HW_TEMP_PROTECT_INIT);
1304 	}
1305 	/* Battery temp over/under */
1306 	else if (di->events.btemp_underover) {
1307 		if (di->charge_state != STATE_TEMP_UNDEROVER)
1308 			ab8500_chargalg_state_to(di,
1309 				STATE_TEMP_UNDEROVER_INIT);
1310 	}
1311 	/* Watchdog expired */
1312 	else if (di->events.ac_wd_expired ||
1313 		di->events.usb_wd_expired) {
1314 		if (di->charge_state != STATE_WD_EXPIRED)
1315 			ab8500_chargalg_state_to(di, STATE_WD_EXPIRED_INIT);
1316 	}
1317 	/* Battery temp high/low */
1318 	else if (di->events.btemp_low || di->events.btemp_high) {
1319 		if (di->charge_state != STATE_TEMP_LOWHIGH)
1320 			ab8500_chargalg_state_to(di, STATE_TEMP_LOWHIGH_INIT);
1321 	}
1322 
1323 	dev_dbg(di->dev,
1324 		"[CHARGALG] Vb %d Ib_avg %d Ib_inst %d Tb %d Cap %d Maint %d "
1325 		"State %s Active_chg %d Chg_status %d AC %d USB %d "
1326 		"AC_online %d USB_online %d AC_CV %d USB_CV %d AC_I %d "
1327 		"USB_I %d AC_Vset %d AC_Iset %d USB_Vset %d USB_Iset %d\n",
1328 		di->batt_data.volt_uv,
1329 		di->batt_data.avg_curr_ua,
1330 		di->batt_data.inst_curr_ua,
1331 		di->batt_data.temp,
1332 		di->batt_data.percent,
1333 		di->maintenance_chg,
1334 		states[di->charge_state],
1335 		di->chg_info.charger_type,
1336 		di->charge_status,
1337 		di->chg_info.conn_chg & AC_CHG,
1338 		di->chg_info.conn_chg & USB_CHG,
1339 		di->chg_info.online_chg & AC_CHG,
1340 		di->chg_info.online_chg & USB_CHG,
1341 		di->events.ac_cv_active,
1342 		di->events.usb_cv_active,
1343 		di->chg_info.ac_curr_ua,
1344 		di->chg_info.usb_curr_ua,
1345 		di->chg_info.ac_vset_uv,
1346 		di->chg_info.ac_iset_ua,
1347 		di->chg_info.usb_vset_uv,
1348 		di->chg_info.usb_iset_ua);
1349 
1350 	switch (di->charge_state) {
1351 	case STATE_HANDHELD_INIT:
1352 		ab8500_chargalg_stop_charging(di);
1353 		di->charge_status = POWER_SUPPLY_STATUS_DISCHARGING;
1354 		ab8500_chargalg_state_to(di, STATE_HANDHELD);
1355 		fallthrough;
1356 
1357 	case STATE_HANDHELD:
1358 		break;
1359 
1360 	case STATE_BATT_REMOVED_INIT:
1361 		ab8500_chargalg_stop_charging(di);
1362 		ab8500_chargalg_state_to(di, STATE_BATT_REMOVED);
1363 		fallthrough;
1364 
1365 	case STATE_BATT_REMOVED:
1366 		if (!di->events.batt_rem)
1367 			ab8500_chargalg_state_to(di, STATE_NORMAL_INIT);
1368 		break;
1369 
1370 	case STATE_HW_TEMP_PROTECT_INIT:
1371 		ab8500_chargalg_stop_charging(di);
1372 		ab8500_chargalg_state_to(di, STATE_HW_TEMP_PROTECT);
1373 		fallthrough;
1374 
1375 	case STATE_HW_TEMP_PROTECT:
1376 		if (!di->events.main_thermal_prot &&
1377 				!di->events.usb_thermal_prot)
1378 			ab8500_chargalg_state_to(di, STATE_NORMAL_INIT);
1379 		break;
1380 
1381 	case STATE_OVV_PROTECT_INIT:
1382 		ab8500_chargalg_stop_charging(di);
1383 		ab8500_chargalg_state_to(di, STATE_OVV_PROTECT);
1384 		fallthrough;
1385 
1386 	case STATE_OVV_PROTECT:
1387 		if (!di->events.vbus_ovv &&
1388 				!di->events.main_ovv &&
1389 				!di->events.batt_ovv &&
1390 				di->chg_info.usb_chg_ok &&
1391 				di->chg_info.ac_chg_ok)
1392 			ab8500_chargalg_state_to(di, STATE_NORMAL_INIT);
1393 		break;
1394 
1395 	case STATE_CHG_NOT_OK_INIT:
1396 		ab8500_chargalg_stop_charging(di);
1397 		ab8500_chargalg_state_to(di, STATE_CHG_NOT_OK);
1398 		fallthrough;
1399 
1400 	case STATE_CHG_NOT_OK:
1401 		if (!di->events.mainextchnotok &&
1402 				!di->events.usbchargernotok)
1403 			ab8500_chargalg_state_to(di, STATE_NORMAL_INIT);
1404 		break;
1405 
1406 	case STATE_SAFETY_TIMER_EXPIRED_INIT:
1407 		ab8500_chargalg_stop_charging(di);
1408 		ab8500_chargalg_state_to(di, STATE_SAFETY_TIMER_EXPIRED);
1409 		fallthrough;
1410 
1411 	case STATE_SAFETY_TIMER_EXPIRED:
1412 		/* We exit this state when charger is removed */
1413 		break;
1414 
1415 	case STATE_NORMAL_INIT:
1416 		if (bi->constant_charge_current_max_ua == 0)
1417 			/* "charging" with 0 uA */
1418 			ab8500_chargalg_stop_charging(di);
1419 		else {
1420 			ab8500_chargalg_start_charging(di,
1421 				bi->constant_charge_voltage_max_uv,
1422 				bi->constant_charge_current_max_ua);
1423 		}
1424 
1425 		ab8500_chargalg_state_to(di, STATE_NORMAL);
1426 		ab8500_chargalg_start_safety_timer(di);
1427 		ab8500_chargalg_stop_maintenance_timer(di);
1428 		init_maxim_chg_curr(di);
1429 		di->charge_status = POWER_SUPPLY_STATUS_CHARGING;
1430 		di->eoc_cnt = 0;
1431 		di->maintenance_chg = false;
1432 		power_supply_changed(di->chargalg_psy);
1433 
1434 		break;
1435 
1436 	case STATE_NORMAL:
1437 		handle_maxim_chg_curr(di);
1438 		if (di->charge_status == POWER_SUPPLY_STATUS_FULL &&
1439 			di->maintenance_chg) {
1440 			/*
1441 			 * The battery is fully charged, check if we support
1442 			 * maintenance charging else go back to waiting for
1443 			 * the recharge voltage limit.
1444 			 */
1445 			if (!power_supply_supports_maintenance_charging(bi))
1446 				ab8500_chargalg_state_to(di,
1447 					STATE_WAIT_FOR_RECHARGE_INIT);
1448 			else
1449 				ab8500_chargalg_state_to(di,
1450 					STATE_MAINTENANCE_A_INIT);
1451 		}
1452 		break;
1453 
1454 	/* This state will be used when the maintenance state is disabled */
1455 	case STATE_WAIT_FOR_RECHARGE_INIT:
1456 		ab8500_chargalg_hold_charging(di);
1457 		ab8500_chargalg_state_to(di, STATE_WAIT_FOR_RECHARGE);
1458 		fallthrough;
1459 
1460 	case STATE_WAIT_FOR_RECHARGE:
1461 		if (ab8500_chargalg_time_to_restart(di))
1462 			ab8500_chargalg_state_to(di, STATE_NORMAL_INIT);
1463 		break;
1464 
1465 	case STATE_MAINTENANCE_A_INIT:
1466 		mt = power_supply_get_maintenance_charging_setting(bi, 0);
1467 		if (!mt) {
1468 			/* No maintenance A state, go back to normal */
1469 			ab8500_chargalg_state_to(di, STATE_NORMAL_INIT);
1470 			power_supply_changed(di->chargalg_psy);
1471 			break;
1472 		}
1473 		ab8500_chargalg_stop_safety_timer(di);
1474 		ab8500_chargalg_start_maintenance_timer(di,
1475 			mt->charge_safety_timer_minutes);
1476 		ab8500_chargalg_start_charging(di,
1477 			mt->charge_voltage_max_uv,
1478 			mt->charge_current_max_ua);
1479 		ab8500_chargalg_state_to(di, STATE_MAINTENANCE_A);
1480 		power_supply_changed(di->chargalg_psy);
1481 		fallthrough;
1482 
1483 	case STATE_MAINTENANCE_A:
1484 		if (di->events.maintenance_timer_expired) {
1485 			ab8500_chargalg_stop_maintenance_timer(di);
1486 			ab8500_chargalg_state_to(di, STATE_MAINTENANCE_B_INIT);
1487 		}
1488 		/*
1489 		 * This happens if the voltage drops too quickly during
1490 		 * maintenance charging, especially in older batteries.
1491 		 */
1492 		if (ab8500_chargalg_time_to_restart(di)) {
1493 			ab8500_chargalg_state_to(di, STATE_NORMAL_INIT);
1494 			dev_info(di->dev, "restarted charging from maintenance state A - battery getting old?\n");
1495 		}
1496 		break;
1497 
1498 	case STATE_MAINTENANCE_B_INIT:
1499 		mt = power_supply_get_maintenance_charging_setting(bi, 1);
1500 		if (!mt) {
1501 			/* No maintenance B state, go back to normal */
1502 			ab8500_chargalg_state_to(di, STATE_NORMAL_INIT);
1503 			power_supply_changed(di->chargalg_psy);
1504 			break;
1505 		}
1506 		ab8500_chargalg_start_maintenance_timer(di,
1507 			mt->charge_safety_timer_minutes);
1508 		ab8500_chargalg_start_charging(di,
1509 			mt->charge_voltage_max_uv,
1510 			mt->charge_current_max_ua);
1511 		ab8500_chargalg_state_to(di, STATE_MAINTENANCE_B);
1512 		power_supply_changed(di->chargalg_psy);
1513 		fallthrough;
1514 
1515 	case STATE_MAINTENANCE_B:
1516 		if (di->events.maintenance_timer_expired) {
1517 			ab8500_chargalg_stop_maintenance_timer(di);
1518 			ab8500_chargalg_state_to(di, STATE_NORMAL_INIT);
1519 		}
1520 		/*
1521 		 * This happens if the voltage drops too quickly during
1522 		 * maintenance charging, especially in older batteries.
1523 		 */
1524 		if (ab8500_chargalg_time_to_restart(di)) {
1525 			ab8500_chargalg_state_to(di, STATE_NORMAL_INIT);
1526 			dev_info(di->dev, "restarted charging from maintenance state B - battery getting old?\n");
1527 		}
1528 		break;
1529 
1530 	case STATE_TEMP_LOWHIGH_INIT:
1531 		if (di->events.btemp_low) {
1532 			ab8500_chargalg_start_charging(di,
1533 				       bi->alert_low_temp_charge_voltage_uv,
1534 				       bi->alert_low_temp_charge_current_ua);
1535 		} else if (di->events.btemp_high) {
1536 			ab8500_chargalg_start_charging(di,
1537 				       bi->alert_high_temp_charge_voltage_uv,
1538 				       bi->alert_high_temp_charge_current_ua);
1539 		} else {
1540 			dev_err(di->dev, "neither low or high temp event occurred\n");
1541 			ab8500_chargalg_state_to(di, STATE_NORMAL_INIT);
1542 			break;
1543 		}
1544 		ab8500_chargalg_stop_maintenance_timer(di);
1545 		di->charge_status = POWER_SUPPLY_STATUS_CHARGING;
1546 		ab8500_chargalg_state_to(di, STATE_TEMP_LOWHIGH);
1547 		power_supply_changed(di->chargalg_psy);
1548 		fallthrough;
1549 
1550 	case STATE_TEMP_LOWHIGH:
1551 		if (!di->events.btemp_low && !di->events.btemp_high)
1552 			ab8500_chargalg_state_to(di, STATE_NORMAL_INIT);
1553 		break;
1554 
1555 	case STATE_WD_EXPIRED_INIT:
1556 		ab8500_chargalg_stop_charging(di);
1557 		ab8500_chargalg_state_to(di, STATE_WD_EXPIRED);
1558 		fallthrough;
1559 
1560 	case STATE_WD_EXPIRED:
1561 		if (!di->events.ac_wd_expired &&
1562 				!di->events.usb_wd_expired)
1563 			ab8500_chargalg_state_to(di, STATE_NORMAL_INIT);
1564 		break;
1565 
1566 	case STATE_TEMP_UNDEROVER_INIT:
1567 		ab8500_chargalg_stop_charging(di);
1568 		ab8500_chargalg_state_to(di, STATE_TEMP_UNDEROVER);
1569 		fallthrough;
1570 
1571 	case STATE_TEMP_UNDEROVER:
1572 		if (!di->events.btemp_underover)
1573 			ab8500_chargalg_state_to(di, STATE_NORMAL_INIT);
1574 		break;
1575 	}
1576 
1577 	/* Start charging directly if the new state is a charge state */
1578 	if (di->charge_state == STATE_NORMAL_INIT ||
1579 			di->charge_state == STATE_MAINTENANCE_A_INIT ||
1580 			di->charge_state == STATE_MAINTENANCE_B_INIT)
1581 		queue_work(di->chargalg_wq, &di->chargalg_work);
1582 }
1583 
1584 /**
1585  * ab8500_chargalg_periodic_work() - Periodic work for the algorithm
1586  * @work:	pointer to the work_struct structure
1587  *
1588  * Work queue function for the charging algorithm
1589  */
1590 static void ab8500_chargalg_periodic_work(struct work_struct *work)
1591 {
1592 	struct ab8500_chargalg *di = container_of(work,
1593 		struct ab8500_chargalg, chargalg_periodic_work.work);
1594 
1595 	ab8500_chargalg_algorithm(di);
1596 
1597 	/*
1598 	 * If a charger is connected then the battery has to be monitored
1599 	 * frequently, else the work can be delayed.
1600 	 */
1601 	if (di->chg_info.conn_chg)
1602 		queue_delayed_work(di->chargalg_wq,
1603 			&di->chargalg_periodic_work,
1604 			di->bm->interval_charging * HZ);
1605 	else
1606 		queue_delayed_work(di->chargalg_wq,
1607 			&di->chargalg_periodic_work,
1608 			di->bm->interval_not_charging * HZ);
1609 }
1610 
1611 /**
1612  * ab8500_chargalg_wd_work() - periodic work to kick the charger watchdog
1613  * @work:	pointer to the work_struct structure
1614  *
1615  * Work queue function for kicking the charger watchdog
1616  */
1617 static void ab8500_chargalg_wd_work(struct work_struct *work)
1618 {
1619 	int ret;
1620 	struct ab8500_chargalg *di = container_of(work,
1621 		struct ab8500_chargalg, chargalg_wd_work.work);
1622 
1623 	ret = ab8500_chargalg_kick_watchdog(di);
1624 	if (ret < 0)
1625 		dev_err(di->dev, "failed to kick watchdog\n");
1626 
1627 	queue_delayed_work(di->chargalg_wq,
1628 		&di->chargalg_wd_work, CHG_WD_INTERVAL);
1629 }
1630 
1631 /**
1632  * ab8500_chargalg_work() - Work to run the charging algorithm instantly
1633  * @work:	pointer to the work_struct structure
1634  *
1635  * Work queue function for calling the charging algorithm
1636  */
1637 static void ab8500_chargalg_work(struct work_struct *work)
1638 {
1639 	struct ab8500_chargalg *di = container_of(work,
1640 		struct ab8500_chargalg, chargalg_work);
1641 
1642 	ab8500_chargalg_algorithm(di);
1643 }
1644 
1645 /**
1646  * ab8500_chargalg_get_property() - get the chargalg properties
1647  * @psy:	pointer to the power_supply structure
1648  * @psp:	pointer to the power_supply_property structure
1649  * @val:	pointer to the power_supply_propval union
1650  *
1651  * This function gets called when an application tries to get the
1652  * chargalg properties by reading the sysfs files.
1653  * status:     charging/discharging/full/unknown
1654  * health:     health of the battery
1655  * Returns error code in case of failure else 0 on success
1656  */
1657 static int ab8500_chargalg_get_property(struct power_supply *psy,
1658 	enum power_supply_property psp,
1659 	union power_supply_propval *val)
1660 {
1661 	struct ab8500_chargalg *di = power_supply_get_drvdata(psy);
1662 
1663 	switch (psp) {
1664 	case POWER_SUPPLY_PROP_STATUS:
1665 		val->intval = di->charge_status;
1666 		break;
1667 	case POWER_SUPPLY_PROP_HEALTH:
1668 		if (di->events.batt_ovv) {
1669 			val->intval = POWER_SUPPLY_HEALTH_OVERVOLTAGE;
1670 		} else if (di->events.btemp_underover) {
1671 			if (di->batt_data.temp <= di->bm->bi->temp_min)
1672 				val->intval = POWER_SUPPLY_HEALTH_COLD;
1673 			else
1674 				val->intval = POWER_SUPPLY_HEALTH_OVERHEAT;
1675 		} else if (di->charge_state == STATE_SAFETY_TIMER_EXPIRED ||
1676 			   di->charge_state == STATE_SAFETY_TIMER_EXPIRED_INIT) {
1677 			val->intval = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
1678 		} else {
1679 			val->intval = POWER_SUPPLY_HEALTH_GOOD;
1680 		}
1681 		break;
1682 	default:
1683 		return -EINVAL;
1684 	}
1685 	return 0;
1686 }
1687 
1688 static int __maybe_unused ab8500_chargalg_resume(struct device *dev)
1689 {
1690 	struct ab8500_chargalg *di = dev_get_drvdata(dev);
1691 
1692 	/* Kick charger watchdog if charging (any charger online) */
1693 	if (di->chg_info.online_chg)
1694 		queue_delayed_work(di->chargalg_wq, &di->chargalg_wd_work, 0);
1695 
1696 	/*
1697 	 * Run the charging algorithm directly to be sure we don't
1698 	 * do it too seldom
1699 	 */
1700 	queue_delayed_work(di->chargalg_wq, &di->chargalg_periodic_work, 0);
1701 
1702 	return 0;
1703 }
1704 
1705 static int __maybe_unused ab8500_chargalg_suspend(struct device *dev)
1706 {
1707 	struct ab8500_chargalg *di = dev_get_drvdata(dev);
1708 
1709 	if (di->chg_info.online_chg)
1710 		cancel_delayed_work_sync(&di->chargalg_wd_work);
1711 
1712 	cancel_delayed_work_sync(&di->chargalg_periodic_work);
1713 
1714 	return 0;
1715 }
1716 
1717 static char *supply_interface[] = {
1718 	"ab8500_fg",
1719 };
1720 
1721 static const struct power_supply_desc ab8500_chargalg_desc = {
1722 	.name			= "ab8500_chargalg",
1723 	.type			= POWER_SUPPLY_TYPE_BATTERY,
1724 	.properties		= ab8500_chargalg_props,
1725 	.num_properties		= ARRAY_SIZE(ab8500_chargalg_props),
1726 	.get_property		= ab8500_chargalg_get_property,
1727 	.external_power_changed	= ab8500_chargalg_external_power_changed,
1728 };
1729 
1730 static int ab8500_chargalg_bind(struct device *dev, struct device *master,
1731 				void *data)
1732 {
1733 	struct ab8500_chargalg *di = dev_get_drvdata(dev);
1734 
1735 	/* Create a work queue for the chargalg */
1736 	di->chargalg_wq = alloc_ordered_workqueue("ab8500_chargalg_wq",
1737 						  WQ_MEM_RECLAIM);
1738 	if (di->chargalg_wq == NULL) {
1739 		dev_err(di->dev, "failed to create work queue\n");
1740 		return -ENOMEM;
1741 	}
1742 
1743 	/* Run the charging algorithm */
1744 	queue_delayed_work(di->chargalg_wq, &di->chargalg_periodic_work, 0);
1745 
1746 	return 0;
1747 }
1748 
1749 static void ab8500_chargalg_unbind(struct device *dev, struct device *master,
1750 				   void *data)
1751 {
1752 	struct ab8500_chargalg *di = dev_get_drvdata(dev);
1753 
1754 	/* Stop all timers and work */
1755 	hrtimer_cancel(&di->safety_timer);
1756 	hrtimer_cancel(&di->maintenance_timer);
1757 
1758 	cancel_delayed_work_sync(&di->chargalg_periodic_work);
1759 	cancel_delayed_work_sync(&di->chargalg_wd_work);
1760 	cancel_work_sync(&di->chargalg_work);
1761 
1762 	/* Delete the work queue */
1763 	destroy_workqueue(di->chargalg_wq);
1764 }
1765 
1766 static const struct component_ops ab8500_chargalg_component_ops = {
1767 	.bind = ab8500_chargalg_bind,
1768 	.unbind = ab8500_chargalg_unbind,
1769 };
1770 
1771 static int ab8500_chargalg_probe(struct platform_device *pdev)
1772 {
1773 	struct device *dev = &pdev->dev;
1774 	struct power_supply_config psy_cfg = {};
1775 	struct ab8500_chargalg *di;
1776 
1777 	di = devm_kzalloc(dev, sizeof(*di), GFP_KERNEL);
1778 	if (!di)
1779 		return -ENOMEM;
1780 
1781 	di->bm = &ab8500_bm_data;
1782 
1783 	/* get device struct and parent */
1784 	di->dev = dev;
1785 	di->parent = dev_get_drvdata(pdev->dev.parent);
1786 
1787 	psy_cfg.supplied_to = supply_interface;
1788 	psy_cfg.num_supplicants = ARRAY_SIZE(supply_interface);
1789 	psy_cfg.drv_data = di;
1790 
1791 	/* Initilialize safety timer */
1792 	hrtimer_init(&di->safety_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
1793 	di->safety_timer.function = ab8500_chargalg_safety_timer_expired;
1794 
1795 	/* Initilialize maintenance timer */
1796 	hrtimer_init(&di->maintenance_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
1797 	di->maintenance_timer.function =
1798 		ab8500_chargalg_maintenance_timer_expired;
1799 
1800 	/* Init work for chargalg */
1801 	INIT_DEFERRABLE_WORK(&di->chargalg_periodic_work,
1802 		ab8500_chargalg_periodic_work);
1803 	INIT_DEFERRABLE_WORK(&di->chargalg_wd_work,
1804 		ab8500_chargalg_wd_work);
1805 
1806 	/* Init work for chargalg */
1807 	INIT_WORK(&di->chargalg_work, ab8500_chargalg_work);
1808 
1809 	/* To detect charger at startup */
1810 	di->chg_info.prev_conn_chg = -1;
1811 
1812 	/* Register chargalg power supply class */
1813 	di->chargalg_psy = devm_power_supply_register(di->dev,
1814 						 &ab8500_chargalg_desc,
1815 						 &psy_cfg);
1816 	if (IS_ERR(di->chargalg_psy)) {
1817 		dev_err(di->dev, "failed to register chargalg psy\n");
1818 		return PTR_ERR(di->chargalg_psy);
1819 	}
1820 
1821 	platform_set_drvdata(pdev, di);
1822 
1823 	dev_info(di->dev, "probe success\n");
1824 	return component_add(dev, &ab8500_chargalg_component_ops);
1825 }
1826 
1827 static int ab8500_chargalg_remove(struct platform_device *pdev)
1828 {
1829 	component_del(&pdev->dev, &ab8500_chargalg_component_ops);
1830 
1831 	return 0;
1832 }
1833 
1834 static SIMPLE_DEV_PM_OPS(ab8500_chargalg_pm_ops, ab8500_chargalg_suspend, ab8500_chargalg_resume);
1835 
1836 static const struct of_device_id ab8500_chargalg_match[] = {
1837 	{ .compatible = "stericsson,ab8500-chargalg", },
1838 	{ },
1839 };
1840 
1841 struct platform_driver ab8500_chargalg_driver = {
1842 	.probe = ab8500_chargalg_probe,
1843 	.remove = ab8500_chargalg_remove,
1844 	.driver = {
1845 		.name = "ab8500_chargalg",
1846 		.of_match_table = ab8500_chargalg_match,
1847 		.pm = &ab8500_chargalg_pm_ops,
1848 	},
1849 };
1850 MODULE_LICENSE("GPL v2");
1851 MODULE_AUTHOR("Johan Palsson, Karl Komierowski");
1852 MODULE_ALIAS("platform:ab8500-chargalg");
1853 MODULE_DESCRIPTION("ab8500 battery charging algorithm");
1854