1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * Copyright (C) ST-Ericsson SA 2012
4  *
5  * Charger driver for AB8500
6  *
7  * Author:
8  *	Johan Palsson <johan.palsson@stericsson.com>
9  *	Karl Komierowski <karl.komierowski@stericsson.com>
10  *	Arun R Murthy <arun.murthy@stericsson.com>
11  */
12 
13 #include <linux/init.h>
14 #include <linux/module.h>
15 #include <linux/device.h>
16 #include <linux/component.h>
17 #include <linux/interrupt.h>
18 #include <linux/delay.h>
19 #include <linux/notifier.h>
20 #include <linux/slab.h>
21 #include <linux/platform_device.h>
22 #include <linux/power_supply.h>
23 #include <linux/completion.h>
24 #include <linux/regulator/consumer.h>
25 #include <linux/err.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/ab8500.h>
31 #include <linux/mfd/abx500.h>
32 #include <linux/usb/otg.h>
33 #include <linux/mutex.h>
34 #include <linux/iio/consumer.h>
35 
36 #include "ab8500-bm.h"
37 #include "ab8500-chargalg.h"
38 
39 /* Charger constants */
40 #define NO_PW_CONN			0
41 #define AC_PW_CONN			1
42 #define USB_PW_CONN			2
43 
44 #define MAIN_WDOG_ENA			0x01
45 #define MAIN_WDOG_KICK			0x02
46 #define MAIN_WDOG_DIS			0x00
47 #define CHARG_WD_KICK			0x01
48 #define MAIN_CH_ENA			0x01
49 #define MAIN_CH_NO_OVERSHOOT_ENA_N	0x02
50 #define USB_CH_ENA			0x01
51 #define USB_CHG_NO_OVERSHOOT_ENA_N	0x02
52 #define MAIN_CH_DET			0x01
53 #define MAIN_CH_CV_ON			0x04
54 #define USB_CH_CV_ON			0x08
55 #define VBUS_DET_DBNC100		0x02
56 #define VBUS_DET_DBNC1			0x01
57 #define OTP_ENABLE_WD			0x01
58 #define DROP_COUNT_RESET		0x01
59 #define USB_CH_DET			0x01
60 
61 #define MAIN_CH_INPUT_CURR_SHIFT	4
62 #define VBUS_IN_CURR_LIM_SHIFT		4
63 #define AUTO_VBUS_IN_CURR_LIM_SHIFT	4
64 #define VBUS_IN_CURR_LIM_RETRY_SET_TIME	30 /* seconds */
65 
66 #define LED_INDICATOR_PWM_ENA		0x01
67 #define LED_INDICATOR_PWM_DIS		0x00
68 #define LED_IND_CUR_5MA			0x04
69 #define LED_INDICATOR_PWM_DUTY_252_256	0xBF
70 
71 /* HW failure constants */
72 #define MAIN_CH_TH_PROT			0x02
73 #define VBUS_CH_NOK			0x08
74 #define USB_CH_TH_PROT			0x02
75 #define VBUS_OVV_TH			0x01
76 #define MAIN_CH_NOK			0x01
77 #define VBUS_DET			0x80
78 
79 #define MAIN_CH_STATUS2_MAINCHGDROP		0x80
80 #define MAIN_CH_STATUS2_MAINCHARGERDETDBNC	0x40
81 #define USB_CH_VBUSDROP				0x40
82 #define USB_CH_VBUSDETDBNC			0x01
83 
84 /* UsbLineStatus register bit masks */
85 #define AB8500_USB_LINK_STATUS		0x78
86 #define AB8505_USB_LINK_STATUS		0xF8
87 #define AB8500_STD_HOST_SUSP		0x18
88 #define USB_LINK_STATUS_SHIFT		3
89 
90 /* Watchdog timeout constant */
91 #define WD_TIMER			0x30 /* 4min */
92 #define WD_KICK_INTERVAL		(60 * HZ)
93 
94 /* Lowest charger voltage is 3.39V -> 0x4E */
95 #define LOW_VOLT_REG			0x4E
96 
97 /* Step up/down delay in us */
98 #define STEP_UDELAY			1000
99 
100 #define CHARGER_STATUS_POLL 10 /* in ms */
101 
102 #define CHG_WD_INTERVAL			(60 * HZ)
103 
104 #define AB8500_SW_CONTROL_FALLBACK	0x03
105 /* Wait for enumeration before charing in us */
106 #define WAIT_ACA_RID_ENUMERATION	(5 * 1000)
107 /*External charger control*/
108 #define AB8500_SYS_CHARGER_CONTROL_REG		0x52
109 #define EXTERNAL_CHARGER_DISABLE_REG_VAL	0x03
110 #define EXTERNAL_CHARGER_ENABLE_REG_VAL		0x07
111 
112 /* UsbLineStatus register - usb types */
113 enum ab8500_charger_link_status {
114 	USB_STAT_NOT_CONFIGURED,
115 	USB_STAT_STD_HOST_NC,
116 	USB_STAT_STD_HOST_C_NS,
117 	USB_STAT_STD_HOST_C_S,
118 	USB_STAT_HOST_CHG_NM,
119 	USB_STAT_HOST_CHG_HS,
120 	USB_STAT_HOST_CHG_HS_CHIRP,
121 	USB_STAT_DEDICATED_CHG,
122 	USB_STAT_ACA_RID_A,
123 	USB_STAT_ACA_RID_B,
124 	USB_STAT_ACA_RID_C_NM,
125 	USB_STAT_ACA_RID_C_HS,
126 	USB_STAT_ACA_RID_C_HS_CHIRP,
127 	USB_STAT_HM_IDGND,
128 	USB_STAT_RESERVED,
129 	USB_STAT_NOT_VALID_LINK,
130 	USB_STAT_PHY_EN,
131 	USB_STAT_SUP_NO_IDGND_VBUS,
132 	USB_STAT_SUP_IDGND_VBUS,
133 	USB_STAT_CHARGER_LINE_1,
134 	USB_STAT_CARKIT_1,
135 	USB_STAT_CARKIT_2,
136 	USB_STAT_ACA_DOCK_CHARGER,
137 };
138 
139 enum ab8500_usb_state {
140 	AB8500_BM_USB_STATE_RESET_HS,	/* HighSpeed Reset */
141 	AB8500_BM_USB_STATE_RESET_FS,	/* FullSpeed/LowSpeed Reset */
142 	AB8500_BM_USB_STATE_CONFIGURED,
143 	AB8500_BM_USB_STATE_SUSPEND,
144 	AB8500_BM_USB_STATE_RESUME,
145 	AB8500_BM_USB_STATE_MAX,
146 };
147 
148 /* VBUS input current limits supported in AB8500 in uA */
149 #define USB_CH_IP_CUR_LVL_0P05		50000
150 #define USB_CH_IP_CUR_LVL_0P09		98000
151 #define USB_CH_IP_CUR_LVL_0P19		193000
152 #define USB_CH_IP_CUR_LVL_0P29		290000
153 #define USB_CH_IP_CUR_LVL_0P38		380000
154 #define USB_CH_IP_CUR_LVL_0P45		450000
155 #define USB_CH_IP_CUR_LVL_0P5		500000
156 #define USB_CH_IP_CUR_LVL_0P6		600000
157 #define USB_CH_IP_CUR_LVL_0P7		700000
158 #define USB_CH_IP_CUR_LVL_0P8		800000
159 #define USB_CH_IP_CUR_LVL_0P9		900000
160 #define USB_CH_IP_CUR_LVL_1P0		1000000
161 #define USB_CH_IP_CUR_LVL_1P1		1100000
162 #define USB_CH_IP_CUR_LVL_1P3		1300000
163 #define USB_CH_IP_CUR_LVL_1P4		1400000
164 #define USB_CH_IP_CUR_LVL_1P5		1500000
165 
166 #define VBAT_TRESH_IP_CUR_RED		3800000
167 
168 #define to_ab8500_charger_usb_device_info(x) container_of((x), \
169 	struct ab8500_charger, usb_chg)
170 #define to_ab8500_charger_ac_device_info(x) container_of((x), \
171 	struct ab8500_charger, ac_chg)
172 
173 /**
174  * struct ab8500_charger_interrupts - ab8500 interrupts
175  * @name:	name of the interrupt
176  * @isr		function pointer to the isr
177  */
178 struct ab8500_charger_interrupts {
179 	char *name;
180 	irqreturn_t (*isr)(int irq, void *data);
181 };
182 
183 struct ab8500_charger_info {
184 	int charger_connected;
185 	int charger_online;
186 	int charger_voltage_uv;
187 	int cv_active;
188 	bool wd_expired;
189 	int charger_current_ua;
190 };
191 
192 struct ab8500_charger_event_flags {
193 	bool mainextchnotok;
194 	bool main_thermal_prot;
195 	bool usb_thermal_prot;
196 	bool vbus_ovv;
197 	bool usbchargernotok;
198 	bool chgwdexp;
199 	bool vbus_collapse;
200 	bool vbus_drop_end;
201 };
202 
203 struct ab8500_charger_usb_state {
204 	int usb_current_ua;
205 	int usb_current_tmp_ua;
206 	enum ab8500_usb_state state;
207 	enum ab8500_usb_state state_tmp;
208 	spinlock_t usb_lock;
209 };
210 
211 struct ab8500_charger_max_usb_in_curr {
212 	int usb_type_max_ua;
213 	int set_max_ua;
214 	int calculated_max_ua;
215 };
216 
217 /**
218  * struct ab8500_charger - ab8500 Charger device information
219  * @dev:		Pointer to the structure device
220  * @vbus_detected:	VBUS detected
221  * @vbus_detected_start:
222  *			VBUS detected during startup
223  * @ac_conn:		This will be true when the AC charger has been plugged
224  * @vddadc_en_ac:	Indicate if VDD ADC supply is enabled because AC
225  *			charger is enabled
226  * @vddadc_en_usb:	Indicate if VDD ADC supply is enabled because USB
227  *			charger is enabled
228  * @vbat		Battery voltage
229  * @old_vbat		Previously measured battery voltage
230  * @usb_device_is_unrecognised	USB device is unrecognised by the hardware
231  * @autopower		Indicate if we should have automatic pwron after pwrloss
232  * @autopower_cfg	platform specific power config support for "pwron after pwrloss"
233  * @invalid_charger_detect_state State when forcing AB to use invalid charger
234  * @is_aca_rid:		Incicate if accessory is ACA type
235  * @current_stepping_sessions:
236  *			Counter for current stepping sessions
237  * @parent:		Pointer to the struct ab8500
238  * @adc_main_charger_v	ADC channel for main charger voltage
239  * @adc_main_charger_c	ADC channel for main charger current
240  * @adc_vbus_v		ADC channel for USB charger voltage
241  * @adc_usb_charger_c	ADC channel for USB charger current
242  * @bm:           	Platform specific battery management information
243  * @flags:		Structure for information about events triggered
244  * @usb_state:		Structure for usb stack information
245  * @max_usb_in_curr:	Max USB charger input current
246  * @ac_chg:		AC charger power supply
247  * @usb_chg:		USB charger power supply
248  * @ac:			Structure that holds the AC charger properties
249  * @usb:		Structure that holds the USB charger properties
250  * @regu:		Pointer to the struct regulator
251  * @charger_wq:		Work queue for the IRQs and checking HW state
252  * @usb_ipt_crnt_lock:	Lock to protect VBUS input current setting from mutuals
253  * @pm_lock:		Lock to prevent system to suspend
254  * @check_vbat_work	Work for checking vbat threshold to adjust vbus current
255  * @check_hw_failure_work:	Work for checking HW state
256  * @check_usbchgnotok_work:	Work for checking USB charger not ok status
257  * @kick_wd_work:		Work for kicking the charger watchdog in case
258  *				of ABB rev 1.* due to the watchog logic bug
259  * @ac_charger_attached_work:	Work for checking if AC charger is still
260  *				connected
261  * @usb_charger_attached_work:	Work for checking if USB charger is still
262  *				connected
263  * @ac_work:			Work for checking AC charger connection
264  * @detect_usb_type_work:	Work for detecting the USB type connected
265  * @usb_link_status_work:	Work for checking the new USB link status
266  * @usb_state_changed_work:	Work for checking USB state
267  * @attach_work:		Work for detecting USB type
268  * @vbus_drop_end_work:		Work for detecting VBUS drop end
269  * @check_main_thermal_prot_work:
270  *				Work for checking Main thermal status
271  * @check_usb_thermal_prot_work:
272  *				Work for checking USB thermal status
273  * @charger_attached_mutex:	For controlling the wakelock
274  */
275 struct ab8500_charger {
276 	struct device *dev;
277 	bool vbus_detected;
278 	bool vbus_detected_start;
279 	bool ac_conn;
280 	bool vddadc_en_ac;
281 	bool vddadc_en_usb;
282 	int vbat;
283 	int old_vbat;
284 	bool usb_device_is_unrecognised;
285 	bool autopower;
286 	bool autopower_cfg;
287 	int invalid_charger_detect_state;
288 	int is_aca_rid;
289 	atomic_t current_stepping_sessions;
290 	struct ab8500 *parent;
291 	struct iio_channel *adc_main_charger_v;
292 	struct iio_channel *adc_main_charger_c;
293 	struct iio_channel *adc_vbus_v;
294 	struct iio_channel *adc_usb_charger_c;
295 	struct ab8500_bm_data *bm;
296 	struct ab8500_charger_event_flags flags;
297 	struct ab8500_charger_usb_state usb_state;
298 	struct ab8500_charger_max_usb_in_curr max_usb_in_curr;
299 	struct ux500_charger ac_chg;
300 	struct ux500_charger usb_chg;
301 	struct ab8500_charger_info ac;
302 	struct ab8500_charger_info usb;
303 	struct regulator *regu;
304 	struct workqueue_struct *charger_wq;
305 	struct mutex usb_ipt_crnt_lock;
306 	struct delayed_work check_vbat_work;
307 	struct delayed_work check_hw_failure_work;
308 	struct delayed_work check_usbchgnotok_work;
309 	struct delayed_work kick_wd_work;
310 	struct delayed_work usb_state_changed_work;
311 	struct delayed_work attach_work;
312 	struct delayed_work ac_charger_attached_work;
313 	struct delayed_work usb_charger_attached_work;
314 	struct delayed_work vbus_drop_end_work;
315 	struct work_struct ac_work;
316 	struct work_struct detect_usb_type_work;
317 	struct work_struct usb_link_status_work;
318 	struct work_struct check_main_thermal_prot_work;
319 	struct work_struct check_usb_thermal_prot_work;
320 	struct usb_phy *usb_phy;
321 	struct notifier_block nb;
322 	struct mutex charger_attached_mutex;
323 };
324 
325 /* AC properties */
326 static enum power_supply_property ab8500_charger_ac_props[] = {
327 	POWER_SUPPLY_PROP_HEALTH,
328 	POWER_SUPPLY_PROP_PRESENT,
329 	POWER_SUPPLY_PROP_ONLINE,
330 	POWER_SUPPLY_PROP_VOLTAGE_NOW,
331 	POWER_SUPPLY_PROP_VOLTAGE_AVG,
332 	POWER_SUPPLY_PROP_CURRENT_NOW,
333 };
334 
335 /* USB properties */
336 static enum power_supply_property ab8500_charger_usb_props[] = {
337 	POWER_SUPPLY_PROP_HEALTH,
338 	POWER_SUPPLY_PROP_CURRENT_AVG,
339 	POWER_SUPPLY_PROP_PRESENT,
340 	POWER_SUPPLY_PROP_ONLINE,
341 	POWER_SUPPLY_PROP_VOLTAGE_NOW,
342 	POWER_SUPPLY_PROP_VOLTAGE_AVG,
343 	POWER_SUPPLY_PROP_CURRENT_NOW,
344 };
345 
346 /*
347  * Function for enabling and disabling sw fallback mode
348  * should always be disabled when no charger is connected.
349  */
350 static void ab8500_enable_disable_sw_fallback(struct ab8500_charger *di,
351 		bool fallback)
352 {
353 	u8 val;
354 	u8 reg;
355 	u8 bank;
356 	u8 bit;
357 	int ret;
358 
359 	dev_dbg(di->dev, "SW Fallback: %d\n", fallback);
360 
361 	if (is_ab8500(di->parent)) {
362 		bank = 0x15;
363 		reg = 0x0;
364 		bit = 3;
365 	} else {
366 		bank = AB8500_SYS_CTRL1_BLOCK;
367 		reg = AB8500_SW_CONTROL_FALLBACK;
368 		bit = 0;
369 	}
370 
371 	/* read the register containing fallback bit */
372 	ret = abx500_get_register_interruptible(di->dev, bank, reg, &val);
373 	if (ret < 0) {
374 		dev_err(di->dev, "%d read failed\n", __LINE__);
375 		return;
376 	}
377 
378 	if (is_ab8500(di->parent)) {
379 		/* enable the OPT emulation registers */
380 		ret = abx500_set_register_interruptible(di->dev, 0x11, 0x00, 0x2);
381 		if (ret) {
382 			dev_err(di->dev, "%d write failed\n", __LINE__);
383 			goto disable_otp;
384 		}
385 	}
386 
387 	if (fallback)
388 		val |= (1 << bit);
389 	else
390 		val &= ~(1 << bit);
391 
392 	/* write back the changed fallback bit value to register */
393 	ret = abx500_set_register_interruptible(di->dev, bank, reg, val);
394 	if (ret) {
395 		dev_err(di->dev, "%d write failed\n", __LINE__);
396 	}
397 
398 disable_otp:
399 	if (is_ab8500(di->parent)) {
400 		/* disable the set OTP registers again */
401 		ret = abx500_set_register_interruptible(di->dev, 0x11, 0x00, 0x0);
402 		if (ret) {
403 			dev_err(di->dev, "%d write failed\n", __LINE__);
404 		}
405 	}
406 }
407 
408 /**
409  * ab8500_power_supply_changed - a wrapper with local extensions for
410  * power_supply_changed
411  * @di:	  pointer to the ab8500_charger structure
412  * @psy:  pointer to power_supply_that have changed.
413  *
414  */
415 static void ab8500_power_supply_changed(struct ab8500_charger *di,
416 					struct power_supply *psy)
417 {
418 	/*
419 	 * This happens if we get notifications or interrupts and
420 	 * the platform has been configured not to support one or
421 	 * other type of charging.
422 	 */
423 	if (!psy)
424 		return;
425 
426 	if (di->autopower_cfg) {
427 		if (!di->usb.charger_connected &&
428 		    !di->ac.charger_connected &&
429 		    di->autopower) {
430 			di->autopower = false;
431 			ab8500_enable_disable_sw_fallback(di, false);
432 		} else if (!di->autopower &&
433 			   (di->ac.charger_connected ||
434 			    di->usb.charger_connected)) {
435 			di->autopower = true;
436 			ab8500_enable_disable_sw_fallback(di, true);
437 		}
438 	}
439 	power_supply_changed(psy);
440 }
441 
442 static void ab8500_charger_set_usb_connected(struct ab8500_charger *di,
443 	bool connected)
444 {
445 	if (connected != di->usb.charger_connected) {
446 		dev_dbg(di->dev, "USB connected:%i\n", connected);
447 		di->usb.charger_connected = connected;
448 
449 		if (!connected)
450 			di->flags.vbus_drop_end = false;
451 
452 		/*
453 		 * Sometimes the platform is configured not to support
454 		 * USB charging and no psy has been created, but we still
455 		 * will get these notifications.
456 		 */
457 		if (di->usb_chg.psy) {
458 			sysfs_notify(&di->usb_chg.psy->dev.kobj, NULL,
459 				     "present");
460 		}
461 
462 		if (connected) {
463 			mutex_lock(&di->charger_attached_mutex);
464 			mutex_unlock(&di->charger_attached_mutex);
465 
466 			if (is_ab8500(di->parent))
467 				queue_delayed_work(di->charger_wq,
468 					   &di->usb_charger_attached_work,
469 					   HZ);
470 		} else {
471 			cancel_delayed_work_sync(&di->usb_charger_attached_work);
472 			mutex_lock(&di->charger_attached_mutex);
473 			mutex_unlock(&di->charger_attached_mutex);
474 		}
475 	}
476 }
477 
478 /**
479  * ab8500_charger_get_ac_voltage() - get ac charger voltage
480  * @di:		pointer to the ab8500_charger structure
481  *
482  * Returns ac charger voltage in microvolt (on success)
483  */
484 static int ab8500_charger_get_ac_voltage(struct ab8500_charger *di)
485 {
486 	int vch, ret;
487 
488 	/* Only measure voltage if the charger is connected */
489 	if (di->ac.charger_connected) {
490 		ret = iio_read_channel_processed(di->adc_main_charger_v, &vch);
491 		if (ret < 0)
492 			dev_err(di->dev, "%s ADC conv failed,\n", __func__);
493 	} else {
494 		vch = 0;
495 	}
496 	/* Convert to microvolt, IIO returns millivolt */
497 	return vch * 1000;
498 }
499 
500 /**
501  * ab8500_charger_ac_cv() - check if the main charger is in CV mode
502  * @di:		pointer to the ab8500_charger structure
503  *
504  * Returns ac charger CV mode (on success) else error code
505  */
506 static int ab8500_charger_ac_cv(struct ab8500_charger *di)
507 {
508 	u8 val;
509 	int ret = 0;
510 
511 	/* Only check CV mode if the charger is online */
512 	if (di->ac.charger_online) {
513 		ret = abx500_get_register_interruptible(di->dev, AB8500_CHARGER,
514 			AB8500_CH_STATUS1_REG, &val);
515 		if (ret < 0) {
516 			dev_err(di->dev, "%s ab8500 read failed\n", __func__);
517 			return 0;
518 		}
519 
520 		if (val & MAIN_CH_CV_ON)
521 			ret = 1;
522 		else
523 			ret = 0;
524 	}
525 
526 	return ret;
527 }
528 
529 /**
530  * ab8500_charger_get_vbus_voltage() - get vbus voltage
531  * @di:		pointer to the ab8500_charger structure
532  *
533  * This function returns the vbus voltage.
534  * Returns vbus voltage in microvolt (on success)
535  */
536 static int ab8500_charger_get_vbus_voltage(struct ab8500_charger *di)
537 {
538 	int vch, ret;
539 
540 	/* Only measure voltage if the charger is connected */
541 	if (di->usb.charger_connected) {
542 		ret = iio_read_channel_processed(di->adc_vbus_v, &vch);
543 		if (ret < 0)
544 			dev_err(di->dev, "%s ADC conv failed,\n", __func__);
545 	} else {
546 		vch = 0;
547 	}
548 	/* Convert to microvolt, IIO returns millivolt */
549 	return vch * 1000;
550 }
551 
552 /**
553  * ab8500_charger_get_usb_current() - get usb charger current
554  * @di:		pointer to the ab8500_charger structure
555  *
556  * This function returns the usb charger current.
557  * Returns usb current in microamperes (on success) and error code on failure
558  */
559 static int ab8500_charger_get_usb_current(struct ab8500_charger *di)
560 {
561 	int ich, ret;
562 
563 	/* Only measure current if the charger is online */
564 	if (di->usb.charger_online) {
565 		ret = iio_read_channel_processed(di->adc_usb_charger_c, &ich);
566 		if (ret < 0)
567 			dev_err(di->dev, "%s ADC conv failed,\n", __func__);
568 	} else {
569 		ich = 0;
570 	}
571 	/* Return microamperes */
572 	return ich * 1000;
573 }
574 
575 /**
576  * ab8500_charger_get_ac_current() - get ac charger current
577  * @di:		pointer to the ab8500_charger structure
578  *
579  * This function returns the ac charger current.
580  * Returns ac current in microamperes (on success) and error code on failure.
581  */
582 static int ab8500_charger_get_ac_current(struct ab8500_charger *di)
583 {
584 	int ich, ret;
585 
586 	/* Only measure current if the charger is online */
587 	if (di->ac.charger_online) {
588 		ret = iio_read_channel_processed(di->adc_main_charger_c, &ich);
589 		if (ret < 0)
590 			dev_err(di->dev, "%s ADC conv failed,\n", __func__);
591 	} else {
592 		ich = 0;
593 	}
594 	/* Return microamperes */
595 	return ich * 1000;
596 }
597 
598 /**
599  * ab8500_charger_usb_cv() - check if the usb charger is in CV mode
600  * @di:		pointer to the ab8500_charger structure
601  *
602  * Returns ac charger CV mode (on success) else error code
603  */
604 static int ab8500_charger_usb_cv(struct ab8500_charger *di)
605 {
606 	int ret;
607 	u8 val;
608 
609 	/* Only check CV mode if the charger is online */
610 	if (di->usb.charger_online) {
611 		ret = abx500_get_register_interruptible(di->dev, AB8500_CHARGER,
612 			AB8500_CH_USBCH_STAT1_REG, &val);
613 		if (ret < 0) {
614 			dev_err(di->dev, "%s ab8500 read failed\n", __func__);
615 			return 0;
616 		}
617 
618 		if (val & USB_CH_CV_ON)
619 			ret = 1;
620 		else
621 			ret = 0;
622 	} else {
623 		ret = 0;
624 	}
625 
626 	return ret;
627 }
628 
629 /**
630  * ab8500_charger_detect_chargers() - Detect the connected chargers
631  * @di:		pointer to the ab8500_charger structure
632  * @probe:	if probe, don't delay and wait for HW
633  *
634  * Returns the type of charger connected.
635  * For USB it will not mean we can actually charge from it
636  * but that there is a USB cable connected that we have to
637  * identify. This is used during startup when we don't get
638  * interrupts of the charger detection
639  *
640  * Returns an integer value, that means,
641  * NO_PW_CONN  no power supply is connected
642  * AC_PW_CONN  if the AC power supply is connected
643  * USB_PW_CONN  if the USB power supply is connected
644  * AC_PW_CONN + USB_PW_CONN if USB and AC power supplies are both connected
645  */
646 static int ab8500_charger_detect_chargers(struct ab8500_charger *di, bool probe)
647 {
648 	int result = NO_PW_CONN;
649 	int ret;
650 	u8 val;
651 
652 	/* Check for AC charger */
653 	ret = abx500_get_register_interruptible(di->dev, AB8500_CHARGER,
654 		AB8500_CH_STATUS1_REG, &val);
655 	if (ret < 0) {
656 		dev_err(di->dev, "%s ab8500 read failed\n", __func__);
657 		return ret;
658 	}
659 
660 	if (val & MAIN_CH_DET)
661 		result = AC_PW_CONN;
662 
663 	/* Check for USB charger */
664 
665 	if (!probe) {
666 		/*
667 		 * AB8500 says VBUS_DET_DBNC1 & VBUS_DET_DBNC100
668 		 * when disconnecting ACA even though no
669 		 * charger was connected. Try waiting a little
670 		 * longer than the 100 ms of VBUS_DET_DBNC100...
671 		 */
672 		msleep(110);
673 	}
674 	ret = abx500_get_register_interruptible(di->dev, AB8500_CHARGER,
675 		AB8500_CH_USBCH_STAT1_REG, &val);
676 	if (ret < 0) {
677 		dev_err(di->dev, "%s ab8500 read failed\n", __func__);
678 		return ret;
679 	}
680 	dev_dbg(di->dev,
681 		"%s AB8500_CH_USBCH_STAT1_REG %x\n", __func__,
682 		val);
683 	if ((val & VBUS_DET_DBNC1) && (val & VBUS_DET_DBNC100))
684 		result |= USB_PW_CONN;
685 
686 	return result;
687 }
688 
689 /**
690  * ab8500_charger_max_usb_curr() - get the max curr for the USB type
691  * @di:			pointer to the ab8500_charger structure
692  * @link_status:	the identified USB type
693  *
694  * Get the maximum current that is allowed to be drawn from the host
695  * based on the USB type.
696  * Returns error code in case of failure else 0 on success
697  */
698 static int ab8500_charger_max_usb_curr(struct ab8500_charger *di,
699 		enum ab8500_charger_link_status link_status)
700 {
701 	int ret = 0;
702 
703 	di->usb_device_is_unrecognised = false;
704 
705 	/*
706 	 * Platform only supports USB 2.0.
707 	 * This means that charging current from USB source
708 	 * is maximum 500 mA. Every occurrence of USB_STAT_*_HOST_*
709 	 * should set USB_CH_IP_CUR_LVL_0P5.
710 	 */
711 
712 	switch (link_status) {
713 	case USB_STAT_STD_HOST_NC:
714 	case USB_STAT_STD_HOST_C_NS:
715 	case USB_STAT_STD_HOST_C_S:
716 		dev_dbg(di->dev, "USB Type - Standard host is "
717 			"detected through USB driver\n");
718 		di->max_usb_in_curr.usb_type_max_ua = USB_CH_IP_CUR_LVL_0P5;
719 		di->is_aca_rid = 0;
720 		break;
721 	case USB_STAT_HOST_CHG_HS_CHIRP:
722 		di->max_usb_in_curr.usb_type_max_ua = USB_CH_IP_CUR_LVL_0P5;
723 		di->is_aca_rid = 0;
724 		break;
725 	case USB_STAT_HOST_CHG_HS:
726 		di->max_usb_in_curr.usb_type_max_ua = USB_CH_IP_CUR_LVL_0P5;
727 		di->is_aca_rid = 0;
728 		break;
729 	case USB_STAT_ACA_RID_C_HS:
730 		di->max_usb_in_curr.usb_type_max_ua = USB_CH_IP_CUR_LVL_0P9;
731 		di->is_aca_rid = 0;
732 		break;
733 	case USB_STAT_ACA_RID_A:
734 		/*
735 		 * Dedicated charger level minus maximum current accessory
736 		 * can consume (900mA). Closest level is 500mA
737 		 */
738 		dev_dbg(di->dev, "USB_STAT_ACA_RID_A detected\n");
739 		di->max_usb_in_curr.usb_type_max_ua = USB_CH_IP_CUR_LVL_0P5;
740 		di->is_aca_rid = 1;
741 		break;
742 	case USB_STAT_ACA_RID_B:
743 		/*
744 		 * Dedicated charger level minus 120mA (20mA for ACA and
745 		 * 100mA for potential accessory). Closest level is 1300mA
746 		 */
747 		di->max_usb_in_curr.usb_type_max_ua = USB_CH_IP_CUR_LVL_1P3;
748 		dev_dbg(di->dev, "USB Type - 0x%02x MaxCurr: %d", link_status,
749 				di->max_usb_in_curr.usb_type_max_ua);
750 		di->is_aca_rid = 1;
751 		break;
752 	case USB_STAT_HOST_CHG_NM:
753 		di->max_usb_in_curr.usb_type_max_ua = USB_CH_IP_CUR_LVL_0P5;
754 		di->is_aca_rid = 0;
755 		break;
756 	case USB_STAT_DEDICATED_CHG:
757 		di->max_usb_in_curr.usb_type_max_ua = USB_CH_IP_CUR_LVL_1P5;
758 		di->is_aca_rid = 0;
759 		break;
760 	case USB_STAT_ACA_RID_C_HS_CHIRP:
761 	case USB_STAT_ACA_RID_C_NM:
762 		di->max_usb_in_curr.usb_type_max_ua = USB_CH_IP_CUR_LVL_1P5;
763 		di->is_aca_rid = 1;
764 		break;
765 	case USB_STAT_NOT_CONFIGURED:
766 		if (di->vbus_detected) {
767 			di->usb_device_is_unrecognised = true;
768 			dev_dbg(di->dev, "USB Type - Legacy charger.\n");
769 			di->max_usb_in_curr.usb_type_max_ua =
770 						USB_CH_IP_CUR_LVL_1P5;
771 			break;
772 		}
773 		fallthrough;
774 	case USB_STAT_HM_IDGND:
775 		dev_err(di->dev, "USB Type - Charging not allowed\n");
776 		di->max_usb_in_curr.usb_type_max_ua = USB_CH_IP_CUR_LVL_0P05;
777 		ret = -ENXIO;
778 		break;
779 	case USB_STAT_RESERVED:
780 		if (is_ab8500(di->parent)) {
781 			di->flags.vbus_collapse = true;
782 			dev_err(di->dev, "USB Type - USB_STAT_RESERVED "
783 						"VBUS has collapsed\n");
784 			ret = -ENXIO;
785 			break;
786 		} else {
787 			dev_dbg(di->dev, "USB Type - Charging not allowed\n");
788 			di->max_usb_in_curr.usb_type_max_ua =
789 						USB_CH_IP_CUR_LVL_0P05;
790 			dev_dbg(di->dev, "USB Type - 0x%02x MaxCurr: %d",
791 				link_status,
792 				di->max_usb_in_curr.usb_type_max_ua);
793 			ret = -ENXIO;
794 			break;
795 		}
796 	case USB_STAT_CARKIT_1:
797 	case USB_STAT_CARKIT_2:
798 	case USB_STAT_ACA_DOCK_CHARGER:
799 	case USB_STAT_CHARGER_LINE_1:
800 		di->max_usb_in_curr.usb_type_max_ua = USB_CH_IP_CUR_LVL_0P5;
801 		dev_dbg(di->dev, "USB Type - 0x%02x MaxCurr: %d", link_status,
802 				di->max_usb_in_curr.usb_type_max_ua);
803 		break;
804 	case USB_STAT_NOT_VALID_LINK:
805 		dev_err(di->dev, "USB Type invalid - try charging anyway\n");
806 		di->max_usb_in_curr.usb_type_max_ua = USB_CH_IP_CUR_LVL_0P5;
807 		break;
808 
809 	default:
810 		dev_err(di->dev, "USB Type - Unknown\n");
811 		di->max_usb_in_curr.usb_type_max_ua = USB_CH_IP_CUR_LVL_0P05;
812 		ret = -ENXIO;
813 		break;
814 	}
815 
816 	di->max_usb_in_curr.set_max_ua = di->max_usb_in_curr.usb_type_max_ua;
817 	dev_dbg(di->dev, "USB Type - 0x%02x MaxCurr: %d",
818 		link_status, di->max_usb_in_curr.set_max_ua);
819 
820 	return ret;
821 }
822 
823 /**
824  * ab8500_charger_read_usb_type() - read the type of usb connected
825  * @di:		pointer to the ab8500_charger structure
826  *
827  * Detect the type of the plugged USB
828  * Returns error code in case of failure else 0 on success
829  */
830 static int ab8500_charger_read_usb_type(struct ab8500_charger *di)
831 {
832 	int ret;
833 	u8 val;
834 
835 	ret = abx500_get_register_interruptible(di->dev,
836 		AB8500_INTERRUPT, AB8500_IT_SOURCE21_REG, &val);
837 	if (ret < 0) {
838 		dev_err(di->dev, "%s ab8500 read failed\n", __func__);
839 		return ret;
840 	}
841 	if (is_ab8500(di->parent))
842 		ret = abx500_get_register_interruptible(di->dev, AB8500_USB,
843 			AB8500_USB_LINE_STAT_REG, &val);
844 	else
845 		ret = abx500_get_register_interruptible(di->dev,
846 			AB8500_USB, AB8500_USB_LINK1_STAT_REG, &val);
847 	if (ret < 0) {
848 		dev_err(di->dev, "%s ab8500 read failed\n", __func__);
849 		return ret;
850 	}
851 
852 	/* get the USB type */
853 	if (is_ab8500(di->parent))
854 		val = (val & AB8500_USB_LINK_STATUS) >> USB_LINK_STATUS_SHIFT;
855 	else
856 		val = (val & AB8505_USB_LINK_STATUS) >> USB_LINK_STATUS_SHIFT;
857 	ret = ab8500_charger_max_usb_curr(di,
858 		(enum ab8500_charger_link_status) val);
859 
860 	return ret;
861 }
862 
863 /**
864  * ab8500_charger_detect_usb_type() - get the type of usb connected
865  * @di:		pointer to the ab8500_charger structure
866  *
867  * Detect the type of the plugged USB
868  * Returns error code in case of failure else 0 on success
869  */
870 static int ab8500_charger_detect_usb_type(struct ab8500_charger *di)
871 {
872 	int i, ret;
873 	u8 val;
874 
875 	/*
876 	 * On getting the VBUS rising edge detect interrupt there
877 	 * is a 250ms delay after which the register UsbLineStatus
878 	 * is filled with valid data.
879 	 */
880 	for (i = 0; i < 10; i++) {
881 		msleep(250);
882 		ret = abx500_get_register_interruptible(di->dev,
883 			AB8500_INTERRUPT, AB8500_IT_SOURCE21_REG,
884 			&val);
885 		dev_dbg(di->dev, "%s AB8500_IT_SOURCE21_REG %x\n",
886 			__func__, val);
887 		if (ret < 0) {
888 			dev_err(di->dev, "%s ab8500 read failed\n", __func__);
889 			return ret;
890 		}
891 
892 		if (is_ab8500(di->parent))
893 			ret = abx500_get_register_interruptible(di->dev,
894 				AB8500_USB, AB8500_USB_LINE_STAT_REG, &val);
895 		else
896 			ret = abx500_get_register_interruptible(di->dev,
897 				AB8500_USB, AB8500_USB_LINK1_STAT_REG, &val);
898 		if (ret < 0) {
899 			dev_err(di->dev, "%s ab8500 read failed\n", __func__);
900 			return ret;
901 		}
902 		dev_dbg(di->dev, "%s AB8500_USB_LINE_STAT_REG %x\n", __func__,
903 			val);
904 		/*
905 		 * Until the IT source register is read the UsbLineStatus
906 		 * register is not updated, hence doing the same
907 		 * Revisit this:
908 		 */
909 
910 		/* get the USB type */
911 		if (is_ab8500(di->parent))
912 			val = (val & AB8500_USB_LINK_STATUS) >>
913 							USB_LINK_STATUS_SHIFT;
914 		else
915 			val = (val & AB8505_USB_LINK_STATUS) >>
916 							USB_LINK_STATUS_SHIFT;
917 		if (val)
918 			break;
919 	}
920 	ret = ab8500_charger_max_usb_curr(di,
921 		(enum ab8500_charger_link_status) val);
922 
923 	return ret;
924 }
925 
926 /*
927  * This array maps the raw hex value to charger voltage used by the AB8500
928  * Values taken from the UM0836, in microvolt.
929  */
930 static int ab8500_charger_voltage_map[] = {
931 	3500000,
932 	3525000,
933 	3550000,
934 	3575000,
935 	3600000,
936 	3625000,
937 	3650000,
938 	3675000,
939 	3700000,
940 	3725000,
941 	3750000,
942 	3775000,
943 	3800000,
944 	3825000,
945 	3850000,
946 	3875000,
947 	3900000,
948 	3925000,
949 	3950000,
950 	3975000,
951 	4000000,
952 	4025000,
953 	4050000,
954 	4060000,
955 	4070000,
956 	4080000,
957 	4090000,
958 	4100000,
959 	4110000,
960 	4120000,
961 	4130000,
962 	4140000,
963 	4150000,
964 	4160000,
965 	4170000,
966 	4180000,
967 	4190000,
968 	4200000,
969 	4210000,
970 	4220000,
971 	4230000,
972 	4240000,
973 	4250000,
974 	4260000,
975 	4270000,
976 	4280000,
977 	4290000,
978 	4300000,
979 	4310000,
980 	4320000,
981 	4330000,
982 	4340000,
983 	4350000,
984 	4360000,
985 	4370000,
986 	4380000,
987 	4390000,
988 	4400000,
989 	4410000,
990 	4420000,
991 	4430000,
992 	4440000,
993 	4450000,
994 	4460000,
995 	4470000,
996 	4480000,
997 	4490000,
998 	4500000,
999 	4510000,
1000 	4520000,
1001 	4530000,
1002 	4540000,
1003 	4550000,
1004 	4560000,
1005 	4570000,
1006 	4580000,
1007 	4590000,
1008 	4600000,
1009 };
1010 
1011 static int ab8500_voltage_to_regval(int voltage_uv)
1012 {
1013 	int i;
1014 
1015 	/* Special case for voltage below 3.5V */
1016 	if (voltage_uv < ab8500_charger_voltage_map[0])
1017 		return LOW_VOLT_REG;
1018 
1019 	for (i = 1; i < ARRAY_SIZE(ab8500_charger_voltage_map); i++) {
1020 		if (voltage_uv < ab8500_charger_voltage_map[i])
1021 			return i - 1;
1022 	}
1023 
1024 	/* If not last element, return error */
1025 	i = ARRAY_SIZE(ab8500_charger_voltage_map) - 1;
1026 	if (voltage_uv == ab8500_charger_voltage_map[i])
1027 		return i;
1028 	else
1029 		return -1;
1030 }
1031 
1032 /* This array maps the raw register value to charger input current */
1033 static int ab8500_charge_input_curr_map[] = {
1034 	50000, 98000, 193000, 290000, 380000, 450000, 500000, 600000,
1035 	700000, 800000, 900000, 1000000, 1100000, 1300000, 1400000, 1500000,
1036 };
1037 
1038 /* This array maps the raw register value to charger output current */
1039 static int ab8500_charge_output_curr_map[] = {
1040 	100000, 200000, 300000, 400000, 500000, 600000, 700000, 800000,
1041 	900000, 1000000, 1100000, 1200000, 1300000, 1400000, 1500000, 1500000,
1042 };
1043 
1044 static int ab8500_current_to_regval(struct ab8500_charger *di, int curr_ua)
1045 {
1046 	int i;
1047 
1048 	if (curr_ua < ab8500_charge_output_curr_map[0])
1049 		return 0;
1050 
1051 	for (i = 0; i < ARRAY_SIZE(ab8500_charge_output_curr_map); i++) {
1052 		if (curr_ua < ab8500_charge_output_curr_map[i])
1053 			return i - 1;
1054 	}
1055 
1056 	/* If not last element, return error */
1057 	i =  ARRAY_SIZE(ab8500_charge_output_curr_map) - 1;
1058 	if (curr_ua == ab8500_charge_output_curr_map[i])
1059 		return i;
1060 	else
1061 		return -1;
1062 }
1063 
1064 static int ab8500_vbus_in_curr_to_regval(struct ab8500_charger *di, int curr_ua)
1065 {
1066 	int i;
1067 
1068 	if (curr_ua < ab8500_charge_input_curr_map[0])
1069 		return 0;
1070 
1071 	for (i = 0; i < ARRAY_SIZE(ab8500_charge_input_curr_map); i++) {
1072 		if (curr_ua < ab8500_charge_input_curr_map[i])
1073 			return i - 1;
1074 	}
1075 
1076 	/* If not last element, return error */
1077 	i =  ARRAY_SIZE(ab8500_charge_input_curr_map) - 1;
1078 	if (curr_ua == ab8500_charge_input_curr_map[i])
1079 		return i;
1080 	else
1081 		return -1;
1082 }
1083 
1084 /**
1085  * ab8500_charger_get_usb_cur() - get usb current
1086  * @di:		pointer to the ab8500_charger structure
1087  *
1088  * The usb stack provides the maximum current that can be drawn from
1089  * the standard usb host. This will be in uA.
1090  * This function converts current in uA to a value that can be written
1091  * to the register. Returns -1 if charging is not allowed
1092  */
1093 static int ab8500_charger_get_usb_cur(struct ab8500_charger *di)
1094 {
1095 	int ret = 0;
1096 	switch (di->usb_state.usb_current_ua) {
1097 	case 100000:
1098 		di->max_usb_in_curr.usb_type_max_ua = USB_CH_IP_CUR_LVL_0P09;
1099 		break;
1100 	case 200000:
1101 		di->max_usb_in_curr.usb_type_max_ua = USB_CH_IP_CUR_LVL_0P19;
1102 		break;
1103 	case 300000:
1104 		di->max_usb_in_curr.usb_type_max_ua = USB_CH_IP_CUR_LVL_0P29;
1105 		break;
1106 	case 400000:
1107 		di->max_usb_in_curr.usb_type_max_ua = USB_CH_IP_CUR_LVL_0P38;
1108 		break;
1109 	case 500000:
1110 		di->max_usb_in_curr.usb_type_max_ua = USB_CH_IP_CUR_LVL_0P5;
1111 		break;
1112 	default:
1113 		di->max_usb_in_curr.usb_type_max_ua = USB_CH_IP_CUR_LVL_0P05;
1114 		ret = -EPERM;
1115 		break;
1116 	}
1117 	di->max_usb_in_curr.set_max_ua = di->max_usb_in_curr.usb_type_max_ua;
1118 	return ret;
1119 }
1120 
1121 /**
1122  * ab8500_charger_check_continue_stepping() - Check to allow stepping
1123  * @di:		pointer to the ab8500_charger structure
1124  * @reg:	select what charger register to check
1125  *
1126  * Check if current stepping should be allowed to continue.
1127  * Checks if charger source has not collapsed. If it has, further stepping
1128  * is not allowed.
1129  */
1130 static bool ab8500_charger_check_continue_stepping(struct ab8500_charger *di,
1131 						   int reg)
1132 {
1133 	if (reg == AB8500_USBCH_IPT_CRNTLVL_REG)
1134 		return !di->flags.vbus_drop_end;
1135 	else
1136 		return true;
1137 }
1138 
1139 /**
1140  * ab8500_charger_set_current() - set charger current
1141  * @di:		pointer to the ab8500_charger structure
1142  * @ich_ua:	charger current, in uA
1143  * @reg:	select what charger register to set
1144  *
1145  * Set charger current.
1146  * There is no state machine in the AB to step up/down the charger
1147  * current to avoid dips and spikes on MAIN, VBUS and VBAT when
1148  * charging is started. Instead we need to implement
1149  * this charger current step-up/down here.
1150  * Returns error code in case of failure else 0(on success)
1151  */
1152 static int ab8500_charger_set_current(struct ab8500_charger *di,
1153 	int ich_ua, int reg)
1154 {
1155 	int ret = 0;
1156 	int curr_index, prev_curr_index, shift_value, i;
1157 	u8 reg_value;
1158 	u32 step_udelay;
1159 	bool no_stepping = false;
1160 
1161 	atomic_inc(&di->current_stepping_sessions);
1162 
1163 	ret = abx500_get_register_interruptible(di->dev, AB8500_CHARGER,
1164 		reg, &reg_value);
1165 	if (ret < 0) {
1166 		dev_err(di->dev, "%s read failed\n", __func__);
1167 		goto exit_set_current;
1168 	}
1169 
1170 	switch (reg) {
1171 	case AB8500_MCH_IPT_CURLVL_REG:
1172 		shift_value = MAIN_CH_INPUT_CURR_SHIFT;
1173 		prev_curr_index = (reg_value >> shift_value);
1174 		curr_index = ab8500_current_to_regval(di, ich_ua);
1175 		step_udelay = STEP_UDELAY;
1176 		if (!di->ac.charger_connected)
1177 			no_stepping = true;
1178 		break;
1179 	case AB8500_USBCH_IPT_CRNTLVL_REG:
1180 		shift_value = VBUS_IN_CURR_LIM_SHIFT;
1181 		prev_curr_index = (reg_value >> shift_value);
1182 		curr_index = ab8500_vbus_in_curr_to_regval(di, ich_ua);
1183 		step_udelay = STEP_UDELAY * 100;
1184 
1185 		if (!di->usb.charger_connected)
1186 			no_stepping = true;
1187 		break;
1188 	case AB8500_CH_OPT_CRNTLVL_REG:
1189 		shift_value = 0;
1190 		prev_curr_index = (reg_value >> shift_value);
1191 		curr_index = ab8500_current_to_regval(di, ich_ua);
1192 		step_udelay = STEP_UDELAY;
1193 		if (curr_index && (curr_index - prev_curr_index) > 1)
1194 			step_udelay *= 100;
1195 
1196 		if (!di->usb.charger_connected && !di->ac.charger_connected)
1197 			no_stepping = true;
1198 
1199 		break;
1200 	default:
1201 		dev_err(di->dev, "%s current register not valid\n", __func__);
1202 		ret = -ENXIO;
1203 		goto exit_set_current;
1204 	}
1205 
1206 	if (curr_index < 0) {
1207 		dev_err(di->dev, "requested current limit out-of-range\n");
1208 		ret = -ENXIO;
1209 		goto exit_set_current;
1210 	}
1211 
1212 	/* only update current if it's been changed */
1213 	if (prev_curr_index == curr_index) {
1214 		dev_dbg(di->dev, "%s current not changed for reg: 0x%02x\n",
1215 			__func__, reg);
1216 		ret = 0;
1217 		goto exit_set_current;
1218 	}
1219 
1220 	dev_dbg(di->dev, "%s set charger current: %d uA for reg: 0x%02x\n",
1221 		__func__, ich_ua, reg);
1222 
1223 	if (no_stepping) {
1224 		ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER,
1225 					reg, (u8)curr_index << shift_value);
1226 		if (ret)
1227 			dev_err(di->dev, "%s write failed\n", __func__);
1228 	} else if (prev_curr_index > curr_index) {
1229 		for (i = prev_curr_index - 1; i >= curr_index; i--) {
1230 			dev_dbg(di->dev, "curr change_1 to: %x for 0x%02x\n",
1231 				(u8) i << shift_value, reg);
1232 			ret = abx500_set_register_interruptible(di->dev,
1233 				AB8500_CHARGER, reg, (u8)i << shift_value);
1234 			if (ret) {
1235 				dev_err(di->dev, "%s write failed\n", __func__);
1236 				goto exit_set_current;
1237 			}
1238 			if (i != curr_index)
1239 				usleep_range(step_udelay, step_udelay * 2);
1240 		}
1241 	} else {
1242 		bool allow = true;
1243 		for (i = prev_curr_index + 1; i <= curr_index && allow; i++) {
1244 			dev_dbg(di->dev, "curr change_2 to: %x for 0x%02x\n",
1245 				(u8)i << shift_value, reg);
1246 			ret = abx500_set_register_interruptible(di->dev,
1247 				AB8500_CHARGER, reg, (u8)i << shift_value);
1248 			if (ret) {
1249 				dev_err(di->dev, "%s write failed\n", __func__);
1250 				goto exit_set_current;
1251 			}
1252 			if (i != curr_index)
1253 				usleep_range(step_udelay, step_udelay * 2);
1254 
1255 			allow = ab8500_charger_check_continue_stepping(di, reg);
1256 		}
1257 	}
1258 
1259 exit_set_current:
1260 	atomic_dec(&di->current_stepping_sessions);
1261 
1262 	return ret;
1263 }
1264 
1265 /**
1266  * ab8500_charger_set_vbus_in_curr() - set VBUS input current limit
1267  * @di:		pointer to the ab8500_charger structure
1268  * @ich_in_ua:	charger input current limit in microampere
1269  *
1270  * Sets the current that can be drawn from the USB host
1271  * Returns error code in case of failure else 0(on success)
1272  */
1273 static int ab8500_charger_set_vbus_in_curr(struct ab8500_charger *di,
1274 		int ich_in_ua)
1275 {
1276 	int min_value;
1277 	int ret;
1278 
1279 	/* We should always use to lowest current limit */
1280 	min_value = min(di->bm->chg_params->usb_curr_max_ua, ich_in_ua);
1281 	if (di->max_usb_in_curr.set_max_ua > 0)
1282 		min_value = min(di->max_usb_in_curr.set_max_ua, min_value);
1283 
1284 	if (di->usb_state.usb_current_ua >= 0)
1285 		min_value = min(di->usb_state.usb_current_ua, min_value);
1286 
1287 	switch (min_value) {
1288 	case 100000:
1289 		if (di->vbat < VBAT_TRESH_IP_CUR_RED)
1290 			min_value = USB_CH_IP_CUR_LVL_0P05;
1291 		break;
1292 	case 500000:
1293 		if (di->vbat < VBAT_TRESH_IP_CUR_RED)
1294 			min_value = USB_CH_IP_CUR_LVL_0P45;
1295 		break;
1296 	default:
1297 		break;
1298 	}
1299 
1300 	dev_info(di->dev, "VBUS input current limit set to %d uA\n", min_value);
1301 
1302 	mutex_lock(&di->usb_ipt_crnt_lock);
1303 	ret = ab8500_charger_set_current(di, min_value,
1304 		AB8500_USBCH_IPT_CRNTLVL_REG);
1305 	mutex_unlock(&di->usb_ipt_crnt_lock);
1306 
1307 	return ret;
1308 }
1309 
1310 /**
1311  * ab8500_charger_set_main_in_curr() - set main charger input current
1312  * @di:		pointer to the ab8500_charger structure
1313  * @ich_in_ua:	input charger current, in uA
1314  *
1315  * Set main charger input current.
1316  * Returns error code in case of failure else 0(on success)
1317  */
1318 static int ab8500_charger_set_main_in_curr(struct ab8500_charger *di,
1319 	int ich_in_ua)
1320 {
1321 	return ab8500_charger_set_current(di, ich_in_ua,
1322 		AB8500_MCH_IPT_CURLVL_REG);
1323 }
1324 
1325 /**
1326  * ab8500_charger_set_output_curr() - set charger output current
1327  * @di:		pointer to the ab8500_charger structure
1328  * @ich_out_ua:	output charger current, in uA
1329  *
1330  * Set charger output current.
1331  * Returns error code in case of failure else 0(on success)
1332  */
1333 static int ab8500_charger_set_output_curr(struct ab8500_charger *di,
1334 	int ich_out_ua)
1335 {
1336 	return ab8500_charger_set_current(di, ich_out_ua,
1337 		AB8500_CH_OPT_CRNTLVL_REG);
1338 }
1339 
1340 /**
1341  * ab8500_charger_led_en() - turn on/off chargign led
1342  * @di:		pointer to the ab8500_charger structure
1343  * @on:		flag to turn on/off the chargign led
1344  *
1345  * Power ON/OFF charging LED indication
1346  * Returns error code in case of failure else 0(on success)
1347  */
1348 static int ab8500_charger_led_en(struct ab8500_charger *di, int on)
1349 {
1350 	int ret;
1351 
1352 	if (on) {
1353 		/* Power ON charging LED indicator, set LED current to 5mA */
1354 		ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER,
1355 			AB8500_LED_INDICATOR_PWM_CTRL,
1356 			(LED_IND_CUR_5MA | LED_INDICATOR_PWM_ENA));
1357 		if (ret) {
1358 			dev_err(di->dev, "Power ON LED failed\n");
1359 			return ret;
1360 		}
1361 		/* LED indicator PWM duty cycle 252/256 */
1362 		ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER,
1363 			AB8500_LED_INDICATOR_PWM_DUTY,
1364 			LED_INDICATOR_PWM_DUTY_252_256);
1365 		if (ret) {
1366 			dev_err(di->dev, "Set LED PWM duty cycle failed\n");
1367 			return ret;
1368 		}
1369 	} else {
1370 		/* Power off charging LED indicator */
1371 		ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER,
1372 			AB8500_LED_INDICATOR_PWM_CTRL,
1373 			LED_INDICATOR_PWM_DIS);
1374 		if (ret) {
1375 			dev_err(di->dev, "Power-off LED failed\n");
1376 			return ret;
1377 		}
1378 	}
1379 
1380 	return ret;
1381 }
1382 
1383 /**
1384  * ab8500_charger_ac_en() - enable or disable ac charging
1385  * @di:		pointer to the ab8500_charger structure
1386  * @enable:	enable/disable flag
1387  * @vset_uv:	charging voltage in microvolt
1388  * @iset_ua:	charging current in microampere
1389  *
1390  * Enable/Disable AC/Mains charging and turns on/off the charging led
1391  * respectively.
1392  **/
1393 static int ab8500_charger_ac_en(struct ux500_charger *charger,
1394 	int enable, int vset_uv, int iset_ua)
1395 {
1396 	int ret;
1397 	int volt_index;
1398 	int curr_index;
1399 	int input_curr_index;
1400 	u8 overshoot = 0;
1401 
1402 	struct ab8500_charger *di = to_ab8500_charger_ac_device_info(charger);
1403 
1404 	if (enable) {
1405 		/* Check if AC is connected */
1406 		if (!di->ac.charger_connected) {
1407 			dev_err(di->dev, "AC charger not connected\n");
1408 			return -ENXIO;
1409 		}
1410 
1411 		/* Enable AC charging */
1412 		dev_dbg(di->dev, "Enable AC: %duV %duA\n", vset_uv, iset_ua);
1413 
1414 		/*
1415 		 * Due to a bug in AB8500, BTEMP_HIGH/LOW interrupts
1416 		 * will be triggered every time we enable the VDD ADC supply.
1417 		 * This will turn off charging for a short while.
1418 		 * It can be avoided by having the supply on when
1419 		 * there is a charger enabled. Normally the VDD ADC supply
1420 		 * is enabled every time a GPADC conversion is triggered.
1421 		 * We will force it to be enabled from this driver to have
1422 		 * the GPADC module independent of the AB8500 chargers
1423 		 */
1424 		if (!di->vddadc_en_ac) {
1425 			ret = regulator_enable(di->regu);
1426 			if (ret)
1427 				dev_warn(di->dev,
1428 					"Failed to enable regulator\n");
1429 			else
1430 				di->vddadc_en_ac = true;
1431 		}
1432 
1433 		/* Check if the requested voltage or current is valid */
1434 		volt_index = ab8500_voltage_to_regval(vset_uv);
1435 		curr_index = ab8500_current_to_regval(di, iset_ua);
1436 		input_curr_index = ab8500_current_to_regval(di,
1437 			di->bm->chg_params->ac_curr_max_ua);
1438 		if (volt_index < 0 || curr_index < 0 || input_curr_index < 0) {
1439 			dev_err(di->dev,
1440 				"Charger voltage or current too high, "
1441 				"charging not started\n");
1442 			return -ENXIO;
1443 		}
1444 
1445 		/* ChVoltLevel: maximum battery charging voltage */
1446 		ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER,
1447 			AB8500_CH_VOLT_LVL_REG, (u8) volt_index);
1448 		if (ret) {
1449 			dev_err(di->dev, "%s write failed\n", __func__);
1450 			return ret;
1451 		}
1452 		/* MainChInputCurr: current that can be drawn from the charger*/
1453 		ret = ab8500_charger_set_main_in_curr(di,
1454 			di->bm->chg_params->ac_curr_max_ua);
1455 		if (ret) {
1456 			dev_err(di->dev, "%s Failed to set MainChInputCurr\n",
1457 				__func__);
1458 			return ret;
1459 		}
1460 		/* ChOutputCurentLevel: protected output current */
1461 		ret = ab8500_charger_set_output_curr(di, iset_ua);
1462 		if (ret) {
1463 			dev_err(di->dev, "%s "
1464 				"Failed to set ChOutputCurentLevel\n",
1465 				__func__);
1466 			return ret;
1467 		}
1468 
1469 		/* Check if VBAT overshoot control should be enabled */
1470 		if (!di->bm->enable_overshoot)
1471 			overshoot = MAIN_CH_NO_OVERSHOOT_ENA_N;
1472 
1473 		/* Enable Main Charger */
1474 		ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER,
1475 			AB8500_MCH_CTRL1, MAIN_CH_ENA | overshoot);
1476 		if (ret) {
1477 			dev_err(di->dev, "%s write failed\n", __func__);
1478 			return ret;
1479 		}
1480 
1481 		/* Power on charging LED indication */
1482 		ret = ab8500_charger_led_en(di, true);
1483 		if (ret < 0)
1484 			dev_err(di->dev, "failed to enable LED\n");
1485 
1486 		di->ac.charger_online = 1;
1487 	} else {
1488 		/* Disable AC charging */
1489 		if (is_ab8500_1p1_or_earlier(di->parent)) {
1490 			/*
1491 			 * For ABB revision 1.0 and 1.1 there is a bug in the
1492 			 * watchdog logic. That means we have to continuously
1493 			 * kick the charger watchdog even when no charger is
1494 			 * connected. This is only valid once the AC charger
1495 			 * has been enabled. This is a bug that is not handled
1496 			 * by the algorithm and the watchdog have to be kicked
1497 			 * by the charger driver when the AC charger
1498 			 * is disabled
1499 			 */
1500 			if (di->ac_conn) {
1501 				queue_delayed_work(di->charger_wq,
1502 					&di->kick_wd_work,
1503 					round_jiffies(WD_KICK_INTERVAL));
1504 			}
1505 
1506 			/*
1507 			 * We can't turn off charging completely
1508 			 * due to a bug in AB8500 cut1.
1509 			 * If we do, charging will not start again.
1510 			 * That is why we set the lowest voltage
1511 			 * and current possible
1512 			 */
1513 			ret = abx500_set_register_interruptible(di->dev,
1514 				AB8500_CHARGER,
1515 				AB8500_CH_VOLT_LVL_REG, CH_VOL_LVL_3P5);
1516 			if (ret) {
1517 				dev_err(di->dev,
1518 					"%s write failed\n", __func__);
1519 				return ret;
1520 			}
1521 
1522 			ret = ab8500_charger_set_output_curr(di, 0);
1523 			if (ret) {
1524 				dev_err(di->dev, "%s "
1525 					"Failed to set ChOutputCurentLevel\n",
1526 					__func__);
1527 				return ret;
1528 			}
1529 		} else {
1530 			ret = abx500_set_register_interruptible(di->dev,
1531 				AB8500_CHARGER,
1532 				AB8500_MCH_CTRL1, 0);
1533 			if (ret) {
1534 				dev_err(di->dev,
1535 					"%s write failed\n", __func__);
1536 				return ret;
1537 			}
1538 		}
1539 
1540 		ret = ab8500_charger_led_en(di, false);
1541 		if (ret < 0)
1542 			dev_err(di->dev, "failed to disable LED\n");
1543 
1544 		di->ac.charger_online = 0;
1545 		di->ac.wd_expired = false;
1546 
1547 		/* Disable regulator if enabled */
1548 		if (di->vddadc_en_ac) {
1549 			regulator_disable(di->regu);
1550 			di->vddadc_en_ac = false;
1551 		}
1552 
1553 		dev_dbg(di->dev, "%s Disabled AC charging\n", __func__);
1554 	}
1555 	ab8500_power_supply_changed(di, di->ac_chg.psy);
1556 
1557 	return ret;
1558 }
1559 
1560 /**
1561  * ab8500_charger_usb_en() - enable usb charging
1562  * @di:		pointer to the ab8500_charger structure
1563  * @enable:	enable/disable flag
1564  * @vset_uv:	charging voltage in microvolt
1565  * @ich_out_ua:	charger output current in microampere
1566  *
1567  * Enable/Disable USB charging and turns on/off the charging led respectively.
1568  * Returns error code in case of failure else 0(on success)
1569  */
1570 static int ab8500_charger_usb_en(struct ux500_charger *charger,
1571 	int enable, int vset_uv, int ich_out_ua)
1572 {
1573 	int ret;
1574 	int volt_index;
1575 	int curr_index;
1576 	u8 overshoot = 0;
1577 
1578 	struct ab8500_charger *di = to_ab8500_charger_usb_device_info(charger);
1579 
1580 	if (enable) {
1581 		/* Check if USB is connected */
1582 		if (!di->usb.charger_connected) {
1583 			dev_err(di->dev, "USB charger not connected\n");
1584 			return -ENXIO;
1585 		}
1586 
1587 		/*
1588 		 * Due to a bug in AB8500, BTEMP_HIGH/LOW interrupts
1589 		 * will be triggered every time we enable the VDD ADC supply.
1590 		 * This will turn off charging for a short while.
1591 		 * It can be avoided by having the supply on when
1592 		 * there is a charger enabled. Normally the VDD ADC supply
1593 		 * is enabled every time a GPADC conversion is triggered.
1594 		 * We will force it to be enabled from this driver to have
1595 		 * the GPADC module independent of the AB8500 chargers
1596 		 */
1597 		if (!di->vddadc_en_usb) {
1598 			ret = regulator_enable(di->regu);
1599 			if (ret)
1600 				dev_warn(di->dev,
1601 					"Failed to enable regulator\n");
1602 			else
1603 				di->vddadc_en_usb = true;
1604 		}
1605 
1606 		/* Enable USB charging */
1607 		dev_dbg(di->dev, "Enable USB: %d uV %d uA\n", vset_uv, ich_out_ua);
1608 
1609 		/* Check if the requested voltage or current is valid */
1610 		volt_index = ab8500_voltage_to_regval(vset_uv);
1611 		curr_index = ab8500_current_to_regval(di, ich_out_ua);
1612 		if (volt_index < 0 || curr_index < 0) {
1613 			dev_err(di->dev,
1614 				"Charger voltage or current too high, "
1615 				"charging not started\n");
1616 			return -ENXIO;
1617 		}
1618 
1619 		/*
1620 		 * ChVoltLevel: max voltage up to which battery can be
1621 		 * charged
1622 		 */
1623 		ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER,
1624 			AB8500_CH_VOLT_LVL_REG, (u8) volt_index);
1625 		if (ret) {
1626 			dev_err(di->dev, "%s write failed\n", __func__);
1627 			return ret;
1628 		}
1629 		/* Check if VBAT overshoot control should be enabled */
1630 		if (!di->bm->enable_overshoot)
1631 			overshoot = USB_CHG_NO_OVERSHOOT_ENA_N;
1632 
1633 		/* Enable USB Charger */
1634 		dev_dbg(di->dev,
1635 			"Enabling USB with write to AB8500_USBCH_CTRL1_REG\n");
1636 		ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER,
1637 			AB8500_USBCH_CTRL1_REG, USB_CH_ENA | overshoot);
1638 		if (ret) {
1639 			dev_err(di->dev, "%s write failed\n", __func__);
1640 			return ret;
1641 		}
1642 
1643 		/* If success power on charging LED indication */
1644 		ret = ab8500_charger_led_en(di, true);
1645 		if (ret < 0)
1646 			dev_err(di->dev, "failed to enable LED\n");
1647 
1648 		di->usb.charger_online = 1;
1649 
1650 		/* USBChInputCurr: current that can be drawn from the usb */
1651 		ret = ab8500_charger_set_vbus_in_curr(di,
1652 					di->max_usb_in_curr.usb_type_max_ua);
1653 		if (ret) {
1654 			dev_err(di->dev, "setting USBChInputCurr failed\n");
1655 			return ret;
1656 		}
1657 
1658 		/* ChOutputCurentLevel: protected output current */
1659 		ret = ab8500_charger_set_output_curr(di, ich_out_ua);
1660 		if (ret) {
1661 			dev_err(di->dev, "%s "
1662 				"Failed to set ChOutputCurentLevel\n",
1663 				__func__);
1664 			return ret;
1665 		}
1666 
1667 		queue_delayed_work(di->charger_wq, &di->check_vbat_work, HZ);
1668 
1669 	} else {
1670 		/* Disable USB charging */
1671 		dev_dbg(di->dev, "%s Disabled USB charging\n", __func__);
1672 		ret = abx500_set_register_interruptible(di->dev,
1673 			AB8500_CHARGER,
1674 			AB8500_USBCH_CTRL1_REG, 0);
1675 		if (ret) {
1676 			dev_err(di->dev,
1677 				"%s write failed\n", __func__);
1678 			return ret;
1679 		}
1680 
1681 		ret = ab8500_charger_led_en(di, false);
1682 		if (ret < 0)
1683 			dev_err(di->dev, "failed to disable LED\n");
1684 		/* USBChInputCurr: current that can be drawn from the usb */
1685 		ret = ab8500_charger_set_vbus_in_curr(di, 0);
1686 		if (ret) {
1687 			dev_err(di->dev, "setting USBChInputCurr failed\n");
1688 			return ret;
1689 		}
1690 
1691 		/* ChOutputCurentLevel: protected output current */
1692 		ret = ab8500_charger_set_output_curr(di, 0);
1693 		if (ret) {
1694 			dev_err(di->dev, "%s "
1695 				"Failed to reset ChOutputCurentLevel\n",
1696 				__func__);
1697 			return ret;
1698 		}
1699 		di->usb.charger_online = 0;
1700 		di->usb.wd_expired = false;
1701 
1702 		/* Disable regulator if enabled */
1703 		if (di->vddadc_en_usb) {
1704 			regulator_disable(di->regu);
1705 			di->vddadc_en_usb = false;
1706 		}
1707 
1708 		dev_dbg(di->dev, "%s Disabled USB charging\n", __func__);
1709 
1710 		/* Cancel any pending Vbat check work */
1711 		cancel_delayed_work(&di->check_vbat_work);
1712 
1713 	}
1714 	ab8500_power_supply_changed(di, di->usb_chg.psy);
1715 
1716 	return ret;
1717 }
1718 
1719 /**
1720  * ab8500_charger_usb_check_enable() - enable usb charging
1721  * @charger:	pointer to the ux500_charger structure
1722  * @vset_uv:	charging voltage in microvolt
1723  * @iset_ua:	charger output current in microampere
1724  *
1725  * Check if the VBUS charger has been disconnected and reconnected without
1726  * AB8500 rising an interrupt. Returns 0 on success.
1727  */
1728 static int ab8500_charger_usb_check_enable(struct ux500_charger *charger,
1729 	int vset_uv, int iset_ua)
1730 {
1731 	u8 usbch_ctrl1 = 0;
1732 	int ret = 0;
1733 
1734 	struct ab8500_charger *di = to_ab8500_charger_usb_device_info(charger);
1735 
1736 	if (!di->usb.charger_connected)
1737 		return ret;
1738 
1739 	ret = abx500_get_register_interruptible(di->dev, AB8500_CHARGER,
1740 				AB8500_USBCH_CTRL1_REG, &usbch_ctrl1);
1741 	if (ret < 0) {
1742 		dev_err(di->dev, "ab8500 read failed %d\n", __LINE__);
1743 		return ret;
1744 	}
1745 	dev_dbg(di->dev, "USB charger ctrl: 0x%02x\n", usbch_ctrl1);
1746 
1747 	if (!(usbch_ctrl1 & USB_CH_ENA)) {
1748 		dev_info(di->dev, "Charging has been disabled abnormally and will be re-enabled\n");
1749 
1750 		ret = abx500_mask_and_set_register_interruptible(di->dev,
1751 					AB8500_CHARGER, AB8500_CHARGER_CTRL,
1752 					DROP_COUNT_RESET, DROP_COUNT_RESET);
1753 		if (ret < 0) {
1754 			dev_err(di->dev, "ab8500 write failed %d\n", __LINE__);
1755 			return ret;
1756 		}
1757 
1758 		ret = ab8500_charger_usb_en(&di->usb_chg, true, vset_uv, iset_ua);
1759 		if (ret < 0) {
1760 			dev_err(di->dev, "Failed to enable VBUS charger %d\n",
1761 					__LINE__);
1762 			return ret;
1763 		}
1764 	}
1765 	return ret;
1766 }
1767 
1768 /**
1769  * ab8500_charger_ac_check_enable() - enable usb charging
1770  * @charger:	pointer to the ux500_charger structure
1771  * @vset_uv:	charging voltage in microvolt
1772  * @iset_ua:	charger output current in micrompere
1773  *
1774  * Check if the AC charger has been disconnected and reconnected without
1775  * AB8500 rising an interrupt. Returns 0 on success.
1776  */
1777 static int ab8500_charger_ac_check_enable(struct ux500_charger *charger,
1778 	int vset_uv, int iset_ua)
1779 {
1780 	u8 mainch_ctrl1 = 0;
1781 	int ret = 0;
1782 
1783 	struct ab8500_charger *di = to_ab8500_charger_ac_device_info(charger);
1784 
1785 	if (!di->ac.charger_connected)
1786 		return ret;
1787 
1788 	ret = abx500_get_register_interruptible(di->dev, AB8500_CHARGER,
1789 				AB8500_MCH_CTRL1, &mainch_ctrl1);
1790 	if (ret < 0) {
1791 		dev_err(di->dev, "ab8500 read failed %d\n", __LINE__);
1792 		return ret;
1793 	}
1794 	dev_dbg(di->dev, "AC charger ctrl: 0x%02x\n", mainch_ctrl1);
1795 
1796 	if (!(mainch_ctrl1 & MAIN_CH_ENA)) {
1797 		dev_info(di->dev, "Charging has been disabled abnormally and will be re-enabled\n");
1798 
1799 		ret = abx500_mask_and_set_register_interruptible(di->dev,
1800 					AB8500_CHARGER, AB8500_CHARGER_CTRL,
1801 					DROP_COUNT_RESET, DROP_COUNT_RESET);
1802 
1803 		if (ret < 0) {
1804 			dev_err(di->dev, "ab8500 write failed %d\n", __LINE__);
1805 			return ret;
1806 		}
1807 
1808 		ret = ab8500_charger_ac_en(&di->usb_chg, true, vset_uv, iset_ua);
1809 		if (ret < 0) {
1810 			dev_err(di->dev, "failed to enable AC charger %d\n",
1811 				__LINE__);
1812 			return ret;
1813 		}
1814 	}
1815 	return ret;
1816 }
1817 
1818 /**
1819  * ab8500_charger_watchdog_kick() - kick charger watchdog
1820  * @di:		pointer to the ab8500_charger structure
1821  *
1822  * Kick charger watchdog
1823  * Returns error code in case of failure else 0(on success)
1824  */
1825 static int ab8500_charger_watchdog_kick(struct ux500_charger *charger)
1826 {
1827 	int ret;
1828 	struct ab8500_charger *di;
1829 
1830 	if (charger->psy->desc->type == POWER_SUPPLY_TYPE_MAINS)
1831 		di = to_ab8500_charger_ac_device_info(charger);
1832 	else if (charger->psy->desc->type == POWER_SUPPLY_TYPE_USB)
1833 		di = to_ab8500_charger_usb_device_info(charger);
1834 	else
1835 		return -ENXIO;
1836 
1837 	ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER,
1838 		AB8500_CHARG_WD_CTRL, CHARG_WD_KICK);
1839 	if (ret)
1840 		dev_err(di->dev, "Failed to kick WD!\n");
1841 
1842 	return ret;
1843 }
1844 
1845 /**
1846  * ab8500_charger_update_charger_current() - update charger current
1847  * @charger:		pointer to the ab8500_charger structure
1848  * @ich_out_ua:		desired output current in microampere
1849  *
1850  * Update the charger output current for the specified charger
1851  * Returns error code in case of failure else 0(on success)
1852  */
1853 static int ab8500_charger_update_charger_current(struct ux500_charger *charger,
1854 		int ich_out_ua)
1855 {
1856 	int ret;
1857 	struct ab8500_charger *di;
1858 
1859 	if (charger->psy->desc->type == POWER_SUPPLY_TYPE_MAINS)
1860 		di = to_ab8500_charger_ac_device_info(charger);
1861 	else if (charger->psy->desc->type == POWER_SUPPLY_TYPE_USB)
1862 		di = to_ab8500_charger_usb_device_info(charger);
1863 	else
1864 		return -ENXIO;
1865 
1866 	ret = ab8500_charger_set_output_curr(di, ich_out_ua);
1867 	if (ret) {
1868 		dev_err(di->dev, "%s "
1869 			"Failed to set ChOutputCurentLevel\n",
1870 			__func__);
1871 		return ret;
1872 	}
1873 
1874 	/* Reset the main and usb drop input current measurement counter */
1875 	ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER,
1876 				AB8500_CHARGER_CTRL, DROP_COUNT_RESET);
1877 	if (ret) {
1878 		dev_err(di->dev, "%s write failed\n", __func__);
1879 		return ret;
1880 	}
1881 
1882 	return ret;
1883 }
1884 
1885 static int ab8500_charger_get_ext_psy_data(struct device *dev, void *data)
1886 {
1887 	struct power_supply *psy;
1888 	struct power_supply *ext = dev_get_drvdata(dev);
1889 	const char **supplicants = (const char **)ext->supplied_to;
1890 	struct ab8500_charger *di;
1891 	union power_supply_propval ret;
1892 	int j;
1893 	struct ux500_charger *usb_chg;
1894 
1895 	usb_chg = (struct ux500_charger *)data;
1896 	psy = usb_chg->psy;
1897 
1898 	di = to_ab8500_charger_usb_device_info(usb_chg);
1899 
1900 	/*
1901 	 * For all psy where the driver name appears in any supplied_to
1902 	 * in practice what we will find will always be "ab8500_fg" as
1903 	 * the fuel gauge is responsible of keeping track of VBAT.
1904 	 */
1905 	j = match_string(supplicants, ext->num_supplicants, psy->desc->name);
1906 	if (j < 0)
1907 		return 0;
1908 
1909 	/* Go through all properties for the psy */
1910 	for (j = 0; j < ext->desc->num_properties; j++) {
1911 		enum power_supply_property prop;
1912 		prop = ext->desc->properties[j];
1913 
1914 		if (power_supply_get_property(ext, prop, &ret))
1915 			continue;
1916 
1917 		switch (prop) {
1918 		case POWER_SUPPLY_PROP_VOLTAGE_NOW:
1919 			switch (ext->desc->type) {
1920 			case POWER_SUPPLY_TYPE_BATTERY:
1921 				/* This will always be "ab8500_fg" */
1922 				dev_dbg(di->dev, "get VBAT from %s\n",
1923 					dev_name(&ext->dev));
1924 				di->vbat = ret.intval;
1925 				break;
1926 			default:
1927 				break;
1928 			}
1929 			break;
1930 		default:
1931 			break;
1932 		}
1933 	}
1934 	return 0;
1935 }
1936 
1937 /**
1938  * ab8500_charger_check_vbat_work() - keep vbus current within spec
1939  * @work	pointer to the work_struct structure
1940  *
1941  * Due to a asic bug it is necessary to lower the input current to the vbus
1942  * charger when charging with at some specific levels. This issue is only valid
1943  * for below a certain battery voltage. This function makes sure that
1944  * the allowed current limit isn't exceeded.
1945  */
1946 static void ab8500_charger_check_vbat_work(struct work_struct *work)
1947 {
1948 	int t = 10;
1949 	struct ab8500_charger *di = container_of(work,
1950 		struct ab8500_charger, check_vbat_work.work);
1951 
1952 	class_for_each_device(power_supply_class, NULL,
1953 			      &di->usb_chg, ab8500_charger_get_ext_psy_data);
1954 
1955 	/* First run old_vbat is 0. */
1956 	if (di->old_vbat == 0)
1957 		di->old_vbat = di->vbat;
1958 
1959 	if (!((di->old_vbat <= VBAT_TRESH_IP_CUR_RED &&
1960 		di->vbat <= VBAT_TRESH_IP_CUR_RED) ||
1961 		(di->old_vbat > VBAT_TRESH_IP_CUR_RED &&
1962 		di->vbat > VBAT_TRESH_IP_CUR_RED))) {
1963 
1964 		dev_dbg(di->dev, "Vbat did cross threshold, curr: %d, new: %d,"
1965 			" old: %d\n", di->max_usb_in_curr.usb_type_max_ua,
1966 			di->vbat, di->old_vbat);
1967 		ab8500_charger_set_vbus_in_curr(di,
1968 					di->max_usb_in_curr.usb_type_max_ua);
1969 		power_supply_changed(di->usb_chg.psy);
1970 	}
1971 
1972 	di->old_vbat = di->vbat;
1973 
1974 	/*
1975 	 * No need to check the battery voltage every second when not close to
1976 	 * the threshold.
1977 	 */
1978 	if (di->vbat < (VBAT_TRESH_IP_CUR_RED + 100000) &&
1979 		(di->vbat > (VBAT_TRESH_IP_CUR_RED - 100000)))
1980 			t = 1;
1981 
1982 	queue_delayed_work(di->charger_wq, &di->check_vbat_work, t * HZ);
1983 }
1984 
1985 /**
1986  * ab8500_charger_check_hw_failure_work() - check main charger failure
1987  * @work:	pointer to the work_struct structure
1988  *
1989  * Work queue function for checking the main charger status
1990  */
1991 static void ab8500_charger_check_hw_failure_work(struct work_struct *work)
1992 {
1993 	int ret;
1994 	u8 reg_value;
1995 
1996 	struct ab8500_charger *di = container_of(work,
1997 		struct ab8500_charger, check_hw_failure_work.work);
1998 
1999 	/* Check if the status bits for HW failure is still active */
2000 	if (di->flags.mainextchnotok) {
2001 		ret = abx500_get_register_interruptible(di->dev,
2002 			AB8500_CHARGER, AB8500_CH_STATUS2_REG, &reg_value);
2003 		if (ret < 0) {
2004 			dev_err(di->dev, "%s ab8500 read failed\n", __func__);
2005 			return;
2006 		}
2007 		if (!(reg_value & MAIN_CH_NOK)) {
2008 			di->flags.mainextchnotok = false;
2009 			ab8500_power_supply_changed(di, di->ac_chg.psy);
2010 		}
2011 	}
2012 	if (di->flags.vbus_ovv) {
2013 		ret = abx500_get_register_interruptible(di->dev,
2014 			AB8500_CHARGER, AB8500_CH_USBCH_STAT2_REG,
2015 			&reg_value);
2016 		if (ret < 0) {
2017 			dev_err(di->dev, "%s ab8500 read failed\n", __func__);
2018 			return;
2019 		}
2020 		if (!(reg_value & VBUS_OVV_TH)) {
2021 			di->flags.vbus_ovv = false;
2022 			ab8500_power_supply_changed(di, di->usb_chg.psy);
2023 		}
2024 	}
2025 	/* If we still have a failure, schedule a new check */
2026 	if (di->flags.mainextchnotok || di->flags.vbus_ovv) {
2027 		queue_delayed_work(di->charger_wq,
2028 			&di->check_hw_failure_work, round_jiffies(HZ));
2029 	}
2030 }
2031 
2032 /**
2033  * ab8500_charger_kick_watchdog_work() - kick the watchdog
2034  * @work:	pointer to the work_struct structure
2035  *
2036  * Work queue function for kicking the charger watchdog.
2037  *
2038  * For ABB revision 1.0 and 1.1 there is a bug in the watchdog
2039  * logic. That means we have to continuously kick the charger
2040  * watchdog even when no charger is connected. This is only
2041  * valid once the AC charger has been enabled. This is
2042  * a bug that is not handled by the algorithm and the
2043  * watchdog have to be kicked by the charger driver
2044  * when the AC charger is disabled
2045  */
2046 static void ab8500_charger_kick_watchdog_work(struct work_struct *work)
2047 {
2048 	int ret;
2049 
2050 	struct ab8500_charger *di = container_of(work,
2051 		struct ab8500_charger, kick_wd_work.work);
2052 
2053 	ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER,
2054 		AB8500_CHARG_WD_CTRL, CHARG_WD_KICK);
2055 	if (ret)
2056 		dev_err(di->dev, "Failed to kick WD!\n");
2057 
2058 	/* Schedule a new watchdog kick */
2059 	queue_delayed_work(di->charger_wq,
2060 		&di->kick_wd_work, round_jiffies(WD_KICK_INTERVAL));
2061 }
2062 
2063 /**
2064  * ab8500_charger_ac_work() - work to get and set main charger status
2065  * @work:	pointer to the work_struct structure
2066  *
2067  * Work queue function for checking the main charger status
2068  */
2069 static void ab8500_charger_ac_work(struct work_struct *work)
2070 {
2071 	int ret;
2072 
2073 	struct ab8500_charger *di = container_of(work,
2074 		struct ab8500_charger, ac_work);
2075 
2076 	/*
2077 	 * Since we can't be sure that the events are received
2078 	 * synchronously, we have the check if the main charger is
2079 	 * connected by reading the status register
2080 	 */
2081 	ret = ab8500_charger_detect_chargers(di, false);
2082 	if (ret < 0)
2083 		return;
2084 
2085 	if (ret & AC_PW_CONN) {
2086 		di->ac.charger_connected = 1;
2087 		di->ac_conn = true;
2088 	} else {
2089 		di->ac.charger_connected = 0;
2090 	}
2091 
2092 	ab8500_power_supply_changed(di, di->ac_chg.psy);
2093 	sysfs_notify(&di->ac_chg.psy->dev.kobj, NULL, "present");
2094 }
2095 
2096 static void ab8500_charger_usb_attached_work(struct work_struct *work)
2097 {
2098 	struct ab8500_charger *di = container_of(work,
2099 						 struct ab8500_charger,
2100 						 usb_charger_attached_work.work);
2101 	int usbch = (USB_CH_VBUSDROP | USB_CH_VBUSDETDBNC);
2102 	int ret, i;
2103 	u8 statval;
2104 
2105 	for (i = 0; i < 10; i++) {
2106 		ret = abx500_get_register_interruptible(di->dev,
2107 							AB8500_CHARGER,
2108 							AB8500_CH_USBCH_STAT1_REG,
2109 							&statval);
2110 		if (ret < 0) {
2111 			dev_err(di->dev, "ab8500 read failed %d\n", __LINE__);
2112 			goto reschedule;
2113 		}
2114 		if ((statval & usbch) != usbch)
2115 			goto reschedule;
2116 
2117 		msleep(CHARGER_STATUS_POLL);
2118 	}
2119 
2120 	ab8500_charger_usb_en(&di->usb_chg, 0, 0, 0);
2121 
2122 	mutex_lock(&di->charger_attached_mutex);
2123 	mutex_unlock(&di->charger_attached_mutex);
2124 
2125 	return;
2126 
2127 reschedule:
2128 	queue_delayed_work(di->charger_wq,
2129 			   &di->usb_charger_attached_work,
2130 			   HZ);
2131 }
2132 
2133 static void ab8500_charger_ac_attached_work(struct work_struct *work)
2134 {
2135 
2136 	struct ab8500_charger *di = container_of(work,
2137 						 struct ab8500_charger,
2138 						 ac_charger_attached_work.work);
2139 	int mainch = (MAIN_CH_STATUS2_MAINCHGDROP |
2140 		      MAIN_CH_STATUS2_MAINCHARGERDETDBNC);
2141 	int ret, i;
2142 	u8 statval;
2143 
2144 	for (i = 0; i < 10; i++) {
2145 		ret = abx500_get_register_interruptible(di->dev,
2146 							AB8500_CHARGER,
2147 							AB8500_CH_STATUS2_REG,
2148 							&statval);
2149 		if (ret < 0) {
2150 			dev_err(di->dev, "ab8500 read failed %d\n", __LINE__);
2151 			goto reschedule;
2152 		}
2153 
2154 		if ((statval & mainch) != mainch)
2155 			goto reschedule;
2156 
2157 		msleep(CHARGER_STATUS_POLL);
2158 	}
2159 
2160 	ab8500_charger_ac_en(&di->ac_chg, 0, 0, 0);
2161 	queue_work(di->charger_wq, &di->ac_work);
2162 
2163 	mutex_lock(&di->charger_attached_mutex);
2164 	mutex_unlock(&di->charger_attached_mutex);
2165 
2166 	return;
2167 
2168 reschedule:
2169 	queue_delayed_work(di->charger_wq,
2170 			   &di->ac_charger_attached_work,
2171 			   HZ);
2172 }
2173 
2174 /**
2175  * ab8500_charger_detect_usb_type_work() - work to detect USB type
2176  * @work:	Pointer to the work_struct structure
2177  *
2178  * Detect the type of USB plugged
2179  */
2180 static void ab8500_charger_detect_usb_type_work(struct work_struct *work)
2181 {
2182 	int ret;
2183 
2184 	struct ab8500_charger *di = container_of(work,
2185 		struct ab8500_charger, detect_usb_type_work);
2186 
2187 	/*
2188 	 * Since we can't be sure that the events are received
2189 	 * synchronously, we have the check if is
2190 	 * connected by reading the status register
2191 	 */
2192 	ret = ab8500_charger_detect_chargers(di, false);
2193 	if (ret < 0)
2194 		return;
2195 
2196 	if (!(ret & USB_PW_CONN)) {
2197 		dev_dbg(di->dev, "%s di->vbus_detected = false\n", __func__);
2198 		di->vbus_detected = false;
2199 		ab8500_charger_set_usb_connected(di, false);
2200 		ab8500_power_supply_changed(di, di->usb_chg.psy);
2201 	} else {
2202 		dev_dbg(di->dev, "%s di->vbus_detected = true\n", __func__);
2203 		di->vbus_detected = true;
2204 
2205 		if (is_ab8500_1p1_or_earlier(di->parent)) {
2206 			ret = ab8500_charger_detect_usb_type(di);
2207 			if (!ret) {
2208 				ab8500_charger_set_usb_connected(di, true);
2209 				ab8500_power_supply_changed(di,
2210 							    di->usb_chg.psy);
2211 			}
2212 		} else {
2213 			/*
2214 			 * For ABB cut2.0 and onwards we have an IRQ,
2215 			 * USB_LINK_STATUS that will be triggered when the USB
2216 			 * link status changes. The exception is USB connected
2217 			 * during startup. Then we don't get a
2218 			 * USB_LINK_STATUS IRQ
2219 			 */
2220 			if (di->vbus_detected_start) {
2221 				di->vbus_detected_start = false;
2222 				ret = ab8500_charger_detect_usb_type(di);
2223 				if (!ret) {
2224 					ab8500_charger_set_usb_connected(di,
2225 						true);
2226 					ab8500_power_supply_changed(di,
2227 						di->usb_chg.psy);
2228 				}
2229 			}
2230 		}
2231 	}
2232 }
2233 
2234 /**
2235  * ab8500_charger_usb_link_attach_work() - work to detect USB type
2236  * @work:	pointer to the work_struct structure
2237  *
2238  * Detect the type of USB plugged
2239  */
2240 static void ab8500_charger_usb_link_attach_work(struct work_struct *work)
2241 {
2242 	struct ab8500_charger *di =
2243 		container_of(work, struct ab8500_charger, attach_work.work);
2244 	int ret;
2245 
2246 	/* Update maximum input current if USB enumeration is not detected */
2247 	if (!di->usb.charger_online) {
2248 		ret = ab8500_charger_set_vbus_in_curr(di,
2249 					di->max_usb_in_curr.usb_type_max_ua);
2250 		if (ret)
2251 			return;
2252 	}
2253 
2254 	ab8500_charger_set_usb_connected(di, true);
2255 	ab8500_power_supply_changed(di, di->usb_chg.psy);
2256 }
2257 
2258 /**
2259  * ab8500_charger_usb_link_status_work() - work to detect USB type
2260  * @work:	pointer to the work_struct structure
2261  *
2262  * Detect the type of USB plugged
2263  */
2264 static void ab8500_charger_usb_link_status_work(struct work_struct *work)
2265 {
2266 	int detected_chargers;
2267 	int ret;
2268 	u8 val;
2269 	u8 link_status;
2270 
2271 	struct ab8500_charger *di = container_of(work,
2272 		struct ab8500_charger, usb_link_status_work);
2273 
2274 	/*
2275 	 * Since we can't be sure that the events are received
2276 	 * synchronously, we have the check if  is
2277 	 * connected by reading the status register
2278 	 */
2279 	detected_chargers = ab8500_charger_detect_chargers(di, false);
2280 	if (detected_chargers < 0)
2281 		return;
2282 
2283 	/*
2284 	 * Some chargers that breaks the USB spec is
2285 	 * identified as invalid by AB8500 and it refuse
2286 	 * to start the charging process. but by jumping
2287 	 * through a few hoops it can be forced to start.
2288 	 */
2289 	if (is_ab8500(di->parent))
2290 		ret = abx500_get_register_interruptible(di->dev, AB8500_USB,
2291 					AB8500_USB_LINE_STAT_REG, &val);
2292 	else
2293 		ret = abx500_get_register_interruptible(di->dev, AB8500_USB,
2294 					AB8500_USB_LINK1_STAT_REG, &val);
2295 
2296 	if (ret >= 0)
2297 		dev_dbg(di->dev, "UsbLineStatus register = 0x%02x\n", val);
2298 	else
2299 		dev_dbg(di->dev, "Error reading USB link status\n");
2300 
2301 	if (is_ab8500(di->parent))
2302 		link_status = AB8500_USB_LINK_STATUS;
2303 	else
2304 		link_status = AB8505_USB_LINK_STATUS;
2305 
2306 	if (detected_chargers & USB_PW_CONN) {
2307 		if (((val & link_status) >> USB_LINK_STATUS_SHIFT) ==
2308 				USB_STAT_NOT_VALID_LINK &&
2309 				di->invalid_charger_detect_state == 0) {
2310 			dev_dbg(di->dev,
2311 					"Invalid charger detected, state= 0\n");
2312 			/*Enable charger*/
2313 			abx500_mask_and_set_register_interruptible(di->dev,
2314 					AB8500_CHARGER, AB8500_USBCH_CTRL1_REG,
2315 					USB_CH_ENA, USB_CH_ENA);
2316 			/*Enable charger detection*/
2317 			abx500_mask_and_set_register_interruptible(di->dev,
2318 					AB8500_USB, AB8500_USB_LINE_CTRL2_REG,
2319 					USB_CH_DET, USB_CH_DET);
2320 			di->invalid_charger_detect_state = 1;
2321 			/*exit and wait for new link status interrupt.*/
2322 			return;
2323 
2324 		}
2325 		if (di->invalid_charger_detect_state == 1) {
2326 			dev_dbg(di->dev,
2327 					"Invalid charger detected, state= 1\n");
2328 			/*Stop charger detection*/
2329 			abx500_mask_and_set_register_interruptible(di->dev,
2330 					AB8500_USB, AB8500_USB_LINE_CTRL2_REG,
2331 					USB_CH_DET, 0x00);
2332 			/*Check link status*/
2333 			if (is_ab8500(di->parent))
2334 				ret = abx500_get_register_interruptible(di->dev,
2335 					AB8500_USB, AB8500_USB_LINE_STAT_REG,
2336 					&val);
2337 			else
2338 				ret = abx500_get_register_interruptible(di->dev,
2339 					AB8500_USB, AB8500_USB_LINK1_STAT_REG,
2340 					&val);
2341 
2342 			dev_dbg(di->dev, "USB link status= 0x%02x\n",
2343 				(val & link_status) >> USB_LINK_STATUS_SHIFT);
2344 			di->invalid_charger_detect_state = 2;
2345 		}
2346 	} else {
2347 		di->invalid_charger_detect_state = 0;
2348 	}
2349 
2350 	if (!(detected_chargers & USB_PW_CONN)) {
2351 		di->vbus_detected = false;
2352 		ab8500_charger_set_usb_connected(di, false);
2353 		ab8500_power_supply_changed(di, di->usb_chg.psy);
2354 		return;
2355 	}
2356 
2357 	dev_dbg(di->dev,"%s di->vbus_detected = true\n",__func__);
2358 	di->vbus_detected = true;
2359 	ret = ab8500_charger_read_usb_type(di);
2360 	if (ret) {
2361 		if (ret == -ENXIO) {
2362 			/* No valid charger type detected */
2363 			ab8500_charger_set_usb_connected(di, false);
2364 			ab8500_power_supply_changed(di, di->usb_chg.psy);
2365 		}
2366 		return;
2367 	}
2368 
2369 	if (di->usb_device_is_unrecognised) {
2370 		dev_dbg(di->dev,
2371 			"Potential Legacy Charger device. "
2372 			"Delay work for %d msec for USB enum "
2373 			"to finish",
2374 			WAIT_ACA_RID_ENUMERATION);
2375 		queue_delayed_work(di->charger_wq,
2376 				   &di->attach_work,
2377 				   msecs_to_jiffies(WAIT_ACA_RID_ENUMERATION));
2378 	} else if (di->is_aca_rid == 1) {
2379 		/* Only wait once */
2380 		di->is_aca_rid++;
2381 		dev_dbg(di->dev,
2382 			"%s Wait %d msec for USB enum to finish",
2383 			__func__, WAIT_ACA_RID_ENUMERATION);
2384 		queue_delayed_work(di->charger_wq,
2385 				   &di->attach_work,
2386 				   msecs_to_jiffies(WAIT_ACA_RID_ENUMERATION));
2387 	} else {
2388 		queue_delayed_work(di->charger_wq,
2389 				   &di->attach_work,
2390 				   0);
2391 	}
2392 }
2393 
2394 static void ab8500_charger_usb_state_changed_work(struct work_struct *work)
2395 {
2396 	int ret;
2397 	unsigned long flags;
2398 
2399 	struct ab8500_charger *di = container_of(work,
2400 		struct ab8500_charger, usb_state_changed_work.work);
2401 
2402 	if (!di->vbus_detected)	{
2403 		dev_dbg(di->dev,
2404 			"%s !di->vbus_detected\n",
2405 			__func__);
2406 		return;
2407 	}
2408 
2409 	spin_lock_irqsave(&di->usb_state.usb_lock, flags);
2410 	di->usb_state.state = di->usb_state.state_tmp;
2411 	di->usb_state.usb_current_ua = di->usb_state.usb_current_tmp_ua;
2412 	spin_unlock_irqrestore(&di->usb_state.usb_lock, flags);
2413 
2414 	dev_dbg(di->dev, "%s USB state: 0x%02x uA: %d\n",
2415 		__func__, di->usb_state.state, di->usb_state.usb_current_ua);
2416 
2417 	switch (di->usb_state.state) {
2418 	case AB8500_BM_USB_STATE_RESET_HS:
2419 	case AB8500_BM_USB_STATE_RESET_FS:
2420 	case AB8500_BM_USB_STATE_SUSPEND:
2421 	case AB8500_BM_USB_STATE_MAX:
2422 		ab8500_charger_set_usb_connected(di, false);
2423 		ab8500_power_supply_changed(di, di->usb_chg.psy);
2424 		break;
2425 
2426 	case AB8500_BM_USB_STATE_RESUME:
2427 		/*
2428 		 * when suspend->resume there should be delay
2429 		 * of 1sec for enabling charging
2430 		 */
2431 		msleep(1000);
2432 		fallthrough;
2433 	case AB8500_BM_USB_STATE_CONFIGURED:
2434 		/*
2435 		 * USB is configured, enable charging with the charging
2436 		 * input current obtained from USB driver
2437 		 */
2438 		if (!ab8500_charger_get_usb_cur(di)) {
2439 			/* Update maximum input current */
2440 			ret = ab8500_charger_set_vbus_in_curr(di,
2441 					di->max_usb_in_curr.usb_type_max_ua);
2442 			if (ret)
2443 				return;
2444 
2445 			ab8500_charger_set_usb_connected(di, true);
2446 			ab8500_power_supply_changed(di, di->usb_chg.psy);
2447 		}
2448 		break;
2449 
2450 	default:
2451 		break;
2452 	}
2453 }
2454 
2455 /**
2456  * ab8500_charger_check_usbchargernotok_work() - check USB chg not ok status
2457  * @work:	pointer to the work_struct structure
2458  *
2459  * Work queue function for checking the USB charger Not OK status
2460  */
2461 static void ab8500_charger_check_usbchargernotok_work(struct work_struct *work)
2462 {
2463 	int ret;
2464 	u8 reg_value;
2465 	bool prev_status;
2466 
2467 	struct ab8500_charger *di = container_of(work,
2468 		struct ab8500_charger, check_usbchgnotok_work.work);
2469 
2470 	/* Check if the status bit for usbchargernotok is still active */
2471 	ret = abx500_get_register_interruptible(di->dev,
2472 		AB8500_CHARGER, AB8500_CH_USBCH_STAT2_REG, &reg_value);
2473 	if (ret < 0) {
2474 		dev_err(di->dev, "%s ab8500 read failed\n", __func__);
2475 		return;
2476 	}
2477 	prev_status = di->flags.usbchargernotok;
2478 
2479 	if (reg_value & VBUS_CH_NOK) {
2480 		di->flags.usbchargernotok = true;
2481 		/* Check again in 1sec */
2482 		queue_delayed_work(di->charger_wq,
2483 			&di->check_usbchgnotok_work, HZ);
2484 	} else {
2485 		di->flags.usbchargernotok = false;
2486 		di->flags.vbus_collapse = false;
2487 	}
2488 
2489 	if (prev_status != di->flags.usbchargernotok)
2490 		ab8500_power_supply_changed(di, di->usb_chg.psy);
2491 }
2492 
2493 /**
2494  * ab8500_charger_check_main_thermal_prot_work() - check main thermal status
2495  * @work:	pointer to the work_struct structure
2496  *
2497  * Work queue function for checking the Main thermal prot status
2498  */
2499 static void ab8500_charger_check_main_thermal_prot_work(
2500 	struct work_struct *work)
2501 {
2502 	int ret;
2503 	u8 reg_value;
2504 
2505 	struct ab8500_charger *di = container_of(work,
2506 		struct ab8500_charger, check_main_thermal_prot_work);
2507 
2508 	/* Check if the status bit for main_thermal_prot is still active */
2509 	ret = abx500_get_register_interruptible(di->dev,
2510 		AB8500_CHARGER, AB8500_CH_STATUS2_REG, &reg_value);
2511 	if (ret < 0) {
2512 		dev_err(di->dev, "%s ab8500 read failed\n", __func__);
2513 		return;
2514 	}
2515 	if (reg_value & MAIN_CH_TH_PROT)
2516 		di->flags.main_thermal_prot = true;
2517 	else
2518 		di->flags.main_thermal_prot = false;
2519 
2520 	ab8500_power_supply_changed(di, di->ac_chg.psy);
2521 }
2522 
2523 /**
2524  * ab8500_charger_check_usb_thermal_prot_work() - check usb thermal status
2525  * @work:	pointer to the work_struct structure
2526  *
2527  * Work queue function for checking the USB thermal prot status
2528  */
2529 static void ab8500_charger_check_usb_thermal_prot_work(
2530 	struct work_struct *work)
2531 {
2532 	int ret;
2533 	u8 reg_value;
2534 
2535 	struct ab8500_charger *di = container_of(work,
2536 		struct ab8500_charger, check_usb_thermal_prot_work);
2537 
2538 	/* Check if the status bit for usb_thermal_prot is still active */
2539 	ret = abx500_get_register_interruptible(di->dev,
2540 		AB8500_CHARGER, AB8500_CH_USBCH_STAT2_REG, &reg_value);
2541 	if (ret < 0) {
2542 		dev_err(di->dev, "%s ab8500 read failed\n", __func__);
2543 		return;
2544 	}
2545 	if (reg_value & USB_CH_TH_PROT)
2546 		di->flags.usb_thermal_prot = true;
2547 	else
2548 		di->flags.usb_thermal_prot = false;
2549 
2550 	ab8500_power_supply_changed(di, di->usb_chg.psy);
2551 }
2552 
2553 /**
2554  * ab8500_charger_mainchunplugdet_handler() - main charger unplugged
2555  * @irq:       interrupt number
2556  * @_di:       pointer to the ab8500_charger structure
2557  *
2558  * Returns IRQ status(IRQ_HANDLED)
2559  */
2560 static irqreturn_t ab8500_charger_mainchunplugdet_handler(int irq, void *_di)
2561 {
2562 	struct ab8500_charger *di = _di;
2563 
2564 	dev_dbg(di->dev, "Main charger unplugged\n");
2565 	queue_work(di->charger_wq, &di->ac_work);
2566 
2567 	cancel_delayed_work_sync(&di->ac_charger_attached_work);
2568 	mutex_lock(&di->charger_attached_mutex);
2569 	mutex_unlock(&di->charger_attached_mutex);
2570 
2571 	return IRQ_HANDLED;
2572 }
2573 
2574 /**
2575  * ab8500_charger_mainchplugdet_handler() - main charger plugged
2576  * @irq:       interrupt number
2577  * @_di:       pointer to the ab8500_charger structure
2578  *
2579  * Returns IRQ status(IRQ_HANDLED)
2580  */
2581 static irqreturn_t ab8500_charger_mainchplugdet_handler(int irq, void *_di)
2582 {
2583 	struct ab8500_charger *di = _di;
2584 
2585 	dev_dbg(di->dev, "Main charger plugged\n");
2586 	queue_work(di->charger_wq, &di->ac_work);
2587 
2588 	mutex_lock(&di->charger_attached_mutex);
2589 	mutex_unlock(&di->charger_attached_mutex);
2590 
2591 	if (is_ab8500(di->parent))
2592 		queue_delayed_work(di->charger_wq,
2593 			   &di->ac_charger_attached_work,
2594 			   HZ);
2595 	return IRQ_HANDLED;
2596 }
2597 
2598 /**
2599  * ab8500_charger_mainextchnotok_handler() - main charger not ok
2600  * @irq:       interrupt number
2601  * @_di:       pointer to the ab8500_charger structure
2602  *
2603  * Returns IRQ status(IRQ_HANDLED)
2604  */
2605 static irqreturn_t ab8500_charger_mainextchnotok_handler(int irq, void *_di)
2606 {
2607 	struct ab8500_charger *di = _di;
2608 
2609 	dev_dbg(di->dev, "Main charger not ok\n");
2610 	di->flags.mainextchnotok = true;
2611 	ab8500_power_supply_changed(di, di->ac_chg.psy);
2612 
2613 	/* Schedule a new HW failure check */
2614 	queue_delayed_work(di->charger_wq, &di->check_hw_failure_work, 0);
2615 
2616 	return IRQ_HANDLED;
2617 }
2618 
2619 /**
2620  * ab8500_charger_mainchthprotr_handler() - Die temp is above main charger
2621  * thermal protection threshold
2622  * @irq:       interrupt number
2623  * @_di:       pointer to the ab8500_charger structure
2624  *
2625  * Returns IRQ status(IRQ_HANDLED)
2626  */
2627 static irqreturn_t ab8500_charger_mainchthprotr_handler(int irq, void *_di)
2628 {
2629 	struct ab8500_charger *di = _di;
2630 
2631 	dev_dbg(di->dev,
2632 		"Die temp above Main charger thermal protection threshold\n");
2633 	queue_work(di->charger_wq, &di->check_main_thermal_prot_work);
2634 
2635 	return IRQ_HANDLED;
2636 }
2637 
2638 /**
2639  * ab8500_charger_mainchthprotf_handler() - Die temp is below main charger
2640  * thermal protection threshold
2641  * @irq:       interrupt number
2642  * @_di:       pointer to the ab8500_charger structure
2643  *
2644  * Returns IRQ status(IRQ_HANDLED)
2645  */
2646 static irqreturn_t ab8500_charger_mainchthprotf_handler(int irq, void *_di)
2647 {
2648 	struct ab8500_charger *di = _di;
2649 
2650 	dev_dbg(di->dev,
2651 		"Die temp ok for Main charger thermal protection threshold\n");
2652 	queue_work(di->charger_wq, &di->check_main_thermal_prot_work);
2653 
2654 	return IRQ_HANDLED;
2655 }
2656 
2657 static void ab8500_charger_vbus_drop_end_work(struct work_struct *work)
2658 {
2659 	struct ab8500_charger *di = container_of(work,
2660 		struct ab8500_charger, vbus_drop_end_work.work);
2661 	int ret, curr_ua;
2662 	u8 reg_value;
2663 
2664 	di->flags.vbus_drop_end = false;
2665 
2666 	/* Reset the drop counter */
2667 	abx500_set_register_interruptible(di->dev,
2668 				  AB8500_CHARGER, AB8500_CHARGER_CTRL, 0x01);
2669 
2670 	ret = abx500_get_register_interruptible(di->dev, AB8500_CHARGER,
2671 			AB8500_CH_USBCH_STAT2_REG, &reg_value);
2672 	if (ret < 0) {
2673 		dev_err(di->dev, "%s read failed\n", __func__);
2674 		return;
2675 	}
2676 
2677 	curr_ua = ab8500_charge_input_curr_map[
2678 		reg_value >> AUTO_VBUS_IN_CURR_LIM_SHIFT];
2679 
2680 	if (di->max_usb_in_curr.calculated_max_ua != curr_ua) {
2681 		/* USB source is collapsing */
2682 		di->max_usb_in_curr.calculated_max_ua = curr_ua;
2683 		dev_dbg(di->dev,
2684 			 "VBUS input current limiting to %d uA\n",
2685 			 di->max_usb_in_curr.calculated_max_ua);
2686 	} else {
2687 		/*
2688 		 * USB source can not give more than this amount.
2689 		 * Taking more will collapse the source.
2690 		 */
2691 		di->max_usb_in_curr.set_max_ua =
2692 			di->max_usb_in_curr.calculated_max_ua;
2693 		dev_dbg(di->dev,
2694 			 "VBUS input current limited to %d uA\n",
2695 			 di->max_usb_in_curr.set_max_ua);
2696 	}
2697 
2698 	if (di->usb.charger_connected)
2699 		ab8500_charger_set_vbus_in_curr(di,
2700 					di->max_usb_in_curr.usb_type_max_ua);
2701 }
2702 
2703 /**
2704  * ab8500_charger_vbusdetf_handler() - VBUS falling detected
2705  * @irq:       interrupt number
2706  * @_di:       pointer to the ab8500_charger structure
2707  *
2708  * Returns IRQ status(IRQ_HANDLED)
2709  */
2710 static irqreturn_t ab8500_charger_vbusdetf_handler(int irq, void *_di)
2711 {
2712 	struct ab8500_charger *di = _di;
2713 
2714 	di->vbus_detected = false;
2715 	dev_dbg(di->dev, "VBUS falling detected\n");
2716 	queue_work(di->charger_wq, &di->detect_usb_type_work);
2717 
2718 	return IRQ_HANDLED;
2719 }
2720 
2721 /**
2722  * ab8500_charger_vbusdetr_handler() - VBUS rising detected
2723  * @irq:       interrupt number
2724  * @_di:       pointer to the ab8500_charger structure
2725  *
2726  * Returns IRQ status(IRQ_HANDLED)
2727  */
2728 static irqreturn_t ab8500_charger_vbusdetr_handler(int irq, void *_di)
2729 {
2730 	struct ab8500_charger *di = _di;
2731 
2732 	di->vbus_detected = true;
2733 	dev_dbg(di->dev, "VBUS rising detected\n");
2734 
2735 	queue_work(di->charger_wq, &di->detect_usb_type_work);
2736 
2737 	return IRQ_HANDLED;
2738 }
2739 
2740 /**
2741  * ab8500_charger_usblinkstatus_handler() - USB link status has changed
2742  * @irq:       interrupt number
2743  * @_di:       pointer to the ab8500_charger structure
2744  *
2745  * Returns IRQ status(IRQ_HANDLED)
2746  */
2747 static irqreturn_t ab8500_charger_usblinkstatus_handler(int irq, void *_di)
2748 {
2749 	struct ab8500_charger *di = _di;
2750 
2751 	dev_dbg(di->dev, "USB link status changed\n");
2752 
2753 	queue_work(di->charger_wq, &di->usb_link_status_work);
2754 
2755 	return IRQ_HANDLED;
2756 }
2757 
2758 /**
2759  * ab8500_charger_usbchthprotr_handler() - Die temp is above usb charger
2760  * thermal protection threshold
2761  * @irq:       interrupt number
2762  * @_di:       pointer to the ab8500_charger structure
2763  *
2764  * Returns IRQ status(IRQ_HANDLED)
2765  */
2766 static irqreturn_t ab8500_charger_usbchthprotr_handler(int irq, void *_di)
2767 {
2768 	struct ab8500_charger *di = _di;
2769 
2770 	dev_dbg(di->dev,
2771 		"Die temp above USB charger thermal protection threshold\n");
2772 	queue_work(di->charger_wq, &di->check_usb_thermal_prot_work);
2773 
2774 	return IRQ_HANDLED;
2775 }
2776 
2777 /**
2778  * ab8500_charger_usbchthprotf_handler() - Die temp is below usb charger
2779  * thermal protection threshold
2780  * @irq:       interrupt number
2781  * @_di:       pointer to the ab8500_charger structure
2782  *
2783  * Returns IRQ status(IRQ_HANDLED)
2784  */
2785 static irqreturn_t ab8500_charger_usbchthprotf_handler(int irq, void *_di)
2786 {
2787 	struct ab8500_charger *di = _di;
2788 
2789 	dev_dbg(di->dev,
2790 		"Die temp ok for USB charger thermal protection threshold\n");
2791 	queue_work(di->charger_wq, &di->check_usb_thermal_prot_work);
2792 
2793 	return IRQ_HANDLED;
2794 }
2795 
2796 /**
2797  * ab8500_charger_usbchargernotokr_handler() - USB charger not ok detected
2798  * @irq:       interrupt number
2799  * @_di:       pointer to the ab8500_charger structure
2800  *
2801  * Returns IRQ status(IRQ_HANDLED)
2802  */
2803 static irqreturn_t ab8500_charger_usbchargernotokr_handler(int irq, void *_di)
2804 {
2805 	struct ab8500_charger *di = _di;
2806 
2807 	dev_dbg(di->dev, "Not allowed USB charger detected\n");
2808 	queue_delayed_work(di->charger_wq, &di->check_usbchgnotok_work, 0);
2809 
2810 	return IRQ_HANDLED;
2811 }
2812 
2813 /**
2814  * ab8500_charger_chwdexp_handler() - Charger watchdog expired
2815  * @irq:       interrupt number
2816  * @_di:       pointer to the ab8500_charger structure
2817  *
2818  * Returns IRQ status(IRQ_HANDLED)
2819  */
2820 static irqreturn_t ab8500_charger_chwdexp_handler(int irq, void *_di)
2821 {
2822 	struct ab8500_charger *di = _di;
2823 
2824 	dev_dbg(di->dev, "Charger watchdog expired\n");
2825 
2826 	/*
2827 	 * The charger that was online when the watchdog expired
2828 	 * needs to be restarted for charging to start again
2829 	 */
2830 	if (di->ac.charger_online) {
2831 		di->ac.wd_expired = true;
2832 		ab8500_power_supply_changed(di, di->ac_chg.psy);
2833 	}
2834 	if (di->usb.charger_online) {
2835 		di->usb.wd_expired = true;
2836 		ab8500_power_supply_changed(di, di->usb_chg.psy);
2837 	}
2838 
2839 	return IRQ_HANDLED;
2840 }
2841 
2842 /**
2843  * ab8500_charger_vbuschdropend_handler() - VBUS drop removed
2844  * @irq:       interrupt number
2845  * @_di:       pointer to the ab8500_charger structure
2846  *
2847  * Returns IRQ status(IRQ_HANDLED)
2848  */
2849 static irqreturn_t ab8500_charger_vbuschdropend_handler(int irq, void *_di)
2850 {
2851 	struct ab8500_charger *di = _di;
2852 
2853 	dev_dbg(di->dev, "VBUS charger drop ended\n");
2854 	di->flags.vbus_drop_end = true;
2855 
2856 	/*
2857 	 * VBUS might have dropped due to bad connection.
2858 	 * Schedule a new input limit set to the value SW requests.
2859 	 */
2860 	queue_delayed_work(di->charger_wq, &di->vbus_drop_end_work,
2861 			   round_jiffies(VBUS_IN_CURR_LIM_RETRY_SET_TIME * HZ));
2862 
2863 	return IRQ_HANDLED;
2864 }
2865 
2866 /**
2867  * ab8500_charger_vbusovv_handler() - VBUS overvoltage detected
2868  * @irq:       interrupt number
2869  * @_di:       pointer to the ab8500_charger structure
2870  *
2871  * Returns IRQ status(IRQ_HANDLED)
2872  */
2873 static irqreturn_t ab8500_charger_vbusovv_handler(int irq, void *_di)
2874 {
2875 	struct ab8500_charger *di = _di;
2876 
2877 	dev_dbg(di->dev, "VBUS overvoltage detected\n");
2878 	di->flags.vbus_ovv = true;
2879 	ab8500_power_supply_changed(di, di->usb_chg.psy);
2880 
2881 	/* Schedule a new HW failure check */
2882 	queue_delayed_work(di->charger_wq, &di->check_hw_failure_work, 0);
2883 
2884 	return IRQ_HANDLED;
2885 }
2886 
2887 /**
2888  * ab8500_charger_ac_get_property() - get the ac/mains properties
2889  * @psy:       pointer to the power_supply structure
2890  * @psp:       pointer to the power_supply_property structure
2891  * @val:       pointer to the power_supply_propval union
2892  *
2893  * This function gets called when an application tries to get the ac/mains
2894  * properties by reading the sysfs files.
2895  * AC/Mains properties are online, present and voltage.
2896  * online:     ac/mains charging is in progress or not
2897  * present:    presence of the ac/mains
2898  * voltage:    AC/Mains voltage
2899  * Returns error code in case of failure else 0(on success)
2900  */
2901 static int ab8500_charger_ac_get_property(struct power_supply *psy,
2902 	enum power_supply_property psp,
2903 	union power_supply_propval *val)
2904 {
2905 	struct ab8500_charger *di;
2906 	int ret;
2907 
2908 	di = to_ab8500_charger_ac_device_info(psy_to_ux500_charger(psy));
2909 
2910 	switch (psp) {
2911 	case POWER_SUPPLY_PROP_HEALTH:
2912 		if (di->flags.mainextchnotok)
2913 			val->intval = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
2914 		else if (di->ac.wd_expired || di->usb.wd_expired)
2915 			val->intval = POWER_SUPPLY_HEALTH_DEAD;
2916 		else if (di->flags.main_thermal_prot)
2917 			val->intval = POWER_SUPPLY_HEALTH_OVERHEAT;
2918 		else
2919 			val->intval = POWER_SUPPLY_HEALTH_GOOD;
2920 		break;
2921 	case POWER_SUPPLY_PROP_ONLINE:
2922 		val->intval = di->ac.charger_online;
2923 		break;
2924 	case POWER_SUPPLY_PROP_PRESENT:
2925 		val->intval = di->ac.charger_connected;
2926 		break;
2927 	case POWER_SUPPLY_PROP_VOLTAGE_NOW:
2928 		ret = ab8500_charger_get_ac_voltage(di);
2929 		if (ret >= 0)
2930 			di->ac.charger_voltage_uv = ret;
2931 		/* On error, use previous value */
2932 		val->intval = di->ac.charger_voltage_uv;
2933 		break;
2934 	case POWER_SUPPLY_PROP_VOLTAGE_AVG:
2935 		/*
2936 		 * This property is used to indicate when CV mode is entered
2937 		 * for the AC charger
2938 		 */
2939 		di->ac.cv_active = ab8500_charger_ac_cv(di);
2940 		val->intval = di->ac.cv_active;
2941 		break;
2942 	case POWER_SUPPLY_PROP_CURRENT_NOW:
2943 		ret = ab8500_charger_get_ac_current(di);
2944 		if (ret >= 0)
2945 			di->ac.charger_current_ua = ret;
2946 		val->intval = di->ac.charger_current_ua;
2947 		break;
2948 	default:
2949 		return -EINVAL;
2950 	}
2951 	return 0;
2952 }
2953 
2954 /**
2955  * ab8500_charger_usb_get_property() - get the usb properties
2956  * @psy:        pointer to the power_supply structure
2957  * @psp:        pointer to the power_supply_property structure
2958  * @val:        pointer to the power_supply_propval union
2959  *
2960  * This function gets called when an application tries to get the usb
2961  * properties by reading the sysfs files.
2962  * USB properties are online, present and voltage.
2963  * online:     usb charging is in progress or not
2964  * present:    presence of the usb
2965  * voltage:    vbus voltage
2966  * Returns error code in case of failure else 0(on success)
2967  */
2968 static int ab8500_charger_usb_get_property(struct power_supply *psy,
2969 	enum power_supply_property psp,
2970 	union power_supply_propval *val)
2971 {
2972 	struct ab8500_charger *di;
2973 	int ret;
2974 
2975 	di = to_ab8500_charger_usb_device_info(psy_to_ux500_charger(psy));
2976 
2977 	switch (psp) {
2978 	case POWER_SUPPLY_PROP_HEALTH:
2979 		if (di->flags.usbchargernotok)
2980 			val->intval = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
2981 		else if (di->ac.wd_expired || di->usb.wd_expired)
2982 			val->intval = POWER_SUPPLY_HEALTH_DEAD;
2983 		else if (di->flags.usb_thermal_prot)
2984 			val->intval = POWER_SUPPLY_HEALTH_OVERHEAT;
2985 		else if (di->flags.vbus_ovv)
2986 			val->intval = POWER_SUPPLY_HEALTH_OVERVOLTAGE;
2987 		else
2988 			val->intval = POWER_SUPPLY_HEALTH_GOOD;
2989 		break;
2990 	case POWER_SUPPLY_PROP_ONLINE:
2991 		val->intval = di->usb.charger_online;
2992 		break;
2993 	case POWER_SUPPLY_PROP_PRESENT:
2994 		val->intval = di->usb.charger_connected;
2995 		break;
2996 	case POWER_SUPPLY_PROP_VOLTAGE_NOW:
2997 		ret = ab8500_charger_get_vbus_voltage(di);
2998 		if (ret >= 0)
2999 			di->usb.charger_voltage_uv = ret;
3000 		val->intval = di->usb.charger_voltage_uv;
3001 		break;
3002 	case POWER_SUPPLY_PROP_VOLTAGE_AVG:
3003 		/*
3004 		 * This property is used to indicate when CV mode is entered
3005 		 * for the USB charger
3006 		 */
3007 		di->usb.cv_active = ab8500_charger_usb_cv(di);
3008 		val->intval = di->usb.cv_active;
3009 		break;
3010 	case POWER_SUPPLY_PROP_CURRENT_NOW:
3011 		ret = ab8500_charger_get_usb_current(di);
3012 		if (ret >= 0)
3013 			di->usb.charger_current_ua = ret;
3014 		val->intval = di->usb.charger_current_ua;
3015 		break;
3016 	case POWER_SUPPLY_PROP_CURRENT_AVG:
3017 		/*
3018 		 * This property is used to indicate when VBUS has collapsed
3019 		 * due to too high output current from the USB charger
3020 		 */
3021 		if (di->flags.vbus_collapse)
3022 			val->intval = 1;
3023 		else
3024 			val->intval = 0;
3025 		break;
3026 	default:
3027 		return -EINVAL;
3028 	}
3029 	return 0;
3030 }
3031 
3032 /**
3033  * ab8500_charger_init_hw_registers() - Set up charger related registers
3034  * @di:		pointer to the ab8500_charger structure
3035  *
3036  * Set up charger OVV, watchdog and maximum voltage registers as well as
3037  * charging of the backup battery
3038  */
3039 static int ab8500_charger_init_hw_registers(struct ab8500_charger *di)
3040 {
3041 	int ret = 0;
3042 
3043 	/* Setup maximum charger current and voltage for ABB cut2.0 */
3044 	if (!is_ab8500_1p1_or_earlier(di->parent)) {
3045 		ret = abx500_set_register_interruptible(di->dev,
3046 			AB8500_CHARGER,
3047 			AB8500_CH_VOLT_LVL_MAX_REG, CH_VOL_LVL_4P6);
3048 		if (ret) {
3049 			dev_err(di->dev,
3050 				"failed to set CH_VOLT_LVL_MAX_REG\n");
3051 			goto out;
3052 		}
3053 
3054 		ret = abx500_set_register_interruptible(di->dev,
3055 			AB8500_CHARGER, AB8500_CH_OPT_CRNTLVL_MAX_REG,
3056 			CH_OP_CUR_LVL_1P6);
3057 		if (ret) {
3058 			dev_err(di->dev,
3059 				"failed to set CH_OPT_CRNTLVL_MAX_REG\n");
3060 			goto out;
3061 		}
3062 	}
3063 
3064 	if (is_ab8505_2p0(di->parent))
3065 		ret = abx500_mask_and_set_register_interruptible(di->dev,
3066 			AB8500_CHARGER,
3067 			AB8500_USBCH_CTRL2_REG,
3068 			VBUS_AUTO_IN_CURR_LIM_ENA,
3069 			VBUS_AUTO_IN_CURR_LIM_ENA);
3070 	else
3071 		/*
3072 		 * VBUS OVV set to 6.3V and enable automatic current limitation
3073 		 */
3074 		ret = abx500_set_register_interruptible(di->dev,
3075 			AB8500_CHARGER,
3076 			AB8500_USBCH_CTRL2_REG,
3077 			VBUS_OVV_SELECT_6P3V | VBUS_AUTO_IN_CURR_LIM_ENA);
3078 	if (ret) {
3079 		dev_err(di->dev,
3080 			"failed to set automatic current limitation\n");
3081 		goto out;
3082 	}
3083 
3084 	/* Enable main watchdog in OTP */
3085 	ret = abx500_set_register_interruptible(di->dev,
3086 		AB8500_OTP_EMUL, AB8500_OTP_CONF_15, OTP_ENABLE_WD);
3087 	if (ret) {
3088 		dev_err(di->dev, "failed to enable main WD in OTP\n");
3089 		goto out;
3090 	}
3091 
3092 	/* Enable main watchdog */
3093 	ret = abx500_set_register_interruptible(di->dev,
3094 		AB8500_SYS_CTRL2_BLOCK,
3095 		AB8500_MAIN_WDOG_CTRL_REG, MAIN_WDOG_ENA);
3096 	if (ret) {
3097 		dev_err(di->dev, "failed to enable main watchdog\n");
3098 		goto out;
3099 	}
3100 
3101 	/*
3102 	 * Due to internal synchronisation, Enable and Kick watchdog bits
3103 	 * cannot be enabled in a single write.
3104 	 * A minimum delay of 2*32 kHz period (62.5µs) must be inserted
3105 	 * between writing Enable then Kick bits.
3106 	 */
3107 	udelay(63);
3108 
3109 	/* Kick main watchdog */
3110 	ret = abx500_set_register_interruptible(di->dev,
3111 		AB8500_SYS_CTRL2_BLOCK,
3112 		AB8500_MAIN_WDOG_CTRL_REG,
3113 		(MAIN_WDOG_ENA | MAIN_WDOG_KICK));
3114 	if (ret) {
3115 		dev_err(di->dev, "failed to kick main watchdog\n");
3116 		goto out;
3117 	}
3118 
3119 	/* Disable main watchdog */
3120 	ret = abx500_set_register_interruptible(di->dev,
3121 		AB8500_SYS_CTRL2_BLOCK,
3122 		AB8500_MAIN_WDOG_CTRL_REG, MAIN_WDOG_DIS);
3123 	if (ret) {
3124 		dev_err(di->dev, "failed to disable main watchdog\n");
3125 		goto out;
3126 	}
3127 
3128 	/* Set watchdog timeout */
3129 	ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER,
3130 		AB8500_CH_WD_TIMER_REG, WD_TIMER);
3131 	if (ret) {
3132 		dev_err(di->dev, "failed to set charger watchdog timeout\n");
3133 		goto out;
3134 	}
3135 
3136 	ret = ab8500_charger_led_en(di, false);
3137 	if (ret < 0) {
3138 		dev_err(di->dev, "failed to disable LED\n");
3139 		goto out;
3140 	}
3141 
3142 	ret = abx500_set_register_interruptible(di->dev,
3143 		AB8500_RTC,
3144 		AB8500_RTC_BACKUP_CHG_REG,
3145 		(di->bm->bkup_bat_v & 0x3) | di->bm->bkup_bat_i);
3146 	if (ret) {
3147 		dev_err(di->dev, "failed to setup backup battery charging\n");
3148 		goto out;
3149 	}
3150 
3151 	/* Enable backup battery charging */
3152 	ret = abx500_mask_and_set_register_interruptible(di->dev,
3153 		AB8500_RTC, AB8500_RTC_CTRL_REG,
3154 		RTC_BUP_CH_ENA, RTC_BUP_CH_ENA);
3155 	if (ret < 0) {
3156 		dev_err(di->dev, "%s mask and set failed\n", __func__);
3157 		goto out;
3158 	}
3159 
3160 out:
3161 	return ret;
3162 }
3163 
3164 /*
3165  * ab8500 charger driver interrupts and their respective isr
3166  */
3167 static struct ab8500_charger_interrupts ab8500_charger_irq[] = {
3168 	{"MAIN_CH_UNPLUG_DET", ab8500_charger_mainchunplugdet_handler},
3169 	{"MAIN_CHARGE_PLUG_DET", ab8500_charger_mainchplugdet_handler},
3170 	{"MAIN_EXT_CH_NOT_OK", ab8500_charger_mainextchnotok_handler},
3171 	{"MAIN_CH_TH_PROT_R", ab8500_charger_mainchthprotr_handler},
3172 	{"MAIN_CH_TH_PROT_F", ab8500_charger_mainchthprotf_handler},
3173 	{"VBUS_DET_F", ab8500_charger_vbusdetf_handler},
3174 	{"VBUS_DET_R", ab8500_charger_vbusdetr_handler},
3175 	{"USB_LINK_STATUS", ab8500_charger_usblinkstatus_handler},
3176 	{"USB_CH_TH_PROT_R", ab8500_charger_usbchthprotr_handler},
3177 	{"USB_CH_TH_PROT_F", ab8500_charger_usbchthprotf_handler},
3178 	{"USB_CHARGER_NOT_OKR", ab8500_charger_usbchargernotokr_handler},
3179 	{"VBUS_OVV", ab8500_charger_vbusovv_handler},
3180 	{"CH_WD_EXP", ab8500_charger_chwdexp_handler},
3181 	{"VBUS_CH_DROP_END", ab8500_charger_vbuschdropend_handler},
3182 };
3183 
3184 static int ab8500_charger_usb_notifier_call(struct notifier_block *nb,
3185 		unsigned long event, void *power)
3186 {
3187 	struct ab8500_charger *di =
3188 		container_of(nb, struct ab8500_charger, nb);
3189 	enum ab8500_usb_state bm_usb_state;
3190 	/*
3191 	 * FIXME: it appears the AB8500 PHY never sends what it should here.
3192 	 * Fix the PHY driver to properly notify the desired current.
3193 	 * Also broadcast microampere and not milliampere.
3194 	 */
3195 	unsigned mA = *((unsigned *)power);
3196 
3197 	if (event != USB_EVENT_VBUS) {
3198 		dev_dbg(di->dev, "not a standard host, returning\n");
3199 		return NOTIFY_DONE;
3200 	}
3201 
3202 	/* TODO: State is fabricate  here. See if charger really needs USB
3203 	 * state or if mA is enough
3204 	 */
3205 	if ((di->usb_state.usb_current_ua == 2000) && (mA > 2))
3206 		bm_usb_state = AB8500_BM_USB_STATE_RESUME;
3207 	else if (mA == 0)
3208 		bm_usb_state = AB8500_BM_USB_STATE_RESET_HS;
3209 	else if (mA == 2)
3210 		bm_usb_state = AB8500_BM_USB_STATE_SUSPEND;
3211 	else if (mA >= 8) /* 8, 100, 500 */
3212 		bm_usb_state = AB8500_BM_USB_STATE_CONFIGURED;
3213 	else /* Should never occur */
3214 		bm_usb_state = AB8500_BM_USB_STATE_RESET_FS;
3215 
3216 	dev_dbg(di->dev, "%s usb_state: 0x%02x mA: %d\n",
3217 		__func__, bm_usb_state, mA);
3218 
3219 	spin_lock(&di->usb_state.usb_lock);
3220 	di->usb_state.state_tmp = bm_usb_state;
3221 	/* FIXME: broadcast ua instead, see above */
3222 	di->usb_state.usb_current_tmp_ua = mA * 1000;
3223 	spin_unlock(&di->usb_state.usb_lock);
3224 
3225 	/*
3226 	 * wait for some time until you get updates from the usb stack
3227 	 * and negotiations are completed
3228 	 */
3229 	queue_delayed_work(di->charger_wq, &di->usb_state_changed_work, HZ/2);
3230 
3231 	return NOTIFY_OK;
3232 }
3233 
3234 static int __maybe_unused ab8500_charger_resume(struct device *dev)
3235 {
3236 	int ret;
3237 	struct ab8500_charger *di = dev_get_drvdata(dev);
3238 
3239 	/*
3240 	 * For ABB revision 1.0 and 1.1 there is a bug in the watchdog
3241 	 * logic. That means we have to continuously kick the charger
3242 	 * watchdog even when no charger is connected. This is only
3243 	 * valid once the AC charger has been enabled. This is
3244 	 * a bug that is not handled by the algorithm and the
3245 	 * watchdog have to be kicked by the charger driver
3246 	 * when the AC charger is disabled
3247 	 */
3248 	if (di->ac_conn && is_ab8500_1p1_or_earlier(di->parent)) {
3249 		ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER,
3250 			AB8500_CHARG_WD_CTRL, CHARG_WD_KICK);
3251 		if (ret)
3252 			dev_err(di->dev, "Failed to kick WD!\n");
3253 
3254 		/* If not already pending start a new timer */
3255 		queue_delayed_work(di->charger_wq, &di->kick_wd_work,
3256 				   round_jiffies(WD_KICK_INTERVAL));
3257 	}
3258 
3259 	/* If we still have a HW failure, schedule a new check */
3260 	if (di->flags.mainextchnotok || di->flags.vbus_ovv) {
3261 		queue_delayed_work(di->charger_wq,
3262 			&di->check_hw_failure_work, 0);
3263 	}
3264 
3265 	if (di->flags.vbus_drop_end)
3266 		queue_delayed_work(di->charger_wq, &di->vbus_drop_end_work, 0);
3267 
3268 	return 0;
3269 }
3270 
3271 static int __maybe_unused ab8500_charger_suspend(struct device *dev)
3272 {
3273 	struct ab8500_charger *di = dev_get_drvdata(dev);
3274 
3275 	/* Cancel any pending jobs */
3276 	cancel_delayed_work(&di->check_hw_failure_work);
3277 	cancel_delayed_work(&di->vbus_drop_end_work);
3278 
3279 	flush_delayed_work(&di->attach_work);
3280 	flush_delayed_work(&di->usb_charger_attached_work);
3281 	flush_delayed_work(&di->ac_charger_attached_work);
3282 	flush_delayed_work(&di->check_usbchgnotok_work);
3283 	flush_delayed_work(&di->check_vbat_work);
3284 	flush_delayed_work(&di->kick_wd_work);
3285 
3286 	flush_work(&di->usb_link_status_work);
3287 	flush_work(&di->ac_work);
3288 	flush_work(&di->detect_usb_type_work);
3289 
3290 	if (atomic_read(&di->current_stepping_sessions))
3291 		return -EAGAIN;
3292 
3293 	return 0;
3294 }
3295 
3296 static char *supply_interface[] = {
3297 	"ab8500_chargalg",
3298 	"ab8500_fg",
3299 	"ab8500_btemp",
3300 };
3301 
3302 static const struct power_supply_desc ab8500_ac_chg_desc = {
3303 	.name		= "ab8500_ac",
3304 	.type		= POWER_SUPPLY_TYPE_MAINS,
3305 	.properties	= ab8500_charger_ac_props,
3306 	.num_properties	= ARRAY_SIZE(ab8500_charger_ac_props),
3307 	.get_property	= ab8500_charger_ac_get_property,
3308 };
3309 
3310 static const struct power_supply_desc ab8500_usb_chg_desc = {
3311 	.name		= "ab8500_usb",
3312 	.type		= POWER_SUPPLY_TYPE_USB,
3313 	.properties	= ab8500_charger_usb_props,
3314 	.num_properties	= ARRAY_SIZE(ab8500_charger_usb_props),
3315 	.get_property	= ab8500_charger_usb_get_property,
3316 };
3317 
3318 static int ab8500_charger_bind(struct device *dev)
3319 {
3320 	struct ab8500_charger *di = dev_get_drvdata(dev);
3321 	int ch_stat;
3322 	int ret;
3323 
3324 	/* Create a work queue for the charger */
3325 	di->charger_wq = alloc_ordered_workqueue("ab8500_charger_wq",
3326 						 WQ_MEM_RECLAIM);
3327 	if (di->charger_wq == NULL) {
3328 		dev_err(dev, "failed to create work queue\n");
3329 		return -ENOMEM;
3330 	}
3331 
3332 	ch_stat = ab8500_charger_detect_chargers(di, false);
3333 
3334 	if (ch_stat & AC_PW_CONN) {
3335 		if (is_ab8500(di->parent))
3336 			queue_delayed_work(di->charger_wq,
3337 					   &di->ac_charger_attached_work,
3338 					   HZ);
3339 	}
3340 	if (ch_stat & USB_PW_CONN) {
3341 		if (is_ab8500(di->parent))
3342 			queue_delayed_work(di->charger_wq,
3343 					   &di->usb_charger_attached_work,
3344 					   HZ);
3345 		di->vbus_detected = true;
3346 		di->vbus_detected_start = true;
3347 		queue_work(di->charger_wq,
3348 			   &di->detect_usb_type_work);
3349 	}
3350 
3351 	ret = component_bind_all(dev, di);
3352 	if (ret) {
3353 		dev_err(dev, "can't bind component devices\n");
3354 		destroy_workqueue(di->charger_wq);
3355 		return ret;
3356 	}
3357 
3358 	return 0;
3359 }
3360 
3361 static void ab8500_charger_unbind(struct device *dev)
3362 {
3363 	struct ab8500_charger *di = dev_get_drvdata(dev);
3364 	int ret;
3365 
3366 	/* Disable AC charging */
3367 	ab8500_charger_ac_en(&di->ac_chg, false, 0, 0);
3368 
3369 	/* Disable USB charging */
3370 	ab8500_charger_usb_en(&di->usb_chg, false, 0, 0);
3371 
3372 	/* Backup battery voltage and current disable */
3373 	ret = abx500_mask_and_set_register_interruptible(di->dev,
3374 		AB8500_RTC, AB8500_RTC_CTRL_REG, RTC_BUP_CH_ENA, 0);
3375 	if (ret < 0)
3376 		dev_err(di->dev, "%s mask and set failed\n", __func__);
3377 
3378 	/* Delete the work queue */
3379 	destroy_workqueue(di->charger_wq);
3380 
3381 	/* Unbind fg, btemp, algorithm */
3382 	component_unbind_all(dev, di);
3383 }
3384 
3385 static const struct component_master_ops ab8500_charger_comp_ops = {
3386 	.bind = ab8500_charger_bind,
3387 	.unbind = ab8500_charger_unbind,
3388 };
3389 
3390 static struct platform_driver *const ab8500_charger_component_drivers[] = {
3391 	&ab8500_fg_driver,
3392 	&ab8500_btemp_driver,
3393 	&ab8500_chargalg_driver,
3394 };
3395 
3396 static int ab8500_charger_probe(struct platform_device *pdev)
3397 {
3398 	struct device *dev = &pdev->dev;
3399 	struct device_node *np = dev->of_node;
3400 	struct component_match *match = NULL;
3401 	struct power_supply_config ac_psy_cfg = {}, usb_psy_cfg = {};
3402 	struct ab8500_charger *di;
3403 	int charger_status;
3404 	int i, irq;
3405 	int ret;
3406 
3407 	di = devm_kzalloc(dev, sizeof(*di), GFP_KERNEL);
3408 	if (!di)
3409 		return -ENOMEM;
3410 
3411 	di->bm = &ab8500_bm_data;
3412 
3413 	di->autopower_cfg = of_property_read_bool(np, "autopower_cfg");
3414 
3415 	/* get parent data */
3416 	di->dev = dev;
3417 	di->parent = dev_get_drvdata(pdev->dev.parent);
3418 
3419 	/* Get ADC channels */
3420 	if (!is_ab8505(di->parent)) {
3421 		di->adc_main_charger_v = devm_iio_channel_get(dev, "main_charger_v");
3422 		if (IS_ERR(di->adc_main_charger_v)) {
3423 			ret = dev_err_probe(dev, PTR_ERR(di->adc_main_charger_v),
3424 					    "failed to get ADC main charger voltage\n");
3425 			return ret;
3426 		}
3427 		di->adc_main_charger_c = devm_iio_channel_get(dev, "main_charger_c");
3428 		if (IS_ERR(di->adc_main_charger_c)) {
3429 			ret = dev_err_probe(dev, PTR_ERR(di->adc_main_charger_c),
3430 					    "failed to get ADC main charger current\n");
3431 			return ret;
3432 		}
3433 	}
3434 	di->adc_vbus_v = devm_iio_channel_get(dev, "vbus_v");
3435 	if (IS_ERR(di->adc_vbus_v)) {
3436 		ret = dev_err_probe(dev, PTR_ERR(di->adc_vbus_v),
3437 				    "failed to get ADC USB charger voltage\n");
3438 		return ret;
3439 	}
3440 	di->adc_usb_charger_c = devm_iio_channel_get(dev, "usb_charger_c");
3441 	if (IS_ERR(di->adc_usb_charger_c)) {
3442 		ret = dev_err_probe(dev, PTR_ERR(di->adc_usb_charger_c),
3443 				    "failed to get ADC USB charger current\n");
3444 		return ret;
3445 	}
3446 
3447 	/*
3448 	 * VDD ADC supply needs to be enabled from this driver when there
3449 	 * is a charger connected to avoid erroneous BTEMP_HIGH/LOW
3450 	 * interrupts during charging
3451 	 */
3452 	di->regu = devm_regulator_get(dev, "vddadc");
3453 	if (IS_ERR(di->regu)) {
3454 		ret = PTR_ERR(di->regu);
3455 		dev_err(dev, "failed to get vddadc regulator\n");
3456 		return ret;
3457 	}
3458 
3459 	/* Request interrupts */
3460 	for (i = 0; i < ARRAY_SIZE(ab8500_charger_irq); i++) {
3461 		irq = platform_get_irq_byname(pdev, ab8500_charger_irq[i].name);
3462 		if (irq < 0)
3463 			return irq;
3464 
3465 		ret = devm_request_threaded_irq(dev,
3466 			irq, NULL, ab8500_charger_irq[i].isr,
3467 			IRQF_SHARED | IRQF_NO_SUSPEND | IRQF_ONESHOT,
3468 			ab8500_charger_irq[i].name, di);
3469 
3470 		if (ret != 0) {
3471 			dev_err(dev, "failed to request %s IRQ %d: %d\n"
3472 				, ab8500_charger_irq[i].name, irq, ret);
3473 			return ret;
3474 		}
3475 		dev_dbg(dev, "Requested %s IRQ %d: %d\n",
3476 			ab8500_charger_irq[i].name, irq, ret);
3477 	}
3478 
3479 	/* initialize lock */
3480 	spin_lock_init(&di->usb_state.usb_lock);
3481 	mutex_init(&di->usb_ipt_crnt_lock);
3482 
3483 	di->autopower = false;
3484 	di->invalid_charger_detect_state = 0;
3485 
3486 	/* AC and USB supply config */
3487 	ac_psy_cfg.of_node = np;
3488 	ac_psy_cfg.supplied_to = supply_interface;
3489 	ac_psy_cfg.num_supplicants = ARRAY_SIZE(supply_interface);
3490 	ac_psy_cfg.drv_data = &di->ac_chg;
3491 	usb_psy_cfg.of_node = np;
3492 	usb_psy_cfg.supplied_to = supply_interface;
3493 	usb_psy_cfg.num_supplicants = ARRAY_SIZE(supply_interface);
3494 	usb_psy_cfg.drv_data = &di->usb_chg;
3495 
3496 	/* AC supply */
3497 	/* ux500_charger sub-class */
3498 	di->ac_chg.ops.enable = &ab8500_charger_ac_en;
3499 	di->ac_chg.ops.check_enable = &ab8500_charger_ac_check_enable;
3500 	di->ac_chg.ops.kick_wd = &ab8500_charger_watchdog_kick;
3501 	di->ac_chg.ops.update_curr = &ab8500_charger_update_charger_current;
3502 	di->ac_chg.max_out_volt_uv = ab8500_charger_voltage_map[
3503 		ARRAY_SIZE(ab8500_charger_voltage_map) - 1];
3504 	di->ac_chg.max_out_curr_ua =
3505 		ab8500_charge_output_curr_map[ARRAY_SIZE(ab8500_charge_output_curr_map) - 1];
3506 	di->ac_chg.wdt_refresh = CHG_WD_INTERVAL;
3507 	/*
3508 	 * The AB8505 only supports USB charging. If we are not the
3509 	 * AB8505, register an AC charger.
3510 	 *
3511 	 * TODO: if this should be opt-in, add DT properties for this.
3512 	 */
3513 	if (!is_ab8505(di->parent))
3514 		di->ac_chg.enabled = true;
3515 
3516 	/* USB supply */
3517 	/* ux500_charger sub-class */
3518 	di->usb_chg.ops.enable = &ab8500_charger_usb_en;
3519 	di->usb_chg.ops.check_enable = &ab8500_charger_usb_check_enable;
3520 	di->usb_chg.ops.kick_wd = &ab8500_charger_watchdog_kick;
3521 	di->usb_chg.ops.update_curr = &ab8500_charger_update_charger_current;
3522 	di->usb_chg.max_out_volt_uv = ab8500_charger_voltage_map[
3523 		ARRAY_SIZE(ab8500_charger_voltage_map) - 1];
3524 	di->usb_chg.max_out_curr_ua =
3525 		ab8500_charge_output_curr_map[ARRAY_SIZE(ab8500_charge_output_curr_map) - 1];
3526 	di->usb_chg.wdt_refresh = CHG_WD_INTERVAL;
3527 	di->usb_state.usb_current_ua = -1;
3528 
3529 	mutex_init(&di->charger_attached_mutex);
3530 
3531 	/* Init work for HW failure check */
3532 	INIT_DEFERRABLE_WORK(&di->check_hw_failure_work,
3533 		ab8500_charger_check_hw_failure_work);
3534 	INIT_DEFERRABLE_WORK(&di->check_usbchgnotok_work,
3535 		ab8500_charger_check_usbchargernotok_work);
3536 
3537 	INIT_DELAYED_WORK(&di->ac_charger_attached_work,
3538 			  ab8500_charger_ac_attached_work);
3539 	INIT_DELAYED_WORK(&di->usb_charger_attached_work,
3540 			  ab8500_charger_usb_attached_work);
3541 
3542 	/*
3543 	 * For ABB revision 1.0 and 1.1 there is a bug in the watchdog
3544 	 * logic. That means we have to continuously kick the charger
3545 	 * watchdog even when no charger is connected. This is only
3546 	 * valid once the AC charger has been enabled. This is
3547 	 * a bug that is not handled by the algorithm and the
3548 	 * watchdog have to be kicked by the charger driver
3549 	 * when the AC charger is disabled
3550 	 */
3551 	INIT_DEFERRABLE_WORK(&di->kick_wd_work,
3552 		ab8500_charger_kick_watchdog_work);
3553 
3554 	INIT_DEFERRABLE_WORK(&di->check_vbat_work,
3555 		ab8500_charger_check_vbat_work);
3556 
3557 	INIT_DELAYED_WORK(&di->attach_work,
3558 		ab8500_charger_usb_link_attach_work);
3559 
3560 	INIT_DELAYED_WORK(&di->usb_state_changed_work,
3561 		ab8500_charger_usb_state_changed_work);
3562 
3563 	INIT_DELAYED_WORK(&di->vbus_drop_end_work,
3564 		ab8500_charger_vbus_drop_end_work);
3565 
3566 	/* Init work for charger detection */
3567 	INIT_WORK(&di->usb_link_status_work,
3568 		ab8500_charger_usb_link_status_work);
3569 	INIT_WORK(&di->ac_work, ab8500_charger_ac_work);
3570 	INIT_WORK(&di->detect_usb_type_work,
3571 		ab8500_charger_detect_usb_type_work);
3572 
3573 	/* Init work for checking HW status */
3574 	INIT_WORK(&di->check_main_thermal_prot_work,
3575 		ab8500_charger_check_main_thermal_prot_work);
3576 	INIT_WORK(&di->check_usb_thermal_prot_work,
3577 		ab8500_charger_check_usb_thermal_prot_work);
3578 
3579 
3580 	/* Initialize OVV, and other registers */
3581 	ret = ab8500_charger_init_hw_registers(di);
3582 	if (ret) {
3583 		dev_err(dev, "failed to initialize ABB registers\n");
3584 		return ret;
3585 	}
3586 
3587 	/* Register AC charger class */
3588 	if (di->ac_chg.enabled) {
3589 		di->ac_chg.psy = devm_power_supply_register(dev,
3590 						       &ab8500_ac_chg_desc,
3591 						       &ac_psy_cfg);
3592 		if (IS_ERR(di->ac_chg.psy)) {
3593 			dev_err(dev, "failed to register AC charger\n");
3594 			return PTR_ERR(di->ac_chg.psy);
3595 		}
3596 	}
3597 
3598 	/* Register USB charger class */
3599 	di->usb_chg.psy = devm_power_supply_register(dev,
3600 						     &ab8500_usb_chg_desc,
3601 						     &usb_psy_cfg);
3602 	if (IS_ERR(di->usb_chg.psy)) {
3603 		dev_err(dev, "failed to register USB charger\n");
3604 		return PTR_ERR(di->usb_chg.psy);
3605 	}
3606 
3607 	/*
3608 	 * Check what battery we have, since we always have the USB
3609 	 * psy, use that as a handle.
3610 	 */
3611 	ret = ab8500_bm_of_probe(di->usb_chg.psy, di->bm);
3612 	if (ret)
3613 		return dev_err_probe(dev, ret,
3614 				     "failed to get battery information\n");
3615 
3616 	/* Identify the connected charger types during startup */
3617 	charger_status = ab8500_charger_detect_chargers(di, true);
3618 	if (charger_status & AC_PW_CONN) {
3619 		di->ac.charger_connected = 1;
3620 		di->ac_conn = true;
3621 		ab8500_power_supply_changed(di, di->ac_chg.psy);
3622 		sysfs_notify(&di->ac_chg.psy->dev.kobj, NULL, "present");
3623 	}
3624 
3625 	platform_set_drvdata(pdev, di);
3626 
3627 	/* Create something that will match the subdrivers when we bind */
3628 	for (i = 0; i < ARRAY_SIZE(ab8500_charger_component_drivers); i++) {
3629 		struct device_driver *drv = &ab8500_charger_component_drivers[i]->driver;
3630 		struct device *p = NULL, *d;
3631 
3632 		while ((d = platform_find_device_by_driver(p, drv))) {
3633 			put_device(p);
3634 			component_match_add(dev, &match, component_compare_dev, d);
3635 			p = d;
3636 		}
3637 		put_device(p);
3638 	}
3639 	if (!match) {
3640 		dev_err(dev, "no matching components\n");
3641 		ret = -ENODEV;
3642 		goto remove_ab8500_bm;
3643 	}
3644 	if (IS_ERR(match)) {
3645 		dev_err(dev, "could not create component match\n");
3646 		ret = PTR_ERR(match);
3647 		goto remove_ab8500_bm;
3648 	}
3649 
3650 	di->usb_phy = usb_get_phy(USB_PHY_TYPE_USB2);
3651 	if (IS_ERR_OR_NULL(di->usb_phy)) {
3652 		dev_err(dev, "failed to get usb transceiver\n");
3653 		ret = -EINVAL;
3654 		goto remove_ab8500_bm;
3655 	}
3656 	di->nb.notifier_call = ab8500_charger_usb_notifier_call;
3657 	ret = usb_register_notifier(di->usb_phy, &di->nb);
3658 	if (ret) {
3659 		dev_err(dev, "failed to register usb notifier\n");
3660 		goto put_usb_phy;
3661 	}
3662 
3663 	ret = component_master_add_with_match(&pdev->dev,
3664 					      &ab8500_charger_comp_ops,
3665 					      match);
3666 	if (ret) {
3667 		dev_err(dev, "failed to add component master\n");
3668 		goto free_notifier;
3669 	}
3670 
3671 	return 0;
3672 
3673 free_notifier:
3674 	usb_unregister_notifier(di->usb_phy, &di->nb);
3675 put_usb_phy:
3676 	usb_put_phy(di->usb_phy);
3677 remove_ab8500_bm:
3678 	ab8500_bm_of_remove(di->usb_chg.psy, di->bm);
3679 	return ret;
3680 }
3681 
3682 static int ab8500_charger_remove(struct platform_device *pdev)
3683 {
3684 	struct ab8500_charger *di = platform_get_drvdata(pdev);
3685 
3686 	component_master_del(&pdev->dev, &ab8500_charger_comp_ops);
3687 
3688 	usb_unregister_notifier(di->usb_phy, &di->nb);
3689 	ab8500_bm_of_remove(di->usb_chg.psy, di->bm);
3690 	usb_put_phy(di->usb_phy);
3691 
3692 	return 0;
3693 }
3694 
3695 static SIMPLE_DEV_PM_OPS(ab8500_charger_pm_ops, ab8500_charger_suspend, ab8500_charger_resume);
3696 
3697 static const struct of_device_id ab8500_charger_match[] = {
3698 	{ .compatible = "stericsson,ab8500-charger", },
3699 	{ },
3700 };
3701 MODULE_DEVICE_TABLE(of, ab8500_charger_match);
3702 
3703 static struct platform_driver ab8500_charger_driver = {
3704 	.probe = ab8500_charger_probe,
3705 	.remove = ab8500_charger_remove,
3706 	.driver = {
3707 		.name = "ab8500-charger",
3708 		.of_match_table = ab8500_charger_match,
3709 		.pm = &ab8500_charger_pm_ops,
3710 	},
3711 };
3712 
3713 static int __init ab8500_charger_init(void)
3714 {
3715 	int ret;
3716 
3717 	ret = platform_register_drivers(ab8500_charger_component_drivers,
3718 			ARRAY_SIZE(ab8500_charger_component_drivers));
3719 	if (ret)
3720 		return ret;
3721 
3722 	ret = platform_driver_register(&ab8500_charger_driver);
3723 	if (ret) {
3724 		platform_unregister_drivers(ab8500_charger_component_drivers,
3725 				ARRAY_SIZE(ab8500_charger_component_drivers));
3726 		return ret;
3727 	}
3728 
3729 	return 0;
3730 }
3731 
3732 static void __exit ab8500_charger_exit(void)
3733 {
3734 	platform_unregister_drivers(ab8500_charger_component_drivers,
3735 			ARRAY_SIZE(ab8500_charger_component_drivers));
3736 	platform_driver_unregister(&ab8500_charger_driver);
3737 }
3738 
3739 module_init(ab8500_charger_init);
3740 module_exit(ab8500_charger_exit);
3741 
3742 MODULE_LICENSE("GPL v2");
3743 MODULE_AUTHOR("Johan Palsson, Karl Komierowski, Arun R Murthy");
3744 MODULE_ALIAS("platform:ab8500-charger");
3745 MODULE_DESCRIPTION("AB8500 charger management driver");
3746