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		3800
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 interupts
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 structre
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 static int ab8500_external_charger_prepare(struct notifier_block *charger_nb,
1720 				unsigned long event, void *data)
1721 {
1722 	int ret;
1723 	struct device *dev = data;
1724 	/*Toggle External charger control pin*/
1725 	ret = abx500_set_register_interruptible(dev, AB8500_SYS_CTRL1_BLOCK,
1726 				  AB8500_SYS_CHARGER_CONTROL_REG,
1727 				  EXTERNAL_CHARGER_DISABLE_REG_VAL);
1728 	if (ret < 0) {
1729 		dev_err(dev, "write reg failed %d\n", ret);
1730 		goto out;
1731 	}
1732 	ret = abx500_set_register_interruptible(dev, AB8500_SYS_CTRL1_BLOCK,
1733 				  AB8500_SYS_CHARGER_CONTROL_REG,
1734 				  EXTERNAL_CHARGER_ENABLE_REG_VAL);
1735 	if (ret < 0)
1736 		dev_err(dev, "Write reg failed %d\n", ret);
1737 
1738 out:
1739 	return ret;
1740 }
1741 
1742 /**
1743  * ab8500_charger_usb_check_enable() - enable usb charging
1744  * @charger:	pointer to the ux500_charger structure
1745  * @vset_uv:	charging voltage in microvolt
1746  * @iset_ua:	charger output current in microampere
1747  *
1748  * Check if the VBUS charger has been disconnected and reconnected without
1749  * AB8500 rising an interrupt. Returns 0 on success.
1750  */
1751 static int ab8500_charger_usb_check_enable(struct ux500_charger *charger,
1752 	int vset_uv, int iset_ua)
1753 {
1754 	u8 usbch_ctrl1 = 0;
1755 	int ret = 0;
1756 
1757 	struct ab8500_charger *di = to_ab8500_charger_usb_device_info(charger);
1758 
1759 	if (!di->usb.charger_connected)
1760 		return ret;
1761 
1762 	ret = abx500_get_register_interruptible(di->dev, AB8500_CHARGER,
1763 				AB8500_USBCH_CTRL1_REG, &usbch_ctrl1);
1764 	if (ret < 0) {
1765 		dev_err(di->dev, "ab8500 read failed %d\n", __LINE__);
1766 		return ret;
1767 	}
1768 	dev_dbg(di->dev, "USB charger ctrl: 0x%02x\n", usbch_ctrl1);
1769 
1770 	if (!(usbch_ctrl1 & USB_CH_ENA)) {
1771 		dev_info(di->dev, "Charging has been disabled abnormally and will be re-enabled\n");
1772 
1773 		ret = abx500_mask_and_set_register_interruptible(di->dev,
1774 					AB8500_CHARGER, AB8500_CHARGER_CTRL,
1775 					DROP_COUNT_RESET, DROP_COUNT_RESET);
1776 		if (ret < 0) {
1777 			dev_err(di->dev, "ab8500 write failed %d\n", __LINE__);
1778 			return ret;
1779 		}
1780 
1781 		ret = ab8500_charger_usb_en(&di->usb_chg, true, vset_uv, iset_ua);
1782 		if (ret < 0) {
1783 			dev_err(di->dev, "Failed to enable VBUS charger %d\n",
1784 					__LINE__);
1785 			return ret;
1786 		}
1787 	}
1788 	return ret;
1789 }
1790 
1791 /**
1792  * ab8500_charger_ac_check_enable() - enable usb charging
1793  * @charger:	pointer to the ux500_charger structure
1794  * @vset_uv:	charging voltage in microvolt
1795  * @iset_ua:	charger output current in micrompere
1796  *
1797  * Check if the AC charger has been disconnected and reconnected without
1798  * AB8500 rising an interrupt. Returns 0 on success.
1799  */
1800 static int ab8500_charger_ac_check_enable(struct ux500_charger *charger,
1801 	int vset_uv, int iset_ua)
1802 {
1803 	u8 mainch_ctrl1 = 0;
1804 	int ret = 0;
1805 
1806 	struct ab8500_charger *di = to_ab8500_charger_ac_device_info(charger);
1807 
1808 	if (!di->ac.charger_connected)
1809 		return ret;
1810 
1811 	ret = abx500_get_register_interruptible(di->dev, AB8500_CHARGER,
1812 				AB8500_MCH_CTRL1, &mainch_ctrl1);
1813 	if (ret < 0) {
1814 		dev_err(di->dev, "ab8500 read failed %d\n", __LINE__);
1815 		return ret;
1816 	}
1817 	dev_dbg(di->dev, "AC charger ctrl: 0x%02x\n", mainch_ctrl1);
1818 
1819 	if (!(mainch_ctrl1 & MAIN_CH_ENA)) {
1820 		dev_info(di->dev, "Charging has been disabled abnormally and will be re-enabled\n");
1821 
1822 		ret = abx500_mask_and_set_register_interruptible(di->dev,
1823 					AB8500_CHARGER, AB8500_CHARGER_CTRL,
1824 					DROP_COUNT_RESET, DROP_COUNT_RESET);
1825 
1826 		if (ret < 0) {
1827 			dev_err(di->dev, "ab8500 write failed %d\n", __LINE__);
1828 			return ret;
1829 		}
1830 
1831 		ret = ab8500_charger_ac_en(&di->usb_chg, true, vset_uv, iset_ua);
1832 		if (ret < 0) {
1833 			dev_err(di->dev, "failed to enable AC charger %d\n",
1834 				__LINE__);
1835 			return ret;
1836 		}
1837 	}
1838 	return ret;
1839 }
1840 
1841 /**
1842  * ab8500_charger_watchdog_kick() - kick charger watchdog
1843  * @di:		pointer to the ab8500_charger structure
1844  *
1845  * Kick charger watchdog
1846  * Returns error code in case of failure else 0(on success)
1847  */
1848 static int ab8500_charger_watchdog_kick(struct ux500_charger *charger)
1849 {
1850 	int ret;
1851 	struct ab8500_charger *di;
1852 
1853 	if (charger->psy->desc->type == POWER_SUPPLY_TYPE_MAINS)
1854 		di = to_ab8500_charger_ac_device_info(charger);
1855 	else if (charger->psy->desc->type == POWER_SUPPLY_TYPE_USB)
1856 		di = to_ab8500_charger_usb_device_info(charger);
1857 	else
1858 		return -ENXIO;
1859 
1860 	ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER,
1861 		AB8500_CHARG_WD_CTRL, CHARG_WD_KICK);
1862 	if (ret)
1863 		dev_err(di->dev, "Failed to kick WD!\n");
1864 
1865 	return ret;
1866 }
1867 
1868 /**
1869  * ab8500_charger_update_charger_current() - update charger current
1870  * @charger:		pointer to the ab8500_charger structure
1871  * @ich_out_ua:		desired output current in microampere
1872  *
1873  * Update the charger output current for the specified charger
1874  * Returns error code in case of failure else 0(on success)
1875  */
1876 static int ab8500_charger_update_charger_current(struct ux500_charger *charger,
1877 		int ich_out_ua)
1878 {
1879 	int ret;
1880 	struct ab8500_charger *di;
1881 
1882 	if (charger->psy->desc->type == POWER_SUPPLY_TYPE_MAINS)
1883 		di = to_ab8500_charger_ac_device_info(charger);
1884 	else if (charger->psy->desc->type == POWER_SUPPLY_TYPE_USB)
1885 		di = to_ab8500_charger_usb_device_info(charger);
1886 	else
1887 		return -ENXIO;
1888 
1889 	ret = ab8500_charger_set_output_curr(di, ich_out_ua);
1890 	if (ret) {
1891 		dev_err(di->dev, "%s "
1892 			"Failed to set ChOutputCurentLevel\n",
1893 			__func__);
1894 		return ret;
1895 	}
1896 
1897 	/* Reset the main and usb drop input current measurement counter */
1898 	ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER,
1899 				AB8500_CHARGER_CTRL, DROP_COUNT_RESET);
1900 	if (ret) {
1901 		dev_err(di->dev, "%s write failed\n", __func__);
1902 		return ret;
1903 	}
1904 
1905 	return ret;
1906 }
1907 
1908 static int ab8500_charger_get_ext_psy_data(struct device *dev, void *data)
1909 {
1910 	struct power_supply *psy;
1911 	struct power_supply *ext = dev_get_drvdata(dev);
1912 	const char **supplicants = (const char **)ext->supplied_to;
1913 	struct ab8500_charger *di;
1914 	union power_supply_propval ret;
1915 	int j;
1916 	struct ux500_charger *usb_chg;
1917 
1918 	usb_chg = (struct ux500_charger *)data;
1919 	psy = usb_chg->psy;
1920 
1921 	di = to_ab8500_charger_usb_device_info(usb_chg);
1922 
1923 	/* For all psy where the driver name appears in any supplied_to */
1924 	j = match_string(supplicants, ext->num_supplicants, psy->desc->name);
1925 	if (j < 0)
1926 		return 0;
1927 
1928 	/* Go through all properties for the psy */
1929 	for (j = 0; j < ext->desc->num_properties; j++) {
1930 		enum power_supply_property prop;
1931 		prop = ext->desc->properties[j];
1932 
1933 		if (power_supply_get_property(ext, prop, &ret))
1934 			continue;
1935 
1936 		switch (prop) {
1937 		case POWER_SUPPLY_PROP_VOLTAGE_NOW:
1938 			switch (ext->desc->type) {
1939 			case POWER_SUPPLY_TYPE_BATTERY:
1940 				di->vbat = ret.intval / 1000;
1941 				break;
1942 			default:
1943 				break;
1944 			}
1945 			break;
1946 		default:
1947 			break;
1948 		}
1949 	}
1950 	return 0;
1951 }
1952 
1953 /**
1954  * ab8500_charger_check_vbat_work() - keep vbus current within spec
1955  * @work	pointer to the work_struct structure
1956  *
1957  * Due to a asic bug it is necessary to lower the input current to the vbus
1958  * charger when charging with at some specific levels. This issue is only valid
1959  * for below a certain battery voltage. This function makes sure that the
1960  * the allowed current limit isn't exceeded.
1961  */
1962 static void ab8500_charger_check_vbat_work(struct work_struct *work)
1963 {
1964 	int t = 10;
1965 	struct ab8500_charger *di = container_of(work,
1966 		struct ab8500_charger, check_vbat_work.work);
1967 
1968 	class_for_each_device(power_supply_class, NULL,
1969 		di->usb_chg.psy, ab8500_charger_get_ext_psy_data);
1970 
1971 	/* First run old_vbat is 0. */
1972 	if (di->old_vbat == 0)
1973 		di->old_vbat = di->vbat;
1974 
1975 	if (!((di->old_vbat <= VBAT_TRESH_IP_CUR_RED &&
1976 		di->vbat <= VBAT_TRESH_IP_CUR_RED) ||
1977 		(di->old_vbat > VBAT_TRESH_IP_CUR_RED &&
1978 		di->vbat > VBAT_TRESH_IP_CUR_RED))) {
1979 
1980 		dev_dbg(di->dev, "Vbat did cross threshold, curr: %d, new: %d,"
1981 			" old: %d\n", di->max_usb_in_curr.usb_type_max_ua,
1982 			di->vbat, di->old_vbat);
1983 		ab8500_charger_set_vbus_in_curr(di,
1984 					di->max_usb_in_curr.usb_type_max_ua);
1985 		power_supply_changed(di->usb_chg.psy);
1986 	}
1987 
1988 	di->old_vbat = di->vbat;
1989 
1990 	/*
1991 	 * No need to check the battery voltage every second when not close to
1992 	 * the threshold.
1993 	 */
1994 	if (di->vbat < (VBAT_TRESH_IP_CUR_RED + 100) &&
1995 		(di->vbat > (VBAT_TRESH_IP_CUR_RED - 100)))
1996 			t = 1;
1997 
1998 	queue_delayed_work(di->charger_wq, &di->check_vbat_work, t * HZ);
1999 }
2000 
2001 /**
2002  * ab8500_charger_check_hw_failure_work() - check main charger failure
2003  * @work:	pointer to the work_struct structure
2004  *
2005  * Work queue function for checking the main charger status
2006  */
2007 static void ab8500_charger_check_hw_failure_work(struct work_struct *work)
2008 {
2009 	int ret;
2010 	u8 reg_value;
2011 
2012 	struct ab8500_charger *di = container_of(work,
2013 		struct ab8500_charger, check_hw_failure_work.work);
2014 
2015 	/* Check if the status bits for HW failure is still active */
2016 	if (di->flags.mainextchnotok) {
2017 		ret = abx500_get_register_interruptible(di->dev,
2018 			AB8500_CHARGER, AB8500_CH_STATUS2_REG, &reg_value);
2019 		if (ret < 0) {
2020 			dev_err(di->dev, "%s ab8500 read failed\n", __func__);
2021 			return;
2022 		}
2023 		if (!(reg_value & MAIN_CH_NOK)) {
2024 			di->flags.mainextchnotok = false;
2025 			ab8500_power_supply_changed(di, di->ac_chg.psy);
2026 		}
2027 	}
2028 	if (di->flags.vbus_ovv) {
2029 		ret = abx500_get_register_interruptible(di->dev,
2030 			AB8500_CHARGER, AB8500_CH_USBCH_STAT2_REG,
2031 			&reg_value);
2032 		if (ret < 0) {
2033 			dev_err(di->dev, "%s ab8500 read failed\n", __func__);
2034 			return;
2035 		}
2036 		if (!(reg_value & VBUS_OVV_TH)) {
2037 			di->flags.vbus_ovv = false;
2038 			ab8500_power_supply_changed(di, di->usb_chg.psy);
2039 		}
2040 	}
2041 	/* If we still have a failure, schedule a new check */
2042 	if (di->flags.mainextchnotok || di->flags.vbus_ovv) {
2043 		queue_delayed_work(di->charger_wq,
2044 			&di->check_hw_failure_work, round_jiffies(HZ));
2045 	}
2046 }
2047 
2048 /**
2049  * ab8500_charger_kick_watchdog_work() - kick the watchdog
2050  * @work:	pointer to the work_struct structure
2051  *
2052  * Work queue function for kicking the charger watchdog.
2053  *
2054  * For ABB revision 1.0 and 1.1 there is a bug in the watchdog
2055  * logic. That means we have to continuously kick the charger
2056  * watchdog even when no charger is connected. This is only
2057  * valid once the AC charger has been enabled. This is
2058  * a bug that is not handled by the algorithm and the
2059  * watchdog have to be kicked by the charger driver
2060  * when the AC charger is disabled
2061  */
2062 static void ab8500_charger_kick_watchdog_work(struct work_struct *work)
2063 {
2064 	int ret;
2065 
2066 	struct ab8500_charger *di = container_of(work,
2067 		struct ab8500_charger, kick_wd_work.work);
2068 
2069 	ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER,
2070 		AB8500_CHARG_WD_CTRL, CHARG_WD_KICK);
2071 	if (ret)
2072 		dev_err(di->dev, "Failed to kick WD!\n");
2073 
2074 	/* Schedule a new watchdog kick */
2075 	queue_delayed_work(di->charger_wq,
2076 		&di->kick_wd_work, round_jiffies(WD_KICK_INTERVAL));
2077 }
2078 
2079 /**
2080  * ab8500_charger_ac_work() - work to get and set main charger status
2081  * @work:	pointer to the work_struct structure
2082  *
2083  * Work queue function for checking the main charger status
2084  */
2085 static void ab8500_charger_ac_work(struct work_struct *work)
2086 {
2087 	int ret;
2088 
2089 	struct ab8500_charger *di = container_of(work,
2090 		struct ab8500_charger, ac_work);
2091 
2092 	/*
2093 	 * Since we can't be sure that the events are received
2094 	 * synchronously, we have the check if the main charger is
2095 	 * connected by reading the status register
2096 	 */
2097 	ret = ab8500_charger_detect_chargers(di, false);
2098 	if (ret < 0)
2099 		return;
2100 
2101 	if (ret & AC_PW_CONN) {
2102 		di->ac.charger_connected = 1;
2103 		di->ac_conn = true;
2104 	} else {
2105 		di->ac.charger_connected = 0;
2106 	}
2107 
2108 	ab8500_power_supply_changed(di, di->ac_chg.psy);
2109 	sysfs_notify(&di->ac_chg.psy->dev.kobj, NULL, "present");
2110 }
2111 
2112 static void ab8500_charger_usb_attached_work(struct work_struct *work)
2113 {
2114 	struct ab8500_charger *di = container_of(work,
2115 						 struct ab8500_charger,
2116 						 usb_charger_attached_work.work);
2117 	int usbch = (USB_CH_VBUSDROP | USB_CH_VBUSDETDBNC);
2118 	int ret, i;
2119 	u8 statval;
2120 
2121 	for (i = 0; i < 10; i++) {
2122 		ret = abx500_get_register_interruptible(di->dev,
2123 							AB8500_CHARGER,
2124 							AB8500_CH_USBCH_STAT1_REG,
2125 							&statval);
2126 		if (ret < 0) {
2127 			dev_err(di->dev, "ab8500 read failed %d\n", __LINE__);
2128 			goto reschedule;
2129 		}
2130 		if ((statval & usbch) != usbch)
2131 			goto reschedule;
2132 
2133 		msleep(CHARGER_STATUS_POLL);
2134 	}
2135 
2136 	ab8500_charger_usb_en(&di->usb_chg, 0, 0, 0);
2137 
2138 	mutex_lock(&di->charger_attached_mutex);
2139 	mutex_unlock(&di->charger_attached_mutex);
2140 
2141 	return;
2142 
2143 reschedule:
2144 	queue_delayed_work(di->charger_wq,
2145 			   &di->usb_charger_attached_work,
2146 			   HZ);
2147 }
2148 
2149 static void ab8500_charger_ac_attached_work(struct work_struct *work)
2150 {
2151 
2152 	struct ab8500_charger *di = container_of(work,
2153 						 struct ab8500_charger,
2154 						 ac_charger_attached_work.work);
2155 	int mainch = (MAIN_CH_STATUS2_MAINCHGDROP |
2156 		      MAIN_CH_STATUS2_MAINCHARGERDETDBNC);
2157 	int ret, i;
2158 	u8 statval;
2159 
2160 	for (i = 0; i < 10; i++) {
2161 		ret = abx500_get_register_interruptible(di->dev,
2162 							AB8500_CHARGER,
2163 							AB8500_CH_STATUS2_REG,
2164 							&statval);
2165 		if (ret < 0) {
2166 			dev_err(di->dev, "ab8500 read failed %d\n", __LINE__);
2167 			goto reschedule;
2168 		}
2169 
2170 		if ((statval & mainch) != mainch)
2171 			goto reschedule;
2172 
2173 		msleep(CHARGER_STATUS_POLL);
2174 	}
2175 
2176 	ab8500_charger_ac_en(&di->ac_chg, 0, 0, 0);
2177 	queue_work(di->charger_wq, &di->ac_work);
2178 
2179 	mutex_lock(&di->charger_attached_mutex);
2180 	mutex_unlock(&di->charger_attached_mutex);
2181 
2182 	return;
2183 
2184 reschedule:
2185 	queue_delayed_work(di->charger_wq,
2186 			   &di->ac_charger_attached_work,
2187 			   HZ);
2188 }
2189 
2190 /**
2191  * ab8500_charger_detect_usb_type_work() - work to detect USB type
2192  * @work:	Pointer to the work_struct structure
2193  *
2194  * Detect the type of USB plugged
2195  */
2196 static void ab8500_charger_detect_usb_type_work(struct work_struct *work)
2197 {
2198 	int ret;
2199 
2200 	struct ab8500_charger *di = container_of(work,
2201 		struct ab8500_charger, detect_usb_type_work);
2202 
2203 	/*
2204 	 * Since we can't be sure that the events are received
2205 	 * synchronously, we have the check if is
2206 	 * connected by reading the status register
2207 	 */
2208 	ret = ab8500_charger_detect_chargers(di, false);
2209 	if (ret < 0)
2210 		return;
2211 
2212 	if (!(ret & USB_PW_CONN)) {
2213 		dev_dbg(di->dev, "%s di->vbus_detected = false\n", __func__);
2214 		di->vbus_detected = false;
2215 		ab8500_charger_set_usb_connected(di, false);
2216 		ab8500_power_supply_changed(di, di->usb_chg.psy);
2217 	} else {
2218 		dev_dbg(di->dev, "%s di->vbus_detected = true\n", __func__);
2219 		di->vbus_detected = true;
2220 
2221 		if (is_ab8500_1p1_or_earlier(di->parent)) {
2222 			ret = ab8500_charger_detect_usb_type(di);
2223 			if (!ret) {
2224 				ab8500_charger_set_usb_connected(di, true);
2225 				ab8500_power_supply_changed(di,
2226 							    di->usb_chg.psy);
2227 			}
2228 		} else {
2229 			/*
2230 			 * For ABB cut2.0 and onwards we have an IRQ,
2231 			 * USB_LINK_STATUS that will be triggered when the USB
2232 			 * link status changes. The exception is USB connected
2233 			 * during startup. Then we don't get a
2234 			 * USB_LINK_STATUS IRQ
2235 			 */
2236 			if (di->vbus_detected_start) {
2237 				di->vbus_detected_start = false;
2238 				ret = ab8500_charger_detect_usb_type(di);
2239 				if (!ret) {
2240 					ab8500_charger_set_usb_connected(di,
2241 						true);
2242 					ab8500_power_supply_changed(di,
2243 						di->usb_chg.psy);
2244 				}
2245 			}
2246 		}
2247 	}
2248 }
2249 
2250 /**
2251  * ab8500_charger_usb_link_attach_work() - work to detect USB type
2252  * @work:	pointer to the work_struct structure
2253  *
2254  * Detect the type of USB plugged
2255  */
2256 static void ab8500_charger_usb_link_attach_work(struct work_struct *work)
2257 {
2258 	struct ab8500_charger *di =
2259 		container_of(work, struct ab8500_charger, attach_work.work);
2260 	int ret;
2261 
2262 	/* Update maximum input current if USB enumeration is not detected */
2263 	if (!di->usb.charger_online) {
2264 		ret = ab8500_charger_set_vbus_in_curr(di,
2265 					di->max_usb_in_curr.usb_type_max_ua);
2266 		if (ret)
2267 			return;
2268 	}
2269 
2270 	ab8500_charger_set_usb_connected(di, true);
2271 	ab8500_power_supply_changed(di, di->usb_chg.psy);
2272 }
2273 
2274 /**
2275  * ab8500_charger_usb_link_status_work() - work to detect USB type
2276  * @work:	pointer to the work_struct structure
2277  *
2278  * Detect the type of USB plugged
2279  */
2280 static void ab8500_charger_usb_link_status_work(struct work_struct *work)
2281 {
2282 	int detected_chargers;
2283 	int ret;
2284 	u8 val;
2285 	u8 link_status;
2286 
2287 	struct ab8500_charger *di = container_of(work,
2288 		struct ab8500_charger, usb_link_status_work);
2289 
2290 	/*
2291 	 * Since we can't be sure that the events are received
2292 	 * synchronously, we have the check if  is
2293 	 * connected by reading the status register
2294 	 */
2295 	detected_chargers = ab8500_charger_detect_chargers(di, false);
2296 	if (detected_chargers < 0)
2297 		return;
2298 
2299 	/*
2300 	 * Some chargers that breaks the USB spec is
2301 	 * identified as invalid by AB8500 and it refuse
2302 	 * to start the charging process. but by jumping
2303 	 * through a few hoops it can be forced to start.
2304 	 */
2305 	if (is_ab8500(di->parent))
2306 		ret = abx500_get_register_interruptible(di->dev, AB8500_USB,
2307 					AB8500_USB_LINE_STAT_REG, &val);
2308 	else
2309 		ret = abx500_get_register_interruptible(di->dev, AB8500_USB,
2310 					AB8500_USB_LINK1_STAT_REG, &val);
2311 
2312 	if (ret >= 0)
2313 		dev_dbg(di->dev, "UsbLineStatus register = 0x%02x\n", val);
2314 	else
2315 		dev_dbg(di->dev, "Error reading USB link status\n");
2316 
2317 	if (is_ab8500(di->parent))
2318 		link_status = AB8500_USB_LINK_STATUS;
2319 	else
2320 		link_status = AB8505_USB_LINK_STATUS;
2321 
2322 	if (detected_chargers & USB_PW_CONN) {
2323 		if (((val & link_status) >> USB_LINK_STATUS_SHIFT) ==
2324 				USB_STAT_NOT_VALID_LINK &&
2325 				di->invalid_charger_detect_state == 0) {
2326 			dev_dbg(di->dev,
2327 					"Invalid charger detected, state= 0\n");
2328 			/*Enable charger*/
2329 			abx500_mask_and_set_register_interruptible(di->dev,
2330 					AB8500_CHARGER, AB8500_USBCH_CTRL1_REG,
2331 					USB_CH_ENA, USB_CH_ENA);
2332 			/*Enable charger detection*/
2333 			abx500_mask_and_set_register_interruptible(di->dev,
2334 					AB8500_USB, AB8500_USB_LINE_CTRL2_REG,
2335 					USB_CH_DET, USB_CH_DET);
2336 			di->invalid_charger_detect_state = 1;
2337 			/*exit and wait for new link status interrupt.*/
2338 			return;
2339 
2340 		}
2341 		if (di->invalid_charger_detect_state == 1) {
2342 			dev_dbg(di->dev,
2343 					"Invalid charger detected, state= 1\n");
2344 			/*Stop charger detection*/
2345 			abx500_mask_and_set_register_interruptible(di->dev,
2346 					AB8500_USB, AB8500_USB_LINE_CTRL2_REG,
2347 					USB_CH_DET, 0x00);
2348 			/*Check link status*/
2349 			if (is_ab8500(di->parent))
2350 				ret = abx500_get_register_interruptible(di->dev,
2351 					AB8500_USB, AB8500_USB_LINE_STAT_REG,
2352 					&val);
2353 			else
2354 				ret = abx500_get_register_interruptible(di->dev,
2355 					AB8500_USB, AB8500_USB_LINK1_STAT_REG,
2356 					&val);
2357 
2358 			dev_dbg(di->dev, "USB link status= 0x%02x\n",
2359 				(val & link_status) >> USB_LINK_STATUS_SHIFT);
2360 			di->invalid_charger_detect_state = 2;
2361 		}
2362 	} else {
2363 		di->invalid_charger_detect_state = 0;
2364 	}
2365 
2366 	if (!(detected_chargers & USB_PW_CONN)) {
2367 		di->vbus_detected = false;
2368 		ab8500_charger_set_usb_connected(di, false);
2369 		ab8500_power_supply_changed(di, di->usb_chg.psy);
2370 		return;
2371 	}
2372 
2373 	dev_dbg(di->dev,"%s di->vbus_detected = true\n",__func__);
2374 	di->vbus_detected = true;
2375 	ret = ab8500_charger_read_usb_type(di);
2376 	if (ret) {
2377 		if (ret == -ENXIO) {
2378 			/* No valid charger type detected */
2379 			ab8500_charger_set_usb_connected(di, false);
2380 			ab8500_power_supply_changed(di, di->usb_chg.psy);
2381 		}
2382 		return;
2383 	}
2384 
2385 	if (di->usb_device_is_unrecognised) {
2386 		dev_dbg(di->dev,
2387 			"Potential Legacy Charger device. "
2388 			"Delay work for %d msec for USB enum "
2389 			"to finish",
2390 			WAIT_ACA_RID_ENUMERATION);
2391 		queue_delayed_work(di->charger_wq,
2392 				   &di->attach_work,
2393 				   msecs_to_jiffies(WAIT_ACA_RID_ENUMERATION));
2394 	} else if (di->is_aca_rid == 1) {
2395 		/* Only wait once */
2396 		di->is_aca_rid++;
2397 		dev_dbg(di->dev,
2398 			"%s Wait %d msec for USB enum to finish",
2399 			__func__, WAIT_ACA_RID_ENUMERATION);
2400 		queue_delayed_work(di->charger_wq,
2401 				   &di->attach_work,
2402 				   msecs_to_jiffies(WAIT_ACA_RID_ENUMERATION));
2403 	} else {
2404 		queue_delayed_work(di->charger_wq,
2405 				   &di->attach_work,
2406 				   0);
2407 	}
2408 }
2409 
2410 static void ab8500_charger_usb_state_changed_work(struct work_struct *work)
2411 {
2412 	int ret;
2413 	unsigned long flags;
2414 
2415 	struct ab8500_charger *di = container_of(work,
2416 		struct ab8500_charger, usb_state_changed_work.work);
2417 
2418 	if (!di->vbus_detected)	{
2419 		dev_dbg(di->dev,
2420 			"%s !di->vbus_detected\n",
2421 			__func__);
2422 		return;
2423 	}
2424 
2425 	spin_lock_irqsave(&di->usb_state.usb_lock, flags);
2426 	di->usb_state.state = di->usb_state.state_tmp;
2427 	di->usb_state.usb_current_ua = di->usb_state.usb_current_tmp_ua;
2428 	spin_unlock_irqrestore(&di->usb_state.usb_lock, flags);
2429 
2430 	dev_dbg(di->dev, "%s USB state: 0x%02x uA: %d\n",
2431 		__func__, di->usb_state.state, di->usb_state.usb_current_ua);
2432 
2433 	switch (di->usb_state.state) {
2434 	case AB8500_BM_USB_STATE_RESET_HS:
2435 	case AB8500_BM_USB_STATE_RESET_FS:
2436 	case AB8500_BM_USB_STATE_SUSPEND:
2437 	case AB8500_BM_USB_STATE_MAX:
2438 		ab8500_charger_set_usb_connected(di, false);
2439 		ab8500_power_supply_changed(di, di->usb_chg.psy);
2440 		break;
2441 
2442 	case AB8500_BM_USB_STATE_RESUME:
2443 		/*
2444 		 * when suspend->resume there should be delay
2445 		 * of 1sec for enabling charging
2446 		 */
2447 		msleep(1000);
2448 		fallthrough;
2449 	case AB8500_BM_USB_STATE_CONFIGURED:
2450 		/*
2451 		 * USB is configured, enable charging with the charging
2452 		 * input current obtained from USB driver
2453 		 */
2454 		if (!ab8500_charger_get_usb_cur(di)) {
2455 			/* Update maximum input current */
2456 			ret = ab8500_charger_set_vbus_in_curr(di,
2457 					di->max_usb_in_curr.usb_type_max_ua);
2458 			if (ret)
2459 				return;
2460 
2461 			ab8500_charger_set_usb_connected(di, true);
2462 			ab8500_power_supply_changed(di, di->usb_chg.psy);
2463 		}
2464 		break;
2465 
2466 	default:
2467 		break;
2468 	}
2469 }
2470 
2471 /**
2472  * ab8500_charger_check_usbchargernotok_work() - check USB chg not ok status
2473  * @work:	pointer to the work_struct structure
2474  *
2475  * Work queue function for checking the USB charger Not OK status
2476  */
2477 static void ab8500_charger_check_usbchargernotok_work(struct work_struct *work)
2478 {
2479 	int ret;
2480 	u8 reg_value;
2481 	bool prev_status;
2482 
2483 	struct ab8500_charger *di = container_of(work,
2484 		struct ab8500_charger, check_usbchgnotok_work.work);
2485 
2486 	/* Check if the status bit for usbchargernotok is still active */
2487 	ret = abx500_get_register_interruptible(di->dev,
2488 		AB8500_CHARGER, AB8500_CH_USBCH_STAT2_REG, &reg_value);
2489 	if (ret < 0) {
2490 		dev_err(di->dev, "%s ab8500 read failed\n", __func__);
2491 		return;
2492 	}
2493 	prev_status = di->flags.usbchargernotok;
2494 
2495 	if (reg_value & VBUS_CH_NOK) {
2496 		di->flags.usbchargernotok = true;
2497 		/* Check again in 1sec */
2498 		queue_delayed_work(di->charger_wq,
2499 			&di->check_usbchgnotok_work, HZ);
2500 	} else {
2501 		di->flags.usbchargernotok = false;
2502 		di->flags.vbus_collapse = false;
2503 	}
2504 
2505 	if (prev_status != di->flags.usbchargernotok)
2506 		ab8500_power_supply_changed(di, di->usb_chg.psy);
2507 }
2508 
2509 /**
2510  * ab8500_charger_check_main_thermal_prot_work() - check main thermal status
2511  * @work:	pointer to the work_struct structure
2512  *
2513  * Work queue function for checking the Main thermal prot status
2514  */
2515 static void ab8500_charger_check_main_thermal_prot_work(
2516 	struct work_struct *work)
2517 {
2518 	int ret;
2519 	u8 reg_value;
2520 
2521 	struct ab8500_charger *di = container_of(work,
2522 		struct ab8500_charger, check_main_thermal_prot_work);
2523 
2524 	/* Check if the status bit for main_thermal_prot is still active */
2525 	ret = abx500_get_register_interruptible(di->dev,
2526 		AB8500_CHARGER, AB8500_CH_STATUS2_REG, &reg_value);
2527 	if (ret < 0) {
2528 		dev_err(di->dev, "%s ab8500 read failed\n", __func__);
2529 		return;
2530 	}
2531 	if (reg_value & MAIN_CH_TH_PROT)
2532 		di->flags.main_thermal_prot = true;
2533 	else
2534 		di->flags.main_thermal_prot = false;
2535 
2536 	ab8500_power_supply_changed(di, di->ac_chg.psy);
2537 }
2538 
2539 /**
2540  * ab8500_charger_check_usb_thermal_prot_work() - check usb thermal status
2541  * @work:	pointer to the work_struct structure
2542  *
2543  * Work queue function for checking the USB thermal prot status
2544  */
2545 static void ab8500_charger_check_usb_thermal_prot_work(
2546 	struct work_struct *work)
2547 {
2548 	int ret;
2549 	u8 reg_value;
2550 
2551 	struct ab8500_charger *di = container_of(work,
2552 		struct ab8500_charger, check_usb_thermal_prot_work);
2553 
2554 	/* Check if the status bit for usb_thermal_prot is still active */
2555 	ret = abx500_get_register_interruptible(di->dev,
2556 		AB8500_CHARGER, AB8500_CH_USBCH_STAT2_REG, &reg_value);
2557 	if (ret < 0) {
2558 		dev_err(di->dev, "%s ab8500 read failed\n", __func__);
2559 		return;
2560 	}
2561 	if (reg_value & USB_CH_TH_PROT)
2562 		di->flags.usb_thermal_prot = true;
2563 	else
2564 		di->flags.usb_thermal_prot = false;
2565 
2566 	ab8500_power_supply_changed(di, di->usb_chg.psy);
2567 }
2568 
2569 /**
2570  * ab8500_charger_mainchunplugdet_handler() - main charger unplugged
2571  * @irq:       interrupt number
2572  * @_di:       pointer to the ab8500_charger structure
2573  *
2574  * Returns IRQ status(IRQ_HANDLED)
2575  */
2576 static irqreturn_t ab8500_charger_mainchunplugdet_handler(int irq, void *_di)
2577 {
2578 	struct ab8500_charger *di = _di;
2579 
2580 	dev_dbg(di->dev, "Main charger unplugged\n");
2581 	queue_work(di->charger_wq, &di->ac_work);
2582 
2583 	cancel_delayed_work_sync(&di->ac_charger_attached_work);
2584 	mutex_lock(&di->charger_attached_mutex);
2585 	mutex_unlock(&di->charger_attached_mutex);
2586 
2587 	return IRQ_HANDLED;
2588 }
2589 
2590 /**
2591  * ab8500_charger_mainchplugdet_handler() - main charger plugged
2592  * @irq:       interrupt number
2593  * @_di:       pointer to the ab8500_charger structure
2594  *
2595  * Returns IRQ status(IRQ_HANDLED)
2596  */
2597 static irqreturn_t ab8500_charger_mainchplugdet_handler(int irq, void *_di)
2598 {
2599 	struct ab8500_charger *di = _di;
2600 
2601 	dev_dbg(di->dev, "Main charger plugged\n");
2602 	queue_work(di->charger_wq, &di->ac_work);
2603 
2604 	mutex_lock(&di->charger_attached_mutex);
2605 	mutex_unlock(&di->charger_attached_mutex);
2606 
2607 	if (is_ab8500(di->parent))
2608 		queue_delayed_work(di->charger_wq,
2609 			   &di->ac_charger_attached_work,
2610 			   HZ);
2611 	return IRQ_HANDLED;
2612 }
2613 
2614 /**
2615  * ab8500_charger_mainextchnotok_handler() - main charger not ok
2616  * @irq:       interrupt number
2617  * @_di:       pointer to the ab8500_charger structure
2618  *
2619  * Returns IRQ status(IRQ_HANDLED)
2620  */
2621 static irqreturn_t ab8500_charger_mainextchnotok_handler(int irq, void *_di)
2622 {
2623 	struct ab8500_charger *di = _di;
2624 
2625 	dev_dbg(di->dev, "Main charger not ok\n");
2626 	di->flags.mainextchnotok = true;
2627 	ab8500_power_supply_changed(di, di->ac_chg.psy);
2628 
2629 	/* Schedule a new HW failure check */
2630 	queue_delayed_work(di->charger_wq, &di->check_hw_failure_work, 0);
2631 
2632 	return IRQ_HANDLED;
2633 }
2634 
2635 /**
2636  * ab8500_charger_mainchthprotr_handler() - Die temp is above main charger
2637  * thermal protection threshold
2638  * @irq:       interrupt number
2639  * @_di:       pointer to the ab8500_charger structure
2640  *
2641  * Returns IRQ status(IRQ_HANDLED)
2642  */
2643 static irqreturn_t ab8500_charger_mainchthprotr_handler(int irq, void *_di)
2644 {
2645 	struct ab8500_charger *di = _di;
2646 
2647 	dev_dbg(di->dev,
2648 		"Die temp above Main charger thermal protection threshold\n");
2649 	queue_work(di->charger_wq, &di->check_main_thermal_prot_work);
2650 
2651 	return IRQ_HANDLED;
2652 }
2653 
2654 /**
2655  * ab8500_charger_mainchthprotf_handler() - Die temp is below main charger
2656  * thermal protection threshold
2657  * @irq:       interrupt number
2658  * @_di:       pointer to the ab8500_charger structure
2659  *
2660  * Returns IRQ status(IRQ_HANDLED)
2661  */
2662 static irqreturn_t ab8500_charger_mainchthprotf_handler(int irq, void *_di)
2663 {
2664 	struct ab8500_charger *di = _di;
2665 
2666 	dev_dbg(di->dev,
2667 		"Die temp ok for Main charger thermal protection threshold\n");
2668 	queue_work(di->charger_wq, &di->check_main_thermal_prot_work);
2669 
2670 	return IRQ_HANDLED;
2671 }
2672 
2673 static void ab8500_charger_vbus_drop_end_work(struct work_struct *work)
2674 {
2675 	struct ab8500_charger *di = container_of(work,
2676 		struct ab8500_charger, vbus_drop_end_work.work);
2677 	int ret, curr_ua;
2678 	u8 reg_value;
2679 
2680 	di->flags.vbus_drop_end = false;
2681 
2682 	/* Reset the drop counter */
2683 	abx500_set_register_interruptible(di->dev,
2684 				  AB8500_CHARGER, AB8500_CHARGER_CTRL, 0x01);
2685 
2686 	ret = abx500_get_register_interruptible(di->dev, AB8500_CHARGER,
2687 			AB8500_CH_USBCH_STAT2_REG, &reg_value);
2688 	if (ret < 0) {
2689 		dev_err(di->dev, "%s read failed\n", __func__);
2690 		return;
2691 	}
2692 
2693 	curr_ua = ab8500_charge_input_curr_map[
2694 		reg_value >> AUTO_VBUS_IN_CURR_LIM_SHIFT];
2695 
2696 	if (di->max_usb_in_curr.calculated_max_ua != curr_ua) {
2697 		/* USB source is collapsing */
2698 		di->max_usb_in_curr.calculated_max_ua = curr_ua;
2699 		dev_dbg(di->dev,
2700 			 "VBUS input current limiting to %d uA\n",
2701 			 di->max_usb_in_curr.calculated_max_ua);
2702 	} else {
2703 		/*
2704 		 * USB source can not give more than this amount.
2705 		 * Taking more will collapse the source.
2706 		 */
2707 		di->max_usb_in_curr.set_max_ua =
2708 			di->max_usb_in_curr.calculated_max_ua;
2709 		dev_dbg(di->dev,
2710 			 "VBUS input current limited to %d uA\n",
2711 			 di->max_usb_in_curr.set_max_ua);
2712 	}
2713 
2714 	if (di->usb.charger_connected)
2715 		ab8500_charger_set_vbus_in_curr(di,
2716 					di->max_usb_in_curr.usb_type_max_ua);
2717 }
2718 
2719 /**
2720  * ab8500_charger_vbusdetf_handler() - VBUS falling detected
2721  * @irq:       interrupt number
2722  * @_di:       pointer to the ab8500_charger structure
2723  *
2724  * Returns IRQ status(IRQ_HANDLED)
2725  */
2726 static irqreturn_t ab8500_charger_vbusdetf_handler(int irq, void *_di)
2727 {
2728 	struct ab8500_charger *di = _di;
2729 
2730 	di->vbus_detected = false;
2731 	dev_dbg(di->dev, "VBUS falling detected\n");
2732 	queue_work(di->charger_wq, &di->detect_usb_type_work);
2733 
2734 	return IRQ_HANDLED;
2735 }
2736 
2737 /**
2738  * ab8500_charger_vbusdetr_handler() - VBUS rising detected
2739  * @irq:       interrupt number
2740  * @_di:       pointer to the ab8500_charger structure
2741  *
2742  * Returns IRQ status(IRQ_HANDLED)
2743  */
2744 static irqreturn_t ab8500_charger_vbusdetr_handler(int irq, void *_di)
2745 {
2746 	struct ab8500_charger *di = _di;
2747 
2748 	di->vbus_detected = true;
2749 	dev_dbg(di->dev, "VBUS rising detected\n");
2750 
2751 	queue_work(di->charger_wq, &di->detect_usb_type_work);
2752 
2753 	return IRQ_HANDLED;
2754 }
2755 
2756 /**
2757  * ab8500_charger_usblinkstatus_handler() - USB link status has changed
2758  * @irq:       interrupt number
2759  * @_di:       pointer to the ab8500_charger structure
2760  *
2761  * Returns IRQ status(IRQ_HANDLED)
2762  */
2763 static irqreturn_t ab8500_charger_usblinkstatus_handler(int irq, void *_di)
2764 {
2765 	struct ab8500_charger *di = _di;
2766 
2767 	dev_dbg(di->dev, "USB link status changed\n");
2768 
2769 	queue_work(di->charger_wq, &di->usb_link_status_work);
2770 
2771 	return IRQ_HANDLED;
2772 }
2773 
2774 /**
2775  * ab8500_charger_usbchthprotr_handler() - Die temp is above usb charger
2776  * thermal protection threshold
2777  * @irq:       interrupt number
2778  * @_di:       pointer to the ab8500_charger structure
2779  *
2780  * Returns IRQ status(IRQ_HANDLED)
2781  */
2782 static irqreturn_t ab8500_charger_usbchthprotr_handler(int irq, void *_di)
2783 {
2784 	struct ab8500_charger *di = _di;
2785 
2786 	dev_dbg(di->dev,
2787 		"Die temp above USB charger thermal protection threshold\n");
2788 	queue_work(di->charger_wq, &di->check_usb_thermal_prot_work);
2789 
2790 	return IRQ_HANDLED;
2791 }
2792 
2793 /**
2794  * ab8500_charger_usbchthprotf_handler() - Die temp is below usb charger
2795  * thermal protection threshold
2796  * @irq:       interrupt number
2797  * @_di:       pointer to the ab8500_charger structure
2798  *
2799  * Returns IRQ status(IRQ_HANDLED)
2800  */
2801 static irqreturn_t ab8500_charger_usbchthprotf_handler(int irq, void *_di)
2802 {
2803 	struct ab8500_charger *di = _di;
2804 
2805 	dev_dbg(di->dev,
2806 		"Die temp ok for USB charger thermal protection threshold\n");
2807 	queue_work(di->charger_wq, &di->check_usb_thermal_prot_work);
2808 
2809 	return IRQ_HANDLED;
2810 }
2811 
2812 /**
2813  * ab8500_charger_usbchargernotokr_handler() - USB charger not ok detected
2814  * @irq:       interrupt number
2815  * @_di:       pointer to the ab8500_charger structure
2816  *
2817  * Returns IRQ status(IRQ_HANDLED)
2818  */
2819 static irqreturn_t ab8500_charger_usbchargernotokr_handler(int irq, void *_di)
2820 {
2821 	struct ab8500_charger *di = _di;
2822 
2823 	dev_dbg(di->dev, "Not allowed USB charger detected\n");
2824 	queue_delayed_work(di->charger_wq, &di->check_usbchgnotok_work, 0);
2825 
2826 	return IRQ_HANDLED;
2827 }
2828 
2829 /**
2830  * ab8500_charger_chwdexp_handler() - Charger watchdog expired
2831  * @irq:       interrupt number
2832  * @_di:       pointer to the ab8500_charger structure
2833  *
2834  * Returns IRQ status(IRQ_HANDLED)
2835  */
2836 static irqreturn_t ab8500_charger_chwdexp_handler(int irq, void *_di)
2837 {
2838 	struct ab8500_charger *di = _di;
2839 
2840 	dev_dbg(di->dev, "Charger watchdog expired\n");
2841 
2842 	/*
2843 	 * The charger that was online when the watchdog expired
2844 	 * needs to be restarted for charging to start again
2845 	 */
2846 	if (di->ac.charger_online) {
2847 		di->ac.wd_expired = true;
2848 		ab8500_power_supply_changed(di, di->ac_chg.psy);
2849 	}
2850 	if (di->usb.charger_online) {
2851 		di->usb.wd_expired = true;
2852 		ab8500_power_supply_changed(di, di->usb_chg.psy);
2853 	}
2854 
2855 	return IRQ_HANDLED;
2856 }
2857 
2858 /**
2859  * ab8500_charger_vbuschdropend_handler() - VBUS drop removed
2860  * @irq:       interrupt number
2861  * @_di:       pointer to the ab8500_charger structure
2862  *
2863  * Returns IRQ status(IRQ_HANDLED)
2864  */
2865 static irqreturn_t ab8500_charger_vbuschdropend_handler(int irq, void *_di)
2866 {
2867 	struct ab8500_charger *di = _di;
2868 
2869 	dev_dbg(di->dev, "VBUS charger drop ended\n");
2870 	di->flags.vbus_drop_end = true;
2871 
2872 	/*
2873 	 * VBUS might have dropped due to bad connection.
2874 	 * Schedule a new input limit set to the value SW requests.
2875 	 */
2876 	queue_delayed_work(di->charger_wq, &di->vbus_drop_end_work,
2877 			   round_jiffies(VBUS_IN_CURR_LIM_RETRY_SET_TIME * HZ));
2878 
2879 	return IRQ_HANDLED;
2880 }
2881 
2882 /**
2883  * ab8500_charger_vbusovv_handler() - VBUS overvoltage detected
2884  * @irq:       interrupt number
2885  * @_di:       pointer to the ab8500_charger structure
2886  *
2887  * Returns IRQ status(IRQ_HANDLED)
2888  */
2889 static irqreturn_t ab8500_charger_vbusovv_handler(int irq, void *_di)
2890 {
2891 	struct ab8500_charger *di = _di;
2892 
2893 	dev_dbg(di->dev, "VBUS overvoltage detected\n");
2894 	di->flags.vbus_ovv = true;
2895 	ab8500_power_supply_changed(di, di->usb_chg.psy);
2896 
2897 	/* Schedule a new HW failure check */
2898 	queue_delayed_work(di->charger_wq, &di->check_hw_failure_work, 0);
2899 
2900 	return IRQ_HANDLED;
2901 }
2902 
2903 /**
2904  * ab8500_charger_ac_get_property() - get the ac/mains properties
2905  * @psy:       pointer to the power_supply structure
2906  * @psp:       pointer to the power_supply_property structure
2907  * @val:       pointer to the power_supply_propval union
2908  *
2909  * This function gets called when an application tries to get the ac/mains
2910  * properties by reading the sysfs files.
2911  * AC/Mains properties are online, present and voltage.
2912  * online:     ac/mains charging is in progress or not
2913  * present:    presence of the ac/mains
2914  * voltage:    AC/Mains voltage
2915  * Returns error code in case of failure else 0(on success)
2916  */
2917 static int ab8500_charger_ac_get_property(struct power_supply *psy,
2918 	enum power_supply_property psp,
2919 	union power_supply_propval *val)
2920 {
2921 	struct ab8500_charger *di;
2922 	int ret;
2923 
2924 	di = to_ab8500_charger_ac_device_info(psy_to_ux500_charger(psy));
2925 
2926 	switch (psp) {
2927 	case POWER_SUPPLY_PROP_HEALTH:
2928 		if (di->flags.mainextchnotok)
2929 			val->intval = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
2930 		else if (di->ac.wd_expired || di->usb.wd_expired)
2931 			val->intval = POWER_SUPPLY_HEALTH_DEAD;
2932 		else if (di->flags.main_thermal_prot)
2933 			val->intval = POWER_SUPPLY_HEALTH_OVERHEAT;
2934 		else
2935 			val->intval = POWER_SUPPLY_HEALTH_GOOD;
2936 		break;
2937 	case POWER_SUPPLY_PROP_ONLINE:
2938 		val->intval = di->ac.charger_online;
2939 		break;
2940 	case POWER_SUPPLY_PROP_PRESENT:
2941 		val->intval = di->ac.charger_connected;
2942 		break;
2943 	case POWER_SUPPLY_PROP_VOLTAGE_NOW:
2944 		ret = ab8500_charger_get_ac_voltage(di);
2945 		if (ret >= 0)
2946 			di->ac.charger_voltage_uv = ret;
2947 		/* On error, use previous value */
2948 		val->intval = di->ac.charger_voltage_uv;
2949 		break;
2950 	case POWER_SUPPLY_PROP_VOLTAGE_AVG:
2951 		/*
2952 		 * This property is used to indicate when CV mode is entered
2953 		 * for the AC charger
2954 		 */
2955 		di->ac.cv_active = ab8500_charger_ac_cv(di);
2956 		val->intval = di->ac.cv_active;
2957 		break;
2958 	case POWER_SUPPLY_PROP_CURRENT_NOW:
2959 		ret = ab8500_charger_get_ac_current(di);
2960 		if (ret >= 0)
2961 			di->ac.charger_current_ua = ret;
2962 		val->intval = di->ac.charger_current_ua;
2963 		break;
2964 	default:
2965 		return -EINVAL;
2966 	}
2967 	return 0;
2968 }
2969 
2970 /**
2971  * ab8500_charger_usb_get_property() - get the usb properties
2972  * @psy:        pointer to the power_supply structure
2973  * @psp:        pointer to the power_supply_property structure
2974  * @val:        pointer to the power_supply_propval union
2975  *
2976  * This function gets called when an application tries to get the usb
2977  * properties by reading the sysfs files.
2978  * USB properties are online, present and voltage.
2979  * online:     usb charging is in progress or not
2980  * present:    presence of the usb
2981  * voltage:    vbus voltage
2982  * Returns error code in case of failure else 0(on success)
2983  */
2984 static int ab8500_charger_usb_get_property(struct power_supply *psy,
2985 	enum power_supply_property psp,
2986 	union power_supply_propval *val)
2987 {
2988 	struct ab8500_charger *di;
2989 	int ret;
2990 
2991 	di = to_ab8500_charger_usb_device_info(psy_to_ux500_charger(psy));
2992 
2993 	switch (psp) {
2994 	case POWER_SUPPLY_PROP_HEALTH:
2995 		if (di->flags.usbchargernotok)
2996 			val->intval = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
2997 		else if (di->ac.wd_expired || di->usb.wd_expired)
2998 			val->intval = POWER_SUPPLY_HEALTH_DEAD;
2999 		else if (di->flags.usb_thermal_prot)
3000 			val->intval = POWER_SUPPLY_HEALTH_OVERHEAT;
3001 		else if (di->flags.vbus_ovv)
3002 			val->intval = POWER_SUPPLY_HEALTH_OVERVOLTAGE;
3003 		else
3004 			val->intval = POWER_SUPPLY_HEALTH_GOOD;
3005 		break;
3006 	case POWER_SUPPLY_PROP_ONLINE:
3007 		val->intval = di->usb.charger_online;
3008 		break;
3009 	case POWER_SUPPLY_PROP_PRESENT:
3010 		val->intval = di->usb.charger_connected;
3011 		break;
3012 	case POWER_SUPPLY_PROP_VOLTAGE_NOW:
3013 		ret = ab8500_charger_get_vbus_voltage(di);
3014 		if (ret >= 0)
3015 			di->usb.charger_voltage_uv = ret;
3016 		val->intval = di->usb.charger_voltage_uv;
3017 		break;
3018 	case POWER_SUPPLY_PROP_VOLTAGE_AVG:
3019 		/*
3020 		 * This property is used to indicate when CV mode is entered
3021 		 * for the USB charger
3022 		 */
3023 		di->usb.cv_active = ab8500_charger_usb_cv(di);
3024 		val->intval = di->usb.cv_active;
3025 		break;
3026 	case POWER_SUPPLY_PROP_CURRENT_NOW:
3027 		ret = ab8500_charger_get_usb_current(di);
3028 		if (ret >= 0)
3029 			di->usb.charger_current_ua = ret;
3030 		val->intval = di->usb.charger_current_ua;
3031 		break;
3032 	case POWER_SUPPLY_PROP_CURRENT_AVG:
3033 		/*
3034 		 * This property is used to indicate when VBUS has collapsed
3035 		 * due to too high output current from the USB charger
3036 		 */
3037 		if (di->flags.vbus_collapse)
3038 			val->intval = 1;
3039 		else
3040 			val->intval = 0;
3041 		break;
3042 	default:
3043 		return -EINVAL;
3044 	}
3045 	return 0;
3046 }
3047 
3048 /**
3049  * ab8500_charger_init_hw_registers() - Set up charger related registers
3050  * @di:		pointer to the ab8500_charger structure
3051  *
3052  * Set up charger OVV, watchdog and maximum voltage registers as well as
3053  * charging of the backup battery
3054  */
3055 static int ab8500_charger_init_hw_registers(struct ab8500_charger *di)
3056 {
3057 	int ret = 0;
3058 
3059 	/* Setup maximum charger current and voltage for ABB cut2.0 */
3060 	if (!is_ab8500_1p1_or_earlier(di->parent)) {
3061 		ret = abx500_set_register_interruptible(di->dev,
3062 			AB8500_CHARGER,
3063 			AB8500_CH_VOLT_LVL_MAX_REG, CH_VOL_LVL_4P6);
3064 		if (ret) {
3065 			dev_err(di->dev,
3066 				"failed to set CH_VOLT_LVL_MAX_REG\n");
3067 			goto out;
3068 		}
3069 
3070 		ret = abx500_set_register_interruptible(di->dev,
3071 			AB8500_CHARGER, AB8500_CH_OPT_CRNTLVL_MAX_REG,
3072 			CH_OP_CUR_LVL_1P6);
3073 		if (ret) {
3074 			dev_err(di->dev,
3075 				"failed to set CH_OPT_CRNTLVL_MAX_REG\n");
3076 			goto out;
3077 		}
3078 	}
3079 
3080 	if (is_ab8505_2p0(di->parent))
3081 		ret = abx500_mask_and_set_register_interruptible(di->dev,
3082 			AB8500_CHARGER,
3083 			AB8500_USBCH_CTRL2_REG,
3084 			VBUS_AUTO_IN_CURR_LIM_ENA,
3085 			VBUS_AUTO_IN_CURR_LIM_ENA);
3086 	else
3087 		/*
3088 		 * VBUS OVV set to 6.3V and enable automatic current limitation
3089 		 */
3090 		ret = abx500_set_register_interruptible(di->dev,
3091 			AB8500_CHARGER,
3092 			AB8500_USBCH_CTRL2_REG,
3093 			VBUS_OVV_SELECT_6P3V | VBUS_AUTO_IN_CURR_LIM_ENA);
3094 	if (ret) {
3095 		dev_err(di->dev,
3096 			"failed to set automatic current limitation\n");
3097 		goto out;
3098 	}
3099 
3100 	/* Enable main watchdog in OTP */
3101 	ret = abx500_set_register_interruptible(di->dev,
3102 		AB8500_OTP_EMUL, AB8500_OTP_CONF_15, OTP_ENABLE_WD);
3103 	if (ret) {
3104 		dev_err(di->dev, "failed to enable main WD in OTP\n");
3105 		goto out;
3106 	}
3107 
3108 	/* Enable main watchdog */
3109 	ret = abx500_set_register_interruptible(di->dev,
3110 		AB8500_SYS_CTRL2_BLOCK,
3111 		AB8500_MAIN_WDOG_CTRL_REG, MAIN_WDOG_ENA);
3112 	if (ret) {
3113 		dev_err(di->dev, "failed to enable main watchdog\n");
3114 		goto out;
3115 	}
3116 
3117 	/*
3118 	 * Due to internal synchronisation, Enable and Kick watchdog bits
3119 	 * cannot be enabled in a single write.
3120 	 * A minimum delay of 2*32 kHz period (62.5µs) must be inserted
3121 	 * between writing Enable then Kick bits.
3122 	 */
3123 	udelay(63);
3124 
3125 	/* Kick main watchdog */
3126 	ret = abx500_set_register_interruptible(di->dev,
3127 		AB8500_SYS_CTRL2_BLOCK,
3128 		AB8500_MAIN_WDOG_CTRL_REG,
3129 		(MAIN_WDOG_ENA | MAIN_WDOG_KICK));
3130 	if (ret) {
3131 		dev_err(di->dev, "failed to kick main watchdog\n");
3132 		goto out;
3133 	}
3134 
3135 	/* Disable main watchdog */
3136 	ret = abx500_set_register_interruptible(di->dev,
3137 		AB8500_SYS_CTRL2_BLOCK,
3138 		AB8500_MAIN_WDOG_CTRL_REG, MAIN_WDOG_DIS);
3139 	if (ret) {
3140 		dev_err(di->dev, "failed to disable main watchdog\n");
3141 		goto out;
3142 	}
3143 
3144 	/* Set watchdog timeout */
3145 	ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER,
3146 		AB8500_CH_WD_TIMER_REG, WD_TIMER);
3147 	if (ret) {
3148 		dev_err(di->dev, "failed to set charger watchdog timeout\n");
3149 		goto out;
3150 	}
3151 
3152 	ret = ab8500_charger_led_en(di, false);
3153 	if (ret < 0) {
3154 		dev_err(di->dev, "failed to disable LED\n");
3155 		goto out;
3156 	}
3157 
3158 	ret = abx500_set_register_interruptible(di->dev,
3159 		AB8500_RTC,
3160 		AB8500_RTC_BACKUP_CHG_REG,
3161 		(di->bm->bkup_bat_v & 0x3) | di->bm->bkup_bat_i);
3162 	if (ret) {
3163 		dev_err(di->dev, "failed to setup backup battery charging\n");
3164 		goto out;
3165 	}
3166 
3167 	/* Enable backup battery charging */
3168 	ret = abx500_mask_and_set_register_interruptible(di->dev,
3169 		AB8500_RTC, AB8500_RTC_CTRL_REG,
3170 		RTC_BUP_CH_ENA, RTC_BUP_CH_ENA);
3171 	if (ret < 0) {
3172 		dev_err(di->dev, "%s mask and set failed\n", __func__);
3173 		goto out;
3174 	}
3175 
3176 out:
3177 	return ret;
3178 }
3179 
3180 /*
3181  * ab8500 charger driver interrupts and their respective isr
3182  */
3183 static struct ab8500_charger_interrupts ab8500_charger_irq[] = {
3184 	{"MAIN_CH_UNPLUG_DET", ab8500_charger_mainchunplugdet_handler},
3185 	{"MAIN_CHARGE_PLUG_DET", ab8500_charger_mainchplugdet_handler},
3186 	{"MAIN_EXT_CH_NOT_OK", ab8500_charger_mainextchnotok_handler},
3187 	{"MAIN_CH_TH_PROT_R", ab8500_charger_mainchthprotr_handler},
3188 	{"MAIN_CH_TH_PROT_F", ab8500_charger_mainchthprotf_handler},
3189 	{"VBUS_DET_F", ab8500_charger_vbusdetf_handler},
3190 	{"VBUS_DET_R", ab8500_charger_vbusdetr_handler},
3191 	{"USB_LINK_STATUS", ab8500_charger_usblinkstatus_handler},
3192 	{"USB_CH_TH_PROT_R", ab8500_charger_usbchthprotr_handler},
3193 	{"USB_CH_TH_PROT_F", ab8500_charger_usbchthprotf_handler},
3194 	{"USB_CHARGER_NOT_OKR", ab8500_charger_usbchargernotokr_handler},
3195 	{"VBUS_OVV", ab8500_charger_vbusovv_handler},
3196 	{"CH_WD_EXP", ab8500_charger_chwdexp_handler},
3197 	{"VBUS_CH_DROP_END", ab8500_charger_vbuschdropend_handler},
3198 };
3199 
3200 static int ab8500_charger_usb_notifier_call(struct notifier_block *nb,
3201 		unsigned long event, void *power)
3202 {
3203 	struct ab8500_charger *di =
3204 		container_of(nb, struct ab8500_charger, nb);
3205 	enum ab8500_usb_state bm_usb_state;
3206 	/*
3207 	 * FIXME: it appears the AB8500 PHY never sends what it should here.
3208 	 * Fix the PHY driver to properly notify the desired current.
3209 	 * Also broadcast microampere and not milliampere.
3210 	 */
3211 	unsigned mA = *((unsigned *)power);
3212 
3213 	if (event != USB_EVENT_VBUS) {
3214 		dev_dbg(di->dev, "not a standard host, returning\n");
3215 		return NOTIFY_DONE;
3216 	}
3217 
3218 	/* TODO: State is fabricate  here. See if charger really needs USB
3219 	 * state or if mA is enough
3220 	 */
3221 	if ((di->usb_state.usb_current_ua == 2000) && (mA > 2))
3222 		bm_usb_state = AB8500_BM_USB_STATE_RESUME;
3223 	else if (mA == 0)
3224 		bm_usb_state = AB8500_BM_USB_STATE_RESET_HS;
3225 	else if (mA == 2)
3226 		bm_usb_state = AB8500_BM_USB_STATE_SUSPEND;
3227 	else if (mA >= 8) /* 8, 100, 500 */
3228 		bm_usb_state = AB8500_BM_USB_STATE_CONFIGURED;
3229 	else /* Should never occur */
3230 		bm_usb_state = AB8500_BM_USB_STATE_RESET_FS;
3231 
3232 	dev_dbg(di->dev, "%s usb_state: 0x%02x mA: %d\n",
3233 		__func__, bm_usb_state, mA);
3234 
3235 	spin_lock(&di->usb_state.usb_lock);
3236 	di->usb_state.state_tmp = bm_usb_state;
3237 	/* FIXME: broadcast ua instead, see above */
3238 	di->usb_state.usb_current_tmp_ua = mA * 1000;
3239 	spin_unlock(&di->usb_state.usb_lock);
3240 
3241 	/*
3242 	 * wait for some time until you get updates from the usb stack
3243 	 * and negotiations are completed
3244 	 */
3245 	queue_delayed_work(di->charger_wq, &di->usb_state_changed_work, HZ/2);
3246 
3247 	return NOTIFY_OK;
3248 }
3249 
3250 static int __maybe_unused ab8500_charger_resume(struct device *dev)
3251 {
3252 	int ret;
3253 	struct ab8500_charger *di = dev_get_drvdata(dev);
3254 
3255 	/*
3256 	 * For ABB revision 1.0 and 1.1 there is a bug in the watchdog
3257 	 * logic. That means we have to continuously kick the charger
3258 	 * watchdog even when no charger is connected. This is only
3259 	 * valid once the AC charger has been enabled. This is
3260 	 * a bug that is not handled by the algorithm and the
3261 	 * watchdog have to be kicked by the charger driver
3262 	 * when the AC charger is disabled
3263 	 */
3264 	if (di->ac_conn && is_ab8500_1p1_or_earlier(di->parent)) {
3265 		ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER,
3266 			AB8500_CHARG_WD_CTRL, CHARG_WD_KICK);
3267 		if (ret)
3268 			dev_err(di->dev, "Failed to kick WD!\n");
3269 
3270 		/* If not already pending start a new timer */
3271 		queue_delayed_work(di->charger_wq, &di->kick_wd_work,
3272 				   round_jiffies(WD_KICK_INTERVAL));
3273 	}
3274 
3275 	/* If we still have a HW failure, schedule a new check */
3276 	if (di->flags.mainextchnotok || di->flags.vbus_ovv) {
3277 		queue_delayed_work(di->charger_wq,
3278 			&di->check_hw_failure_work, 0);
3279 	}
3280 
3281 	if (di->flags.vbus_drop_end)
3282 		queue_delayed_work(di->charger_wq, &di->vbus_drop_end_work, 0);
3283 
3284 	return 0;
3285 }
3286 
3287 static int __maybe_unused ab8500_charger_suspend(struct device *dev)
3288 {
3289 	struct ab8500_charger *di = dev_get_drvdata(dev);
3290 
3291 	/* Cancel any pending jobs */
3292 	cancel_delayed_work(&di->check_hw_failure_work);
3293 	cancel_delayed_work(&di->vbus_drop_end_work);
3294 
3295 	flush_delayed_work(&di->attach_work);
3296 	flush_delayed_work(&di->usb_charger_attached_work);
3297 	flush_delayed_work(&di->ac_charger_attached_work);
3298 	flush_delayed_work(&di->check_usbchgnotok_work);
3299 	flush_delayed_work(&di->check_vbat_work);
3300 	flush_delayed_work(&di->kick_wd_work);
3301 
3302 	flush_work(&di->usb_link_status_work);
3303 	flush_work(&di->ac_work);
3304 	flush_work(&di->detect_usb_type_work);
3305 
3306 	if (atomic_read(&di->current_stepping_sessions))
3307 		return -EAGAIN;
3308 
3309 	return 0;
3310 }
3311 
3312 static struct notifier_block charger_nb = {
3313 	.notifier_call = ab8500_external_charger_prepare,
3314 };
3315 
3316 static char *supply_interface[] = {
3317 	"ab8500_chargalg",
3318 	"ab8500_fg",
3319 	"ab8500_btemp",
3320 };
3321 
3322 static const struct power_supply_desc ab8500_ac_chg_desc = {
3323 	.name		= "ab8500_ac",
3324 	.type		= POWER_SUPPLY_TYPE_MAINS,
3325 	.properties	= ab8500_charger_ac_props,
3326 	.num_properties	= ARRAY_SIZE(ab8500_charger_ac_props),
3327 	.get_property	= ab8500_charger_ac_get_property,
3328 };
3329 
3330 static const struct power_supply_desc ab8500_usb_chg_desc = {
3331 	.name		= "ab8500_usb",
3332 	.type		= POWER_SUPPLY_TYPE_USB,
3333 	.properties	= ab8500_charger_usb_props,
3334 	.num_properties	= ARRAY_SIZE(ab8500_charger_usb_props),
3335 	.get_property	= ab8500_charger_usb_get_property,
3336 };
3337 
3338 static int ab8500_charger_bind(struct device *dev)
3339 {
3340 	struct ab8500_charger *di = dev_get_drvdata(dev);
3341 	int ch_stat;
3342 	int ret;
3343 
3344 	/* Create a work queue for the charger */
3345 	di->charger_wq = alloc_ordered_workqueue("ab8500_charger_wq",
3346 						 WQ_MEM_RECLAIM);
3347 	if (di->charger_wq == NULL) {
3348 		dev_err(dev, "failed to create work queue\n");
3349 		return -ENOMEM;
3350 	}
3351 
3352 	ch_stat = ab8500_charger_detect_chargers(di, false);
3353 
3354 	if (ch_stat & AC_PW_CONN) {
3355 		if (is_ab8500(di->parent))
3356 			queue_delayed_work(di->charger_wq,
3357 					   &di->ac_charger_attached_work,
3358 					   HZ);
3359 	}
3360 	if (ch_stat & USB_PW_CONN) {
3361 		if (is_ab8500(di->parent))
3362 			queue_delayed_work(di->charger_wq,
3363 					   &di->usb_charger_attached_work,
3364 					   HZ);
3365 		di->vbus_detected = true;
3366 		di->vbus_detected_start = true;
3367 		queue_work(di->charger_wq,
3368 			   &di->detect_usb_type_work);
3369 	}
3370 
3371 	ret = component_bind_all(dev, di);
3372 	if (ret) {
3373 		dev_err(dev, "can't bind component devices\n");
3374 		return ret;
3375 	}
3376 
3377 	return 0;
3378 }
3379 
3380 static void ab8500_charger_unbind(struct device *dev)
3381 {
3382 	struct ab8500_charger *di = dev_get_drvdata(dev);
3383 	int ret;
3384 
3385 	/* Disable AC charging */
3386 	ab8500_charger_ac_en(&di->ac_chg, false, 0, 0);
3387 
3388 	/* Disable USB charging */
3389 	ab8500_charger_usb_en(&di->usb_chg, false, 0, 0);
3390 
3391 	/* Backup battery voltage and current disable */
3392 	ret = abx500_mask_and_set_register_interruptible(di->dev,
3393 		AB8500_RTC, AB8500_RTC_CTRL_REG, RTC_BUP_CH_ENA, 0);
3394 	if (ret < 0)
3395 		dev_err(di->dev, "%s mask and set failed\n", __func__);
3396 
3397 	/* Delete the work queue */
3398 	destroy_workqueue(di->charger_wq);
3399 
3400 	flush_scheduled_work();
3401 
3402 	/* Unbind fg, btemp, algorithm */
3403 	component_unbind_all(dev, di);
3404 }
3405 
3406 static const struct component_master_ops ab8500_charger_comp_ops = {
3407 	.bind = ab8500_charger_bind,
3408 	.unbind = ab8500_charger_unbind,
3409 };
3410 
3411 static struct platform_driver *const ab8500_charger_component_drivers[] = {
3412 	&ab8500_fg_driver,
3413 	&ab8500_btemp_driver,
3414 	&ab8500_chargalg_driver,
3415 };
3416 
3417 static int ab8500_charger_compare_dev(struct device *dev, void *data)
3418 {
3419 	return dev == data;
3420 }
3421 
3422 static int ab8500_charger_probe(struct platform_device *pdev)
3423 {
3424 	struct device *dev = &pdev->dev;
3425 	struct device_node *np = dev->of_node;
3426 	struct component_match *match = NULL;
3427 	struct power_supply_config ac_psy_cfg = {}, usb_psy_cfg = {};
3428 	struct ab8500_charger *di;
3429 	int charger_status;
3430 	int i, irq;
3431 	int ret;
3432 
3433 	di = devm_kzalloc(dev, sizeof(*di), GFP_KERNEL);
3434 	if (!di)
3435 		return -ENOMEM;
3436 
3437 	di->bm = &ab8500_bm_data;
3438 
3439 	di->autopower_cfg = of_property_read_bool(np, "autopower_cfg");
3440 
3441 	/* get parent data */
3442 	di->dev = dev;
3443 	di->parent = dev_get_drvdata(pdev->dev.parent);
3444 
3445 	/* Get ADC channels */
3446 	di->adc_main_charger_v = devm_iio_channel_get(dev, "main_charger_v");
3447 	if (IS_ERR(di->adc_main_charger_v)) {
3448 		ret = dev_err_probe(dev, PTR_ERR(di->adc_main_charger_v),
3449 				    "failed to get ADC main charger voltage\n");
3450 		return ret;
3451 	}
3452 	di->adc_main_charger_c = devm_iio_channel_get(dev, "main_charger_c");
3453 	if (IS_ERR(di->adc_main_charger_c)) {
3454 		ret = dev_err_probe(dev, PTR_ERR(di->adc_main_charger_c),
3455 				    "failed to get ADC main charger current\n");
3456 		return ret;
3457 	}
3458 	di->adc_vbus_v = devm_iio_channel_get(dev, "vbus_v");
3459 	if (IS_ERR(di->adc_vbus_v)) {
3460 		ret = dev_err_probe(dev, PTR_ERR(di->adc_vbus_v),
3461 				    "failed to get ADC USB charger voltage\n");
3462 		return ret;
3463 	}
3464 	di->adc_usb_charger_c = devm_iio_channel_get(dev, "usb_charger_c");
3465 	if (IS_ERR(di->adc_usb_charger_c)) {
3466 		ret = dev_err_probe(dev, PTR_ERR(di->adc_usb_charger_c),
3467 				    "failed to get ADC USB charger current\n");
3468 		return ret;
3469 	}
3470 
3471 	/*
3472 	 * VDD ADC supply needs to be enabled from this driver when there
3473 	 * is a charger connected to avoid erroneous BTEMP_HIGH/LOW
3474 	 * interrupts during charging
3475 	 */
3476 	di->regu = devm_regulator_get(dev, "vddadc");
3477 	if (IS_ERR(di->regu)) {
3478 		ret = PTR_ERR(di->regu);
3479 		dev_err(dev, "failed to get vddadc regulator\n");
3480 		return ret;
3481 	}
3482 
3483 	/* Request interrupts */
3484 	for (i = 0; i < ARRAY_SIZE(ab8500_charger_irq); i++) {
3485 		irq = platform_get_irq_byname(pdev, ab8500_charger_irq[i].name);
3486 		if (irq < 0)
3487 			return irq;
3488 
3489 		ret = devm_request_threaded_irq(dev,
3490 			irq, NULL, ab8500_charger_irq[i].isr,
3491 			IRQF_SHARED | IRQF_NO_SUSPEND | IRQF_ONESHOT,
3492 			ab8500_charger_irq[i].name, di);
3493 
3494 		if (ret != 0) {
3495 			dev_err(dev, "failed to request %s IRQ %d: %d\n"
3496 				, ab8500_charger_irq[i].name, irq, ret);
3497 			return ret;
3498 		}
3499 		dev_dbg(dev, "Requested %s IRQ %d: %d\n",
3500 			ab8500_charger_irq[i].name, irq, ret);
3501 	}
3502 
3503 	/* initialize lock */
3504 	spin_lock_init(&di->usb_state.usb_lock);
3505 	mutex_init(&di->usb_ipt_crnt_lock);
3506 
3507 	di->autopower = false;
3508 	di->invalid_charger_detect_state = 0;
3509 
3510 	/* AC and USB supply config */
3511 	ac_psy_cfg.of_node = np;
3512 	ac_psy_cfg.supplied_to = supply_interface;
3513 	ac_psy_cfg.num_supplicants = ARRAY_SIZE(supply_interface);
3514 	ac_psy_cfg.drv_data = &di->ac_chg;
3515 	usb_psy_cfg.of_node = np;
3516 	usb_psy_cfg.supplied_to = supply_interface;
3517 	usb_psy_cfg.num_supplicants = ARRAY_SIZE(supply_interface);
3518 	usb_psy_cfg.drv_data = &di->usb_chg;
3519 
3520 	/* AC supply */
3521 	/* ux500_charger sub-class */
3522 	di->ac_chg.ops.enable = &ab8500_charger_ac_en;
3523 	di->ac_chg.ops.check_enable = &ab8500_charger_ac_check_enable;
3524 	di->ac_chg.ops.kick_wd = &ab8500_charger_watchdog_kick;
3525 	di->ac_chg.ops.update_curr = &ab8500_charger_update_charger_current;
3526 	di->ac_chg.max_out_volt_uv = ab8500_charger_voltage_map[
3527 		ARRAY_SIZE(ab8500_charger_voltage_map) - 1];
3528 	di->ac_chg.max_out_curr_ua =
3529 		ab8500_charge_output_curr_map[ARRAY_SIZE(ab8500_charge_output_curr_map) - 1];
3530 	di->ac_chg.wdt_refresh = CHG_WD_INTERVAL;
3531 	/*
3532 	 * The AB8505 only supports USB charging. If we are not the
3533 	 * AB8505, register an AC charger.
3534 	 *
3535 	 * TODO: if this should be opt-in, add DT properties for this.
3536 	 */
3537 	if (!is_ab8505(di->parent))
3538 		di->ac_chg.enabled = true;
3539 	di->ac_chg.external = false;
3540 
3541 	/* USB supply */
3542 	/* ux500_charger sub-class */
3543 	di->usb_chg.ops.enable = &ab8500_charger_usb_en;
3544 	di->usb_chg.ops.check_enable = &ab8500_charger_usb_check_enable;
3545 	di->usb_chg.ops.kick_wd = &ab8500_charger_watchdog_kick;
3546 	di->usb_chg.ops.update_curr = &ab8500_charger_update_charger_current;
3547 	di->usb_chg.max_out_volt_uv = ab8500_charger_voltage_map[
3548 		ARRAY_SIZE(ab8500_charger_voltage_map) - 1];
3549 	di->usb_chg.max_out_curr_ua =
3550 		ab8500_charge_output_curr_map[ARRAY_SIZE(ab8500_charge_output_curr_map) - 1];
3551 	di->usb_chg.wdt_refresh = CHG_WD_INTERVAL;
3552 	di->usb_chg.external = false;
3553 	di->usb_state.usb_current_ua = -1;
3554 
3555 	mutex_init(&di->charger_attached_mutex);
3556 
3557 	/* Init work for HW failure check */
3558 	INIT_DEFERRABLE_WORK(&di->check_hw_failure_work,
3559 		ab8500_charger_check_hw_failure_work);
3560 	INIT_DEFERRABLE_WORK(&di->check_usbchgnotok_work,
3561 		ab8500_charger_check_usbchargernotok_work);
3562 
3563 	INIT_DELAYED_WORK(&di->ac_charger_attached_work,
3564 			  ab8500_charger_ac_attached_work);
3565 	INIT_DELAYED_WORK(&di->usb_charger_attached_work,
3566 			  ab8500_charger_usb_attached_work);
3567 
3568 	/*
3569 	 * For ABB revision 1.0 and 1.1 there is a bug in the watchdog
3570 	 * logic. That means we have to continuously kick the charger
3571 	 * watchdog even when no charger is connected. This is only
3572 	 * valid once the AC charger has been enabled. This is
3573 	 * a bug that is not handled by the algorithm and the
3574 	 * watchdog have to be kicked by the charger driver
3575 	 * when the AC charger is disabled
3576 	 */
3577 	INIT_DEFERRABLE_WORK(&di->kick_wd_work,
3578 		ab8500_charger_kick_watchdog_work);
3579 
3580 	INIT_DEFERRABLE_WORK(&di->check_vbat_work,
3581 		ab8500_charger_check_vbat_work);
3582 
3583 	INIT_DELAYED_WORK(&di->attach_work,
3584 		ab8500_charger_usb_link_attach_work);
3585 
3586 	INIT_DELAYED_WORK(&di->usb_state_changed_work,
3587 		ab8500_charger_usb_state_changed_work);
3588 
3589 	INIT_DELAYED_WORK(&di->vbus_drop_end_work,
3590 		ab8500_charger_vbus_drop_end_work);
3591 
3592 	/* Init work for charger detection */
3593 	INIT_WORK(&di->usb_link_status_work,
3594 		ab8500_charger_usb_link_status_work);
3595 	INIT_WORK(&di->ac_work, ab8500_charger_ac_work);
3596 	INIT_WORK(&di->detect_usb_type_work,
3597 		ab8500_charger_detect_usb_type_work);
3598 
3599 	/* Init work for checking HW status */
3600 	INIT_WORK(&di->check_main_thermal_prot_work,
3601 		ab8500_charger_check_main_thermal_prot_work);
3602 	INIT_WORK(&di->check_usb_thermal_prot_work,
3603 		ab8500_charger_check_usb_thermal_prot_work);
3604 
3605 
3606 	/* Initialize OVV, and other registers */
3607 	ret = ab8500_charger_init_hw_registers(di);
3608 	if (ret) {
3609 		dev_err(dev, "failed to initialize ABB registers\n");
3610 		return ret;
3611 	}
3612 
3613 	/* Register AC charger class */
3614 	if (di->ac_chg.enabled) {
3615 		di->ac_chg.psy = devm_power_supply_register(dev,
3616 						       &ab8500_ac_chg_desc,
3617 						       &ac_psy_cfg);
3618 		if (IS_ERR(di->ac_chg.psy)) {
3619 			dev_err(dev, "failed to register AC charger\n");
3620 			return PTR_ERR(di->ac_chg.psy);
3621 		}
3622 	}
3623 
3624 	/* Register USB charger class */
3625 	di->usb_chg.psy = devm_power_supply_register(dev,
3626 						     &ab8500_usb_chg_desc,
3627 						     &usb_psy_cfg);
3628 	if (IS_ERR(di->usb_chg.psy)) {
3629 		dev_err(dev, "failed to register USB charger\n");
3630 		return PTR_ERR(di->usb_chg.psy);
3631 	}
3632 
3633 	/*
3634 	 * Check what battery we have, since we always have the USB
3635 	 * psy, use that as a handle.
3636 	 */
3637 	ret = ab8500_bm_of_probe(di->usb_chg.psy, di->bm);
3638 	if (ret)
3639 		return dev_err_probe(dev, ret,
3640 				     "failed to get battery information\n");
3641 
3642 	/* Identify the connected charger types during startup */
3643 	charger_status = ab8500_charger_detect_chargers(di, true);
3644 	if (charger_status & AC_PW_CONN) {
3645 		di->ac.charger_connected = 1;
3646 		di->ac_conn = true;
3647 		ab8500_power_supply_changed(di, di->ac_chg.psy);
3648 		sysfs_notify(&di->ac_chg.psy->dev.kobj, NULL, "present");
3649 	}
3650 
3651 	platform_set_drvdata(pdev, di);
3652 
3653 	/* Create something that will match the subdrivers when we bind */
3654 	for (i = 0; i < ARRAY_SIZE(ab8500_charger_component_drivers); i++) {
3655 		struct device_driver *drv = &ab8500_charger_component_drivers[i]->driver;
3656 		struct device *p = NULL, *d;
3657 
3658 		while ((d = platform_find_device_by_driver(p, drv))) {
3659 			put_device(p);
3660 			component_match_add(dev, &match,
3661 					    ab8500_charger_compare_dev, d);
3662 			p = d;
3663 		}
3664 		put_device(p);
3665 	}
3666 	if (!match) {
3667 		dev_err(dev, "no matching components\n");
3668 		ret = -ENODEV;
3669 		goto remove_ab8500_bm;
3670 	}
3671 	if (IS_ERR(match)) {
3672 		dev_err(dev, "could not create component match\n");
3673 		ret = PTR_ERR(match);
3674 		goto remove_ab8500_bm;
3675 	}
3676 
3677 	/* Notifier for external charger enabling */
3678 	if (!di->ac_chg.enabled)
3679 		blocking_notifier_chain_register(
3680 			&charger_notifier_list, &charger_nb);
3681 
3682 
3683 	di->usb_phy = usb_get_phy(USB_PHY_TYPE_USB2);
3684 	if (IS_ERR_OR_NULL(di->usb_phy)) {
3685 		dev_err(dev, "failed to get usb transceiver\n");
3686 		ret = -EINVAL;
3687 		goto out_charger_notifier;
3688 	}
3689 	di->nb.notifier_call = ab8500_charger_usb_notifier_call;
3690 	ret = usb_register_notifier(di->usb_phy, &di->nb);
3691 	if (ret) {
3692 		dev_err(dev, "failed to register usb notifier\n");
3693 		goto put_usb_phy;
3694 	}
3695 
3696 
3697 	ret = component_master_add_with_match(&pdev->dev,
3698 					      &ab8500_charger_comp_ops,
3699 					      match);
3700 	if (ret) {
3701 		dev_err(dev, "failed to add component master\n");
3702 		goto free_notifier;
3703 	}
3704 
3705 	return 0;
3706 
3707 free_notifier:
3708 	usb_unregister_notifier(di->usb_phy, &di->nb);
3709 put_usb_phy:
3710 	usb_put_phy(di->usb_phy);
3711 out_charger_notifier:
3712 	if (!di->ac_chg.enabled)
3713 		blocking_notifier_chain_unregister(
3714 			&charger_notifier_list, &charger_nb);
3715 remove_ab8500_bm:
3716 	ab8500_bm_of_remove(di->usb_chg.psy, di->bm);
3717 	return ret;
3718 }
3719 
3720 static int ab8500_charger_remove(struct platform_device *pdev)
3721 {
3722 	struct ab8500_charger *di = platform_get_drvdata(pdev);
3723 
3724 	component_master_del(&pdev->dev, &ab8500_charger_comp_ops);
3725 
3726 	usb_unregister_notifier(di->usb_phy, &di->nb);
3727 	ab8500_bm_of_remove(di->usb_chg.psy, di->bm);
3728 	usb_put_phy(di->usb_phy);
3729 	if (!di->ac_chg.enabled)
3730 		blocking_notifier_chain_unregister(
3731 			&charger_notifier_list, &charger_nb);
3732 
3733 	return 0;
3734 }
3735 
3736 static SIMPLE_DEV_PM_OPS(ab8500_charger_pm_ops, ab8500_charger_suspend, ab8500_charger_resume);
3737 
3738 static const struct of_device_id ab8500_charger_match[] = {
3739 	{ .compatible = "stericsson,ab8500-charger", },
3740 	{ },
3741 };
3742 MODULE_DEVICE_TABLE(of, ab8500_charger_match);
3743 
3744 static struct platform_driver ab8500_charger_driver = {
3745 	.probe = ab8500_charger_probe,
3746 	.remove = ab8500_charger_remove,
3747 	.driver = {
3748 		.name = "ab8500-charger",
3749 		.of_match_table = ab8500_charger_match,
3750 		.pm = &ab8500_charger_pm_ops,
3751 	},
3752 };
3753 
3754 static int __init ab8500_charger_init(void)
3755 {
3756 	int ret;
3757 
3758 	ret = platform_register_drivers(ab8500_charger_component_drivers,
3759 			ARRAY_SIZE(ab8500_charger_component_drivers));
3760 	if (ret)
3761 		return ret;
3762 
3763 	return platform_driver_register(&ab8500_charger_driver);
3764 }
3765 
3766 static void __exit ab8500_charger_exit(void)
3767 {
3768 	platform_unregister_drivers(ab8500_charger_component_drivers,
3769 			ARRAY_SIZE(ab8500_charger_component_drivers));
3770 	platform_driver_unregister(&ab8500_charger_driver);
3771 }
3772 
3773 module_init(ab8500_charger_init);
3774 module_exit(ab8500_charger_exit);
3775 
3776 MODULE_LICENSE("GPL v2");
3777 MODULE_AUTHOR("Johan Palsson, Karl Komierowski, Arun R Murthy");
3778 MODULE_ALIAS("platform:ab8500-charger");
3779 MODULE_DESCRIPTION("AB8500 charger management driver");
3780