1	// SPDX-License-Identifier: GPL-2.0-only
2	/*
3	* Copyright (C) ST-Ericsson SA 2012
4	*
5	* Charger driver for AB8500
6	*
7	* Author:
8	* Johan Palsson <johan.palsson@stericsson.com>
9	* Karl Komierowski <karl.komierowski@stericsson.com>
10	* Arun R Murthy <arun.murthy@stericsson.com>
11	*/
12
13	#include <linux/init.h>
14	#include <linux/module.h>
15	#include <linux/device.h>
16	#include <linux/component.h>
17	#include <linux/interrupt.h>
18	#include <linux/delay.h>
19	#include <linux/notifier.h>
20	#include <linux/slab.h>
21	#include <linux/platform_device.h>
22	#include <linux/power_supply.h>
23	#include <linux/completion.h>
24	#include <linux/regulator/consumer.h>
25	#include <linux/err.h>
26	#include <linux/workqueue.h>
27	#include <linux/kobject.h>
28	#include <linux/of.h>
29	#include <linux/mfd/core.h>
30	#include <linux/mfd/abx500/ab8500.h>
31	#include <linux/mfd/abx500.h>
32	#include <linux/usb/otg.h>
33	#include <linux/mutex.h>
34	#include <linux/iio/consumer.h>
35
36	#include "ab8500-bm.h"
37	#include "ab8500-chargalg.h"
38
39	/* Charger constants */
40	#define NO_PW_CONN 0
41	#define AC_PW_CONN 1
42	#define USB_PW_CONN 2
43
44	#define MAIN_WDOG_ENA 0x01
45	#define MAIN_WDOG_KICK 0x02
46	#define MAIN_WDOG_DIS 0x00
47	#define CHARG_WD_KICK 0x01
48	#define MAIN_CH_ENA 0x01
49	#define MAIN_CH_NO_OVERSHOOT_ENA_N 0x02
50	#define USB_CH_ENA 0x01
51	#define USB_CHG_NO_OVERSHOOT_ENA_N 0x02
52	#define MAIN_CH_DET 0x01
53	#define MAIN_CH_CV_ON 0x04
54	#define USB_CH_CV_ON 0x08
55	#define VBUS_DET_DBNC100 0x02
56	#define VBUS_DET_DBNC1 0x01
57	#define OTP_ENABLE_WD 0x01
58	#define DROP_COUNT_RESET 0x01
59	#define USB_CH_DET 0x01
60
61	#define MAIN_CH_INPUT_CURR_SHIFT 4
62	#define VBUS_IN_CURR_LIM_SHIFT 4
63	#define AUTO_VBUS_IN_CURR_LIM_SHIFT 4
64	#define VBUS_IN_CURR_LIM_RETRY_SET_TIME 30 /* seconds */
65
66	#define LED_INDICATOR_PWM_ENA 0x01
67	#define LED_INDICATOR_PWM_DIS 0x00
68	#define LED_IND_CUR_5MA 0x04
69	#define LED_INDICATOR_PWM_DUTY_252_256 0xBF
70
71	/* HW failure constants */
72	#define MAIN_CH_TH_PROT 0x02
73	#define VBUS_CH_NOK 0x08
74	#define USB_CH_TH_PROT 0x02
75	#define VBUS_OVV_TH 0x01
76	#define MAIN_CH_NOK 0x01
77	#define VBUS_DET 0x80
78
79	#define MAIN_CH_STATUS2_MAINCHGDROP 0x80
80	#define MAIN_CH_STATUS2_MAINCHARGERDETDBNC 0x40
81	#define USB_CH_VBUSDROP 0x40
82	#define USB_CH_VBUSDETDBNC 0x01
83
84	/* UsbLineStatus register bit masks */
85	#define AB8500_USB_LINK_STATUS 0x78
86	#define AB8505_USB_LINK_STATUS 0xF8
87	#define AB8500_STD_HOST_SUSP 0x18
88	#define USB_LINK_STATUS_SHIFT 3
89
90	/* Watchdog timeout constant */
91	#define WD_TIMER 0x30 /* 4min */
92	#define WD_KICK_INTERVAL (60 * HZ)
93
94	/* Lowest charger voltage is 3.39V -> 0x4E */
95	#define LOW_VOLT_REG 0x4E
96
97	/* Step up/down delay in us */
98	#define STEP_UDELAY 1000
99
100	#define CHARGER_STATUS_POLL 10 /* in ms */
101
102	#define CHG_WD_INTERVAL (60 * HZ)
103
104	#define AB8500_SW_CONTROL_FALLBACK 0x03
105	/* Wait for enumeration before charing in us */
106	#define WAIT_ACA_RID_ENUMERATION (5 * 1000)
107	/*External charger control*/
108	#define AB8500_SYS_CHARGER_CONTROL_REG 0x52
109	#define EXTERNAL_CHARGER_DISABLE_REG_VAL 0x03
110	#define EXTERNAL_CHARGER_ENABLE_REG_VAL 0x07
111
112	/* UsbLineStatus register - usb types */
113	enum ab8500_charger_link_status {
114	USB_STAT_NOT_CONFIGURED,
115	USB_STAT_STD_HOST_NC,
116	USB_STAT_STD_HOST_C_NS,
117	USB_STAT_STD_HOST_C_S,
118	USB_STAT_HOST_CHG_NM,
119	USB_STAT_HOST_CHG_HS,
120	USB_STAT_HOST_CHG_HS_CHIRP,
121	USB_STAT_DEDICATED_CHG,
122	USB_STAT_ACA_RID_A,
123	USB_STAT_ACA_RID_B,
124	USB_STAT_ACA_RID_C_NM,
125	USB_STAT_ACA_RID_C_HS,
126	USB_STAT_ACA_RID_C_HS_CHIRP,
127	USB_STAT_HM_IDGND,
128	USB_STAT_RESERVED,
129	USB_STAT_NOT_VALID_LINK,
130	USB_STAT_PHY_EN,
131	USB_STAT_SUP_NO_IDGND_VBUS,
132	USB_STAT_SUP_IDGND_VBUS,
133	USB_STAT_CHARGER_LINE_1,
134	USB_STAT_CARKIT_1,
135	USB_STAT_CARKIT_2,
136	USB_STAT_ACA_DOCK_CHARGER,
137	};
138
139	enum ab8500_usb_state {
140	AB8500_BM_USB_STATE_RESET_HS, /* HighSpeed Reset */
141	AB8500_BM_USB_STATE_RESET_FS, /* FullSpeed/LowSpeed Reset */
142	AB8500_BM_USB_STATE_CONFIGURED,
143	AB8500_BM_USB_STATE_SUSPEND,
144	AB8500_BM_USB_STATE_RESUME,
145	AB8500_BM_USB_STATE_MAX,
146	};
147
148	/* VBUS input current limits supported in AB8500 in uA */
149	#define USB_CH_IP_CUR_LVL_0P05 50000
150	#define USB_CH_IP_CUR_LVL_0P09 98000
151	#define USB_CH_IP_CUR_LVL_0P19 193000
152	#define USB_CH_IP_CUR_LVL_0P29 290000
153	#define USB_CH_IP_CUR_LVL_0P38 380000
154	#define USB_CH_IP_CUR_LVL_0P45 450000
155	#define USB_CH_IP_CUR_LVL_0P5 500000
156	#define USB_CH_IP_CUR_LVL_0P6 600000
157	#define USB_CH_IP_CUR_LVL_0P7 700000
158	#define USB_CH_IP_CUR_LVL_0P8 800000
159	#define USB_CH_IP_CUR_LVL_0P9 900000
160	#define USB_CH_IP_CUR_LVL_1P0 1000000
161	#define USB_CH_IP_CUR_LVL_1P1 1100000
162	#define USB_CH_IP_CUR_LVL_1P3 1300000
163	#define USB_CH_IP_CUR_LVL_1P4 1400000
164	#define USB_CH_IP_CUR_LVL_1P5 1500000
165
166	#define VBAT_TRESH_IP_CUR_RED 3800000
167
168	#define to_ab8500_charger_usb_device_info(x) container_of((x), \
169	struct ab8500_charger, usb_chg)
170	#define to_ab8500_charger_ac_device_info(x) container_of((x), \
171	struct ab8500_charger, ac_chg)
172
173	/**
174	* struct ab8500_charger_interrupts - ab8500 interrupts
175	* @name: name of the interrupt
176	* @isr function pointer to the isr
177	*/
178	struct ab8500_charger_interrupts {
179	char *name;
180	irqreturn_t (*isr)(int irq, void *data);
181	};
182
183	struct ab8500_charger_info {
184	int charger_connected;
185	int charger_online;
186	int charger_voltage_uv;
187	int cv_active;
188	bool wd_expired;
189	int charger_current_ua;
190	};
191
192	struct ab8500_charger_event_flags {
193	bool mainextchnotok;
194	bool main_thermal_prot;
195	bool usb_thermal_prot;
196	bool vbus_ovv;
197	bool usbchargernotok;
198	bool chgwdexp;
199	bool vbus_collapse;
200	bool vbus_drop_end;
201	};
202
203	struct ab8500_charger_usb_state {
204	int usb_current_ua;
205	int usb_current_tmp_ua;
206	enum ab8500_usb_state state;
207	enum ab8500_usb_state state_tmp;
208	spinlock_t usb_lock;
209	};
210
211	struct ab8500_charger_max_usb_in_curr {
212	int usb_type_max_ua;
213	int set_max_ua;
214	int calculated_max_ua;
215	};
216
217	/**
218	* struct ab8500_charger - ab8500 Charger device information
219	* @dev: Pointer to the structure device
220	* @vbus_detected: VBUS detected
221	* @vbus_detected_start:
222	* VBUS detected during startup
223	* @ac_conn: This will be true when the AC charger has been plugged
224	* @vddadc_en_ac: Indicate if VDD ADC supply is enabled because AC
225	* charger is enabled
226	* @vddadc_en_usb: Indicate if VDD ADC supply is enabled because USB
227	* charger is enabled
228	* @vbat Battery voltage
229	* @old_vbat Previously measured battery voltage
230	* @usb_device_is_unrecognised USB device is unrecognised by the hardware
231	* @autopower Indicate if we should have automatic pwron after pwrloss
232	* @autopower_cfg platform specific power config support for "pwron after pwrloss"
233	* @invalid_charger_detect_state State when forcing AB to use invalid charger
234	* @is_aca_rid: Incicate if accessory is ACA type
235	* @current_stepping_sessions:
236	* Counter for current stepping sessions
237	* @parent: Pointer to the struct ab8500
238	* @adc_main_charger_v ADC channel for main charger voltage
239	* @adc_main_charger_c ADC channel for main charger current
240	* @adc_vbus_v ADC channel for USB charger voltage
241	* @adc_usb_charger_c ADC channel for USB charger current
242	* @bm: Platform specific battery management information
243	* @flags: Structure for information about events triggered
244	* @usb_state: Structure for usb stack information
245	* @max_usb_in_curr: Max USB charger input current
246	* @ac_chg: AC charger power supply
247	* @usb_chg: USB charger power supply
248	* @ac: Structure that holds the AC charger properties
249	* @usb: Structure that holds the USB charger properties
250	* @regu: Pointer to the struct regulator
251	* @charger_wq: Work queue for the IRQs and checking HW state
252	* @usb_ipt_crnt_lock: Lock to protect VBUS input current setting from mutuals
253	* @pm_lock: Lock to prevent system to suspend
254	* @check_vbat_work Work for checking vbat threshold to adjust vbus current
255	* @check_hw_failure_work: Work for checking HW state
256	* @check_usbchgnotok_work: Work for checking USB charger not ok status
257	* @kick_wd_work: Work for kicking the charger watchdog in case
258	* of ABB rev 1.* due to the watchog logic bug
259	* @ac_charger_attached_work: Work for checking if AC charger is still
260	* connected
261	* @usb_charger_attached_work: Work for checking if USB charger is still
262	* connected
263	* @ac_work: Work for checking AC charger connection
264	* @detect_usb_type_work: Work for detecting the USB type connected
265	* @usb_link_status_work: Work for checking the new USB link status
266	* @usb_state_changed_work: Work for checking USB state
267	* @attach_work: Work for detecting USB type
268	* @vbus_drop_end_work: Work for detecting VBUS drop end
269	* @check_main_thermal_prot_work:
270	* Work for checking Main thermal status
271	* @check_usb_thermal_prot_work:
272	* Work for checking USB thermal status
273	* @charger_attached_mutex: For controlling the wakelock
274	*/
275	struct ab8500_charger {
276	struct device *dev;
277	bool vbus_detected;
278	bool vbus_detected_start;
279	bool ac_conn;
280	bool vddadc_en_ac;
281	bool vddadc_en_usb;
282	int vbat;
283	int old_vbat;
284	bool usb_device_is_unrecognised;
285	bool autopower;
286	bool autopower_cfg;
287	int invalid_charger_detect_state;
288	int is_aca_rid;
289	atomic_t current_stepping_sessions;
290	struct ab8500 *parent;
291	struct iio_channel *adc_main_charger_v;
292	struct iio_channel *adc_main_charger_c;
293	struct iio_channel *adc_vbus_v;
294	struct iio_channel *adc_usb_charger_c;
295	struct ab8500_bm_data *bm;
296	struct ab8500_charger_event_flags flags;
297	struct ab8500_charger_usb_state usb_state;
298	struct ab8500_charger_max_usb_in_curr max_usb_in_curr;
299	struct ux500_charger ac_chg;
300	struct ux500_charger usb_chg;
301	struct ab8500_charger_info ac;
302	struct ab8500_charger_info usb;
303	struct regulator *regu;
304	struct workqueue_struct *charger_wq;
305	struct mutex usb_ipt_crnt_lock;
306	struct delayed_work check_vbat_work;
307	struct delayed_work check_hw_failure_work;
308	struct delayed_work check_usbchgnotok_work;
309	struct delayed_work kick_wd_work;
310	struct delayed_work usb_state_changed_work;
311	struct delayed_work attach_work;
312	struct delayed_work ac_charger_attached_work;
313	struct delayed_work usb_charger_attached_work;
314	struct delayed_work vbus_drop_end_work;
315	struct work_struct ac_work;
316	struct work_struct detect_usb_type_work;
317	struct work_struct usb_link_status_work;
318	struct work_struct check_main_thermal_prot_work;
319	struct work_struct check_usb_thermal_prot_work;
320	struct usb_phy *usb_phy;
321	struct notifier_block nb;
322	struct mutex charger_attached_mutex;
323	};
324
325	/* AC properties */
326	static enum power_supply_property ab8500_charger_ac_props[] = {
327	POWER_SUPPLY_PROP_HEALTH,
328	POWER_SUPPLY_PROP_PRESENT,
329	POWER_SUPPLY_PROP_ONLINE,
330	POWER_SUPPLY_PROP_VOLTAGE_NOW,
331	POWER_SUPPLY_PROP_VOLTAGE_AVG,
332	POWER_SUPPLY_PROP_CURRENT_NOW,
333	};
334
335	/* USB properties */
336	static enum power_supply_property ab8500_charger_usb_props[] = {
337	POWER_SUPPLY_PROP_HEALTH,
338	POWER_SUPPLY_PROP_CURRENT_AVG,
339	POWER_SUPPLY_PROP_PRESENT,
340	POWER_SUPPLY_PROP_ONLINE,
341	POWER_SUPPLY_PROP_VOLTAGE_NOW,
342	POWER_SUPPLY_PROP_VOLTAGE_AVG,
343	POWER_SUPPLY_PROP_CURRENT_NOW,
344	};
345
346	/*
347	* Function for enabling and disabling sw fallback mode
348	* should always be disabled when no charger is connected.
349	*/
350	static void ab8500_enable_disable_sw_fallback(struct ab8500_charger *di,
351	bool fallback)
352	{
353	u8 val;
354	u8 reg;
355	u8 bank;
356	u8 bit;
357	int ret;
358
359	dev_dbg(di->dev, "SW Fallback: %d\n", fallback);
360
361	if (is_ab8500(ab: 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(dev: di->dev, bank, reg, value: &val);
373	if (ret < 0) {
374	dev_err(di->dev, "%d read failed\n", __LINE__);
375	return;
376	}
377
378	if (is_ab8500(ab: di->parent)) {
379	/* enable the OPT emulation registers */
380	ret = abx500_set_register_interruptible(dev: di->dev, bank: 0x11, reg: 0x00, value: 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(dev: di->dev, bank, reg, value: val);
394	if (ret) {
395	dev_err(di->dev, "%d write failed\n", __LINE__);
396	}
397
398	disable_otp:
399	if (is_ab8500(ab: di->parent)) {
400	/* disable the set OTP registers again */
401	ret = abx500_set_register_interruptible(dev: di->dev, bank: 0x11, reg: 0x00, value: 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, fallback: 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, fallback: 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(kobj: &di->usb_chg.psy->dev.kobj, NULL,
459	attr: "present");
460	}
461
462	if (connected) {
463	mutex_lock(&di->charger_attached_mutex);
464	mutex_unlock(lock: &di->charger_attached_mutex);
465
466	if (is_ab8500(ab: di->parent))
467	queue_delayed_work(wq: di->charger_wq,
468	dwork: &di->usb_charger_attached_work,
469	HZ);
470	} else {
471	cancel_delayed_work_sync(dwork: &di->usb_charger_attached_work);
472	mutex_lock(&di->charger_attached_mutex);
473	mutex_unlock(lock: &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(chan: di->adc_main_charger_v, val: &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(dev: di->dev, AB8500_CHARGER,
514	AB8500_CH_STATUS1_REG, value: &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(chan: di->adc_vbus_v, val: &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(chan: di->adc_usb_charger_c, val: &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(chan: di->adc_main_charger_c, val: &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(dev: di->dev, AB8500_CHARGER,
612	AB8500_CH_USBCH_STAT1_REG, value: &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(dev: di->dev, AB8500_CHARGER,
654	AB8500_CH_STATUS1_REG, value: &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(msecs: 110);
673	}
674	ret = abx500_get_register_interruptible(dev: di->dev, AB8500_CHARGER,
675	AB8500_CH_USBCH_STAT1_REG, value: &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(ab: 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(dev: di->dev,
836	AB8500_INTERRUPT, AB8500_IT_SOURCE21_REG, value: &val);
837	if (ret < 0) {
838	dev_err(di->dev, "%s ab8500 read failed\n", __func__);
839	return ret;
840	}
841	if (is_ab8500(ab: di->parent))
842	ret = abx500_get_register_interruptible(dev: di->dev, AB8500_USB,
843	AB8500_USB_LINE_STAT_REG, value: &val);
844	else
845	ret = abx500_get_register_interruptible(dev: di->dev,
846	AB8500_USB, AB8500_USB_LINK1_STAT_REG, value: &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(ab: 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	link_status: (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(msecs: 250);
882	ret = abx500_get_register_interruptible(dev: di->dev,
883	AB8500_INTERRUPT, AB8500_IT_SOURCE21_REG,
884	value: &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(ab: di->parent))
893	ret = abx500_get_register_interruptible(dev: di->dev,
894	AB8500_USB, AB8500_USB_LINE_STAT_REG, value: &val);
895	else
896	ret = abx500_get_register_interruptible(dev: di->dev,
897	AB8500_USB, AB8500_USB_LINK1_STAT_REG, value: &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(ab: 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	link_status: (enum ab8500_charger_link_status) val);
922
923	return ret;
924	}
925
926	/*
927	* This array maps the raw hex value to charger voltage used by the AB8500
928	* Values taken from the UM0836, in microvolt.
929	*/
930	static int ab8500_charger_voltage_map[] = {
931	3500000,
932	3525000,
933	3550000,
934	3575000,
935	3600000,
936	3625000,
937	3650000,
938	3675000,
939	3700000,
940	3725000,
941	3750000,
942	3775000,
943	3800000,
944	3825000,
945	3850000,
946	3875000,
947	3900000,
948	3925000,
949	3950000,
950	3975000,
951	4000000,
952	4025000,
953	4050000,
954	4060000,
955	4070000,
956	4080000,
957	4090000,
958	4100000,
959	4110000,
960	4120000,
961	4130000,
962	4140000,
963	4150000,
964	4160000,
965	4170000,
966	4180000,
967	4190000,
968	4200000,
969	4210000,
970	4220000,
971	4230000,
972	4240000,
973	4250000,
974	4260000,
975	4270000,
976	4280000,
977	4290000,
978	4300000,
979	4310000,
980	4320000,
981	4330000,
982	4340000,
983	4350000,
984	4360000,
985	4370000,
986	4380000,
987	4390000,
988	4400000,
989	4410000,
990	4420000,
991	4430000,
992	4440000,
993	4450000,
994	4460000,
995	4470000,
996	4480000,
997	4490000,
998	4500000,
999	4510000,
1000	4520000,
1001	4530000,
1002	4540000,
1003	4550000,
1004	4560000,
1005	4570000,
1006	4580000,
1007	4590000,
1008	4600000,
1009	};
1010
1011	static int ab8500_voltage_to_regval(int voltage_uv)
1012	{
1013	int i;
1014
1015	/* Special case for voltage below 3.5V */
1016	if (voltage_uv < ab8500_charger_voltage_map[0])
1017	return LOW_VOLT_REG;
1018
1019	for (i = 1; i < ARRAY_SIZE(ab8500_charger_voltage_map); i++) {
1020	if (voltage_uv < ab8500_charger_voltage_map[i])
1021	return i - 1;
1022	}
1023
1024	/* If not last element, return error */
1025	i = ARRAY_SIZE(ab8500_charger_voltage_map) - 1;
1026	if (voltage_uv == ab8500_charger_voltage_map[i])
1027	return i;
1028	else
1029	return -1;
1030	}
1031
1032	/* This array maps the raw register value to charger input current */
1033	static int ab8500_charge_input_curr_map[] = {
1034	50000, 98000, 193000, 290000, 380000, 450000, 500000, 600000,
1035	700000, 800000, 900000, 1000000, 1100000, 1300000, 1400000, 1500000,
1036	};
1037
1038	/* This array maps the raw register value to charger output current */
1039	static int ab8500_charge_output_curr_map[] = {
1040	100000, 200000, 300000, 400000, 500000, 600000, 700000, 800000,
1041	900000, 1000000, 1100000, 1200000, 1300000, 1400000, 1500000, 1500000,
1042	};
1043
1044	static int ab8500_current_to_regval(struct ab8500_charger *di, int curr_ua)
1045	{
1046	int i;
1047
1048	if (curr_ua < ab8500_charge_output_curr_map[0])
1049	return 0;
1050
1051	for (i = 0; i < ARRAY_SIZE(ab8500_charge_output_curr_map); i++) {
1052	if (curr_ua < ab8500_charge_output_curr_map[i])
1053	return i - 1;
1054	}
1055
1056	/* If not last element, return error */
1057	i = ARRAY_SIZE(ab8500_charge_output_curr_map) - 1;
1058	if (curr_ua == ab8500_charge_output_curr_map[i])
1059	return i;
1060	else
1061	return -1;
1062	}
1063
1064	static int ab8500_vbus_in_curr_to_regval(struct ab8500_charger *di, int curr_ua)
1065	{
1066	int i;
1067
1068	if (curr_ua < ab8500_charge_input_curr_map[0])
1069	return 0;
1070
1071	for (i = 0; i < ARRAY_SIZE(ab8500_charge_input_curr_map); i++) {
1072	if (curr_ua < ab8500_charge_input_curr_map[i])
1073	return i - 1;
1074	}
1075
1076	/* If not last element, return error */
1077	i = ARRAY_SIZE(ab8500_charge_input_curr_map) - 1;
1078	if (curr_ua == ab8500_charge_input_curr_map[i])
1079	return i;
1080	else
1081	return -1;
1082	}
1083
1084	/**
1085	* ab8500_charger_get_usb_cur() - get usb current
1086	* @di: pointer to the ab8500_charger structure
1087	*
1088	* The usb stack provides the maximum current that can be drawn from
1089	* the standard usb host. This will be in uA.
1090	* This function converts current in uA to a value that can be written
1091	* to the register. Returns -1 if charging is not allowed
1092	*/
1093	static int ab8500_charger_get_usb_cur(struct ab8500_charger *di)
1094	{
1095	int ret = 0;
1096	switch (di->usb_state.usb_current_ua) {
1097	case 100000:
1098	di->max_usb_in_curr.usb_type_max_ua = USB_CH_IP_CUR_LVL_0P09;
1099	break;
1100	case 200000:
1101	di->max_usb_in_curr.usb_type_max_ua = USB_CH_IP_CUR_LVL_0P19;
1102	break;
1103	case 300000:
1104	di->max_usb_in_curr.usb_type_max_ua = USB_CH_IP_CUR_LVL_0P29;
1105	break;
1106	case 400000:
1107	di->max_usb_in_curr.usb_type_max_ua = USB_CH_IP_CUR_LVL_0P38;
1108	break;
1109	case 500000:
1110	di->max_usb_in_curr.usb_type_max_ua = USB_CH_IP_CUR_LVL_0P5;
1111	break;
1112	default:
1113	di->max_usb_in_curr.usb_type_max_ua = USB_CH_IP_CUR_LVL_0P05;
1114	ret = -EPERM;
1115	break;
1116	}
1117	di->max_usb_in_curr.set_max_ua = di->max_usb_in_curr.usb_type_max_ua;
1118	return ret;
1119	}
1120
1121	/**
1122	* ab8500_charger_check_continue_stepping() - Check to allow stepping
1123	* @di: pointer to the ab8500_charger structure
1124	* @reg: select what charger register to check
1125	*
1126	* Check if current stepping should be allowed to continue.
1127	* Checks if charger source has not collapsed. If it has, further stepping
1128	* is not allowed.
1129	*/
1130	static bool ab8500_charger_check_continue_stepping(struct ab8500_charger *di,
1131	int reg)
1132	{
1133	if (reg == AB8500_USBCH_IPT_CRNTLVL_REG)
1134	return !di->flags.vbus_drop_end;
1135	else
1136	return true;
1137	}
1138
1139	/**
1140	* ab8500_charger_set_current() - set charger current
1141	* @di: pointer to the ab8500_charger structure
1142	* @ich_ua: charger current, in uA
1143	* @reg: select what charger register to set
1144	*
1145	* Set charger current.
1146	* There is no state machine in the AB to step up/down the charger
1147	* current to avoid dips and spikes on MAIN, VBUS and VBAT when
1148	* charging is started. Instead we need to implement
1149	* this charger current step-up/down here.
1150	* Returns error code in case of failure else 0(on success)
1151	*/
1152	static int ab8500_charger_set_current(struct ab8500_charger *di,
1153	int ich_ua, int reg)
1154	{
1155	int ret = 0;
1156	int curr_index, prev_curr_index, shift_value, i;
1157	u8 reg_value;
1158	u32 step_udelay;
1159	bool no_stepping = false;
1160
1161	atomic_inc(v: &di->current_stepping_sessions);
1162
1163	ret = abx500_get_register_interruptible(dev: di->dev, AB8500_CHARGER,
1164	reg, value: &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, curr_ua: 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, curr_ua: 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, curr_ua: 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(dev: di->dev, AB8500_CHARGER,
1225	reg, value: (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(dev: di->dev,
1233	AB8500_CHARGER, reg, value: (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(min: step_udelay, max: 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(dev: di->dev,
1247	AB8500_CHARGER, reg, value: (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(min: step_udelay, max: step_udelay * 2);
1254
1255	allow = ab8500_charger_check_continue_stepping(di, reg);
1256	}
1257	}
1258
1259	exit_set_current:
1260	atomic_dec(v: &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, ich_ua: min_value,
1304	AB8500_USBCH_IPT_CRNTLVL_REG);
1305	mutex_unlock(lock: &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_ua: 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_ua: 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(dev: di->dev, AB8500_CHARGER,
1355	AB8500_LED_INDICATOR_PWM_CTRL,
1356	value: (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(dev: 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(dev: 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(regulator: 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(voltage_uv: vset_uv);
1435	curr_index = ab8500_current_to_regval(di, curr_ua: iset_ua);
1436	input_curr_index = ab8500_current_to_regval(di,
1437	curr_ua: 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(dev: di->dev, AB8500_CHARGER,
1447	AB8500_CH_VOLT_LVL_REG, value: (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	ich_in_ua: 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, ich_out_ua: 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(dev: 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, on: 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(ab: 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(wq: di->charger_wq,
1502	dwork: &di->kick_wd_work,
1503	delay: 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(dev: 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, ich_out_ua: 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(dev: di->dev,
1531	AB8500_CHARGER,
1532	AB8500_MCH_CTRL1, value: 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, on: 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(regulator: 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, psy: 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(regulator: 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(voltage_uv: vset_uv);
1611	curr_index = ab8500_current_to_regval(di, curr_ua: 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(dev: di->dev, AB8500_CHARGER,
1624	AB8500_CH_VOLT_LVL_REG, value: (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(dev: 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, on: 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	ich_in_ua: 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(wq: di->charger_wq, dwork: &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(dev: di->dev,
1673	AB8500_CHARGER,
1674	AB8500_USBCH_CTRL1_REG, value: 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, on: 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, ich_in_ua: 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, ich_out_ua: 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(regulator: 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(dwork: &di->check_vbat_work);
1712
1713	}
1714	ab8500_power_supply_changed(di, psy: di->usb_chg.psy);
1715
1716	return ret;
1717	}
1718
1719	/**
1720	* ab8500_charger_usb_check_enable() - enable usb charging
1721	* @charger: pointer to the ux500_charger structure
1722	* @vset_uv: charging voltage in microvolt
1723	* @iset_ua: charger output current in microampere
1724	*
1725	* Check if the VBUS charger has been disconnected and reconnected without
1726	* AB8500 rising an interrupt. Returns 0 on success.
1727	*/
1728	static int ab8500_charger_usb_check_enable(struct ux500_charger *charger,
1729	int vset_uv, int iset_ua)
1730	{
1731	u8 usbch_ctrl1 = 0;
1732	int ret = 0;
1733
1734	struct ab8500_charger *di = to_ab8500_charger_usb_device_info(charger);
1735
1736	if (!di->usb.charger_connected)
1737	return ret;
1738
1739	ret = abx500_get_register_interruptible(dev: di->dev, AB8500_CHARGER,
1740	AB8500_USBCH_CTRL1_REG, value: &usbch_ctrl1);
1741	if (ret < 0) {
1742	dev_err(di->dev, "ab8500 read failed %d\n", __LINE__);
1743	return ret;
1744	}
1745	dev_dbg(di->dev, "USB charger ctrl: 0x%02x\n", usbch_ctrl1);
1746
1747	if (!(usbch_ctrl1 & USB_CH_ENA)) {
1748	dev_info(di->dev, "Charging has been disabled abnormally and will be re-enabled\n");
1749
1750	ret = abx500_mask_and_set_register_interruptible(dev: di->dev,
1751	AB8500_CHARGER, AB8500_CHARGER_CTRL,
1752	DROP_COUNT_RESET, DROP_COUNT_RESET);
1753	if (ret < 0) {
1754	dev_err(di->dev, "ab8500 write failed %d\n", __LINE__);
1755	return ret;
1756	}
1757
1758	ret = ab8500_charger_usb_en(charger: &di->usb_chg, enable: true, vset_uv, ich_out_ua: iset_ua);
1759	if (ret < 0) {
1760	dev_err(di->dev, "Failed to enable VBUS charger %d\n",
1761	__LINE__);
1762	return ret;
1763	}
1764	}
1765	return ret;
1766	}
1767
1768	/**
1769	* ab8500_charger_ac_check_enable() - enable usb charging
1770	* @charger: pointer to the ux500_charger structure
1771	* @vset_uv: charging voltage in microvolt
1772	* @iset_ua: charger output current in micrompere
1773	*
1774	* Check if the AC charger has been disconnected and reconnected without
1775	* AB8500 rising an interrupt. Returns 0 on success.
1776	*/
1777	static int ab8500_charger_ac_check_enable(struct ux500_charger *charger,
1778	int vset_uv, int iset_ua)
1779	{
1780	u8 mainch_ctrl1 = 0;
1781	int ret = 0;
1782
1783	struct ab8500_charger *di = to_ab8500_charger_ac_device_info(charger);
1784
1785	if (!di->ac.charger_connected)
1786	return ret;
1787
1788	ret = abx500_get_register_interruptible(dev: di->dev, AB8500_CHARGER,
1789	AB8500_MCH_CTRL1, value: &mainch_ctrl1);
1790	if (ret < 0) {
1791	dev_err(di->dev, "ab8500 read failed %d\n", __LINE__);
1792	return ret;
1793	}
1794	dev_dbg(di->dev, "AC charger ctrl: 0x%02x\n", mainch_ctrl1);
1795
1796	if (!(mainch_ctrl1 & MAIN_CH_ENA)) {
1797	dev_info(di->dev, "Charging has been disabled abnormally and will be re-enabled\n");
1798
1799	ret = abx500_mask_and_set_register_interruptible(dev: di->dev,
1800	AB8500_CHARGER, AB8500_CHARGER_CTRL,
1801	DROP_COUNT_RESET, DROP_COUNT_RESET);
1802
1803	if (ret < 0) {
1804	dev_err(di->dev, "ab8500 write failed %d\n", __LINE__);
1805	return ret;
1806	}
1807
1808	ret = ab8500_charger_ac_en(charger: &di->usb_chg, enable: true, vset_uv, iset_ua);
1809	if (ret < 0) {
1810	dev_err(di->dev, "failed to enable AC charger %d\n",
1811	__LINE__);
1812	return ret;
1813	}
1814	}
1815	return ret;
1816	}
1817
1818	/**
1819	* ab8500_charger_watchdog_kick() - kick charger watchdog
1820	* @di: pointer to the ab8500_charger structure
1821	*
1822	* Kick charger watchdog
1823	* Returns error code in case of failure else 0(on success)
1824	*/
1825	static int ab8500_charger_watchdog_kick(struct ux500_charger *charger)
1826	{
1827	int ret;
1828	struct ab8500_charger *di;
1829
1830	if (charger->psy->desc->type == POWER_SUPPLY_TYPE_MAINS)
1831	di = to_ab8500_charger_ac_device_info(charger);
1832	else if (charger->psy->desc->type == POWER_SUPPLY_TYPE_USB)
1833	di = to_ab8500_charger_usb_device_info(charger);
1834	else
1835	return -ENXIO;
1836
1837	ret = abx500_set_register_interruptible(dev: di->dev, AB8500_CHARGER,
1838	AB8500_CHARG_WD_CTRL, CHARG_WD_KICK);
1839	if (ret)
1840	dev_err(di->dev, "Failed to kick WD!\n");
1841
1842	return ret;
1843	}
1844
1845	/**
1846	* ab8500_charger_update_charger_current() - update charger current
1847	* @charger: pointer to the ab8500_charger structure
1848	* @ich_out_ua: desired output current in microampere
1849	*
1850	* Update the charger output current for the specified charger
1851	* Returns error code in case of failure else 0(on success)
1852	*/
1853	static int ab8500_charger_update_charger_current(struct ux500_charger *charger,
1854	int ich_out_ua)
1855	{
1856	int ret;
1857	struct ab8500_charger *di;
1858
1859	if (charger->psy->desc->type == POWER_SUPPLY_TYPE_MAINS)
1860	di = to_ab8500_charger_ac_device_info(charger);
1861	else if (charger->psy->desc->type == POWER_SUPPLY_TYPE_USB)
1862	di = to_ab8500_charger_usb_device_info(charger);
1863	else
1864	return -ENXIO;
1865
1866	ret = ab8500_charger_set_output_curr(di, ich_out_ua);
1867	if (ret) {
1868	dev_err(di->dev, "%s "
1869	"Failed to set ChOutputCurentLevel\n",
1870	__func__);
1871	return ret;
1872	}
1873
1874	/* Reset the main and usb drop input current measurement counter */
1875	ret = abx500_set_register_interruptible(dev: di->dev, AB8500_CHARGER,
1876	AB8500_CHARGER_CTRL, DROP_COUNT_RESET);
1877	if (ret) {
1878	dev_err(di->dev, "%s write failed\n", __func__);
1879	return ret;
1880	}
1881
1882	return ret;
1883	}
1884
1885	static int ab8500_charger_get_ext_psy_data(struct device *dev, void *data)
1886	{
1887	struct power_supply *psy;
1888	struct power_supply *ext = dev_get_drvdata(dev);
1889	const char **supplicants = (const char **)ext->supplied_to;
1890	struct ab8500_charger *di;
1891	union power_supply_propval ret;
1892	int j;
1893	struct ux500_charger *usb_chg;
1894
1895	usb_chg = (struct ux500_charger *)data;
1896	psy = usb_chg->psy;
1897
1898	di = to_ab8500_charger_usb_device_info(usb_chg);
1899
1900	/*
1901	* For all psy where the driver name appears in any supplied_to
1902	* in practice what we will find will always be "ab8500_fg" as
1903	* the fuel gauge is responsible of keeping track of VBAT.
1904	*/
1905	j = match_string(array: supplicants, n: ext->num_supplicants, string: psy->desc->name);
1906	if (j < 0)
1907	return 0;
1908
1909	/* Go through all properties for the psy */
1910	for (j = 0; j < ext->desc->num_properties; j++) {
1911	enum power_supply_property prop;
1912	prop = ext->desc->properties[j];
1913
1914	if (power_supply_get_property(psy: ext, psp: prop, val: &ret))
1915	continue;
1916
1917	switch (prop) {
1918	case POWER_SUPPLY_PROP_VOLTAGE_NOW:
1919	switch (ext->desc->type) {
1920	case POWER_SUPPLY_TYPE_BATTERY:
1921	/* This will always be "ab8500_fg" */
1922	dev_dbg(di->dev, "get VBAT from %s\n",
1923	dev_name(&ext->dev));
1924	di->vbat = ret.intval;
1925	break;
1926	default:
1927	break;
1928	}
1929	break;
1930	default:
1931	break;
1932	}
1933	}
1934	return 0;
1935	}
1936
1937	/**
1938	* ab8500_charger_check_vbat_work() - keep vbus current within spec
1939	* @work pointer to the work_struct structure
1940	*
1941	* Due to a asic bug it is necessary to lower the input current to the vbus
1942	* charger when charging with at some specific levels. This issue is only valid
1943	* for below a certain battery voltage. This function makes sure that
1944	* the allowed current limit isn't exceeded.
1945	*/
1946	static void ab8500_charger_check_vbat_work(struct work_struct *work)
1947	{
1948	int t = 10;
1949	struct ab8500_charger *di = container_of(work,
1950	struct ab8500_charger, check_vbat_work.work);
1951
1952	power_supply_for_each_device(data: &di->usb_chg, fn: ab8500_charger_get_ext_psy_data);
1953
1954	/* First run old_vbat is 0. */
1955	if (di->old_vbat == 0)
1956	di->old_vbat = di->vbat;
1957
1958	if (!((di->old_vbat <= VBAT_TRESH_IP_CUR_RED &&
1959	di->vbat <= VBAT_TRESH_IP_CUR_RED) ||
1960	(di->old_vbat > VBAT_TRESH_IP_CUR_RED &&
1961	di->vbat > VBAT_TRESH_IP_CUR_RED))) {
1962
1963	dev_dbg(di->dev, "Vbat did cross threshold, curr: %d, new: %d,"
1964	" old: %d\n", di->max_usb_in_curr.usb_type_max_ua,
1965	di->vbat, di->old_vbat);
1966	ab8500_charger_set_vbus_in_curr(di,
1967	ich_in_ua: di->max_usb_in_curr.usb_type_max_ua);
1968	power_supply_changed(psy: di->usb_chg.psy);
1969	}
1970
1971	di->old_vbat = di->vbat;
1972
1973	/*
1974	* No need to check the battery voltage every second when not close to
1975	* the threshold.
1976	*/
1977	if (di->vbat < (VBAT_TRESH_IP_CUR_RED + 100000) &&
1978	(di->vbat > (VBAT_TRESH_IP_CUR_RED - 100000)))
1979	t = 1;
1980
1981	queue_delayed_work(wq: di->charger_wq, dwork: &di->check_vbat_work, delay: t * HZ);
1982	}
1983
1984	/**
1985	* ab8500_charger_check_hw_failure_work() - check main charger failure
1986	* @work: pointer to the work_struct structure
1987	*
1988	* Work queue function for checking the main charger status
1989	*/
1990	static void ab8500_charger_check_hw_failure_work(struct work_struct *work)
1991	{
1992	int ret;
1993	u8 reg_value;
1994
1995	struct ab8500_charger *di = container_of(work,
1996	struct ab8500_charger, check_hw_failure_work.work);
1997
1998	/* Check if the status bits for HW failure is still active */
1999	if (di->flags.mainextchnotok) {
2000	ret = abx500_get_register_interruptible(dev: di->dev,
2001	AB8500_CHARGER, AB8500_CH_STATUS2_REG, value: &reg_value);
2002	if (ret < 0) {
2003	dev_err(di->dev, "%s ab8500 read failed\n", __func__);
2004	return;
2005	}
2006	if (!(reg_value & MAIN_CH_NOK)) {
2007	di->flags.mainextchnotok = false;
2008	ab8500_power_supply_changed(di, psy: di->ac_chg.psy);
2009	}
2010	}
2011	if (di->flags.vbus_ovv) {
2012	ret = abx500_get_register_interruptible(dev: di->dev,
2013	AB8500_CHARGER, AB8500_CH_USBCH_STAT2_REG,
2014	value: &reg_value);
2015	if (ret < 0) {
2016	dev_err(di->dev, "%s ab8500 read failed\n", __func__);
2017	return;
2018	}
2019	if (!(reg_value & VBUS_OVV_TH)) {
2020	di->flags.vbus_ovv = false;
2021	ab8500_power_supply_changed(di, psy: di->usb_chg.psy);
2022	}
2023	}
2024	/* If we still have a failure, schedule a new check */
2025	if (di->flags.mainextchnotok || di->flags.vbus_ovv) {
2026	queue_delayed_work(wq: di->charger_wq,
2027	dwork: &di->check_hw_failure_work, delay: round_jiffies(HZ));
2028	}
2029	}
2030
2031	/**
2032	* ab8500_charger_kick_watchdog_work() - kick the watchdog
2033	* @work: pointer to the work_struct structure
2034	*
2035	* Work queue function for kicking the charger watchdog.
2036	*
2037	* For ABB revision 1.0 and 1.1 there is a bug in the watchdog
2038	* logic. That means we have to continuously kick the charger
2039	* watchdog even when no charger is connected. This is only
2040	* valid once the AC charger has been enabled. This is
2041	* a bug that is not handled by the algorithm and the
2042	* watchdog have to be kicked by the charger driver
2043	* when the AC charger is disabled
2044	*/
2045	static void ab8500_charger_kick_watchdog_work(struct work_struct *work)
2046	{
2047	int ret;
2048
2049	struct ab8500_charger *di = container_of(work,
2050	struct ab8500_charger, kick_wd_work.work);
2051
2052	ret = abx500_set_register_interruptible(dev: di->dev, AB8500_CHARGER,
2053	AB8500_CHARG_WD_CTRL, CHARG_WD_KICK);
2054	if (ret)
2055	dev_err(di->dev, "Failed to kick WD!\n");
2056
2057	/* Schedule a new watchdog kick */
2058	queue_delayed_work(wq: di->charger_wq,
2059	dwork: &di->kick_wd_work, delay: round_jiffies(WD_KICK_INTERVAL));
2060	}
2061
2062	/**
2063	* ab8500_charger_ac_work() - work to get and set main charger status
2064	* @work: pointer to the work_struct structure
2065	*
2066	* Work queue function for checking the main charger status
2067	*/
2068	static void ab8500_charger_ac_work(struct work_struct *work)
2069	{
2070	int ret;
2071
2072	struct ab8500_charger *di = container_of(work,
2073	struct ab8500_charger, ac_work);
2074
2075	/*
2076	* Since we can't be sure that the events are received
2077	* synchronously, we have the check if the main charger is
2078	* connected by reading the status register
2079	*/
2080	ret = ab8500_charger_detect_chargers(di, probe: false);
2081	if (ret < 0)
2082	return;
2083
2084	if (ret & AC_PW_CONN) {
2085	di->ac.charger_connected = 1;
2086	di->ac_conn = true;
2087	} else {
2088	di->ac.charger_connected = 0;
2089	}
2090
2091	ab8500_power_supply_changed(di, psy: di->ac_chg.psy);
2092	sysfs_notify(kobj: &di->ac_chg.psy->dev.kobj, NULL, attr: "present");
2093	}
2094
2095	static void ab8500_charger_usb_attached_work(struct work_struct *work)
2096	{
2097	struct ab8500_charger *di = container_of(work,
2098	struct ab8500_charger,
2099	usb_charger_attached_work.work);
2100	int usbch = (USB_CH_VBUSDROP | USB_CH_VBUSDETDBNC);
2101	int ret, i;
2102	u8 statval;
2103
2104	for (i = 0; i < 10; i++) {
2105	ret = abx500_get_register_interruptible(dev: di->dev,
2106	AB8500_CHARGER,
2107	AB8500_CH_USBCH_STAT1_REG,
2108	value: &statval);
2109	if (ret < 0) {
2110	dev_err(di->dev, "ab8500 read failed %d\n", __LINE__);
2111	goto reschedule;
2112	}
2113	if ((statval & usbch) != usbch)
2114	goto reschedule;
2115
2116	msleep(CHARGER_STATUS_POLL);
2117	}
2118
2119	ab8500_charger_usb_en(charger: &di->usb_chg, enable: 0, vset_uv: 0, ich_out_ua: 0);
2120
2121	mutex_lock(&di->charger_attached_mutex);
2122	mutex_unlock(lock: &di->charger_attached_mutex);
2123
2124	return;
2125
2126	reschedule:
2127	queue_delayed_work(wq: di->charger_wq,
2128	dwork: &di->usb_charger_attached_work,
2129	HZ);
2130	}
2131
2132	static void ab8500_charger_ac_attached_work(struct work_struct *work)
2133	{
2134
2135	struct ab8500_charger *di = container_of(work,
2136	struct ab8500_charger,
2137	ac_charger_attached_work.work);
2138	int mainch = (MAIN_CH_STATUS2_MAINCHGDROP |
2139	MAIN_CH_STATUS2_MAINCHARGERDETDBNC);
2140	int ret, i;
2141	u8 statval;
2142
2143	for (i = 0; i < 10; i++) {
2144	ret = abx500_get_register_interruptible(dev: di->dev,
2145	AB8500_CHARGER,
2146	AB8500_CH_STATUS2_REG,
2147	value: &statval);
2148	if (ret < 0) {
2149	dev_err(di->dev, "ab8500 read failed %d\n", __LINE__);
2150	goto reschedule;
2151	}
2152
2153	if ((statval & mainch) != mainch)
2154	goto reschedule;
2155
2156	msleep(CHARGER_STATUS_POLL);
2157	}
2158
2159	ab8500_charger_ac_en(charger: &di->ac_chg, enable: 0, vset_uv: 0, iset_ua: 0);
2160	queue_work(wq: di->charger_wq, work: &di->ac_work);
2161
2162	mutex_lock(&di->charger_attached_mutex);
2163	mutex_unlock(lock: &di->charger_attached_mutex);
2164
2165	return;
2166
2167	reschedule:
2168	queue_delayed_work(wq: di->charger_wq,
2169	dwork: &di->ac_charger_attached_work,
2170	HZ);
2171	}
2172
2173	/**
2174	* ab8500_charger_detect_usb_type_work() - work to detect USB type
2175	* @work: Pointer to the work_struct structure
2176	*
2177	* Detect the type of USB plugged
2178	*/
2179	static void ab8500_charger_detect_usb_type_work(struct work_struct *work)
2180	{
2181	int ret;
2182
2183	struct ab8500_charger *di = container_of(work,
2184	struct ab8500_charger, detect_usb_type_work);
2185
2186	/*
2187	* Since we can't be sure that the events are received
2188	* synchronously, we have the check if is
2189	* connected by reading the status register
2190	*/
2191	ret = ab8500_charger_detect_chargers(di, probe: false);
2192	if (ret < 0)
2193	return;
2194
2195	if (!(ret & USB_PW_CONN)) {
2196	dev_dbg(di->dev, "%s di->vbus_detected = false\n", __func__);
2197	di->vbus_detected = false;
2198	ab8500_charger_set_usb_connected(di, connected: false);
2199	ab8500_power_supply_changed(di, psy: di->usb_chg.psy);
2200	} else {
2201	dev_dbg(di->dev, "%s di->vbus_detected = true\n", __func__);
2202	di->vbus_detected = true;
2203
2204	if (is_ab8500_1p1_or_earlier(ab: di->parent)) {
2205	ret = ab8500_charger_detect_usb_type(di);
2206	if (!ret) {
2207	ab8500_charger_set_usb_connected(di, connected: true);
2208	ab8500_power_supply_changed(di,
2209	psy: di->usb_chg.psy);
2210	}
2211	} else {
2212	/*
2213	* For ABB cut2.0 and onwards we have an IRQ,
2214	* USB_LINK_STATUS that will be triggered when the USB
2215	* link status changes. The exception is USB connected
2216	* during startup. Then we don't get a
2217	* USB_LINK_STATUS IRQ
2218	*/
2219	if (di->vbus_detected_start) {
2220	di->vbus_detected_start = false;
2221	ret = ab8500_charger_detect_usb_type(di);
2222	if (!ret) {
2223	ab8500_charger_set_usb_connected(di,
2224	connected: true);
2225	ab8500_power_supply_changed(di,
2226	psy: di->usb_chg.psy);
2227	}
2228	}
2229	}
2230	}
2231	}
2232
2233	/**
2234	* ab8500_charger_usb_link_attach_work() - work to detect USB type
2235	* @work: pointer to the work_struct structure
2236	*
2237	* Detect the type of USB plugged
2238	*/
2239	static void ab8500_charger_usb_link_attach_work(struct work_struct *work)
2240	{
2241	struct ab8500_charger *di =
2242	container_of(work, struct ab8500_charger, attach_work.work);
2243	int ret;
2244
2245	/* Update maximum input current if USB enumeration is not detected */
2246	if (!di->usb.charger_online) {
2247	ret = ab8500_charger_set_vbus_in_curr(di,
2248	ich_in_ua: di->max_usb_in_curr.usb_type_max_ua);
2249	if (ret)
2250	return;
2251	}
2252
2253	ab8500_charger_set_usb_connected(di, connected: true);
2254	ab8500_power_supply_changed(di, psy: di->usb_chg.psy);
2255	}
2256
2257	/**
2258	* ab8500_charger_usb_link_status_work() - work to detect USB type
2259	* @work: pointer to the work_struct structure
2260	*
2261	* Detect the type of USB plugged
2262	*/
2263	static void ab8500_charger_usb_link_status_work(struct work_struct *work)
2264	{
2265	int detected_chargers;
2266	int ret;
2267	u8 val;
2268	u8 link_status;
2269
2270	struct ab8500_charger *di = container_of(work,
2271	struct ab8500_charger, usb_link_status_work);
2272
2273	/*
2274	* Since we can't be sure that the events are received
2275	* synchronously, we have the check if is
2276	* connected by reading the status register
2277	*/
2278	detected_chargers = ab8500_charger_detect_chargers(di, probe: false);
2279	if (detected_chargers < 0)
2280	return;
2281
2282	/*
2283	* Some chargers that breaks the USB spec is
2284	* identified as invalid by AB8500 and it refuse
2285	* to start the charging process. but by jumping
2286	* through a few hoops it can be forced to start.
2287	*/
2288	if (is_ab8500(ab: di->parent))
2289	ret = abx500_get_register_interruptible(dev: di->dev, AB8500_USB,
2290	AB8500_USB_LINE_STAT_REG, value: &val);
2291	else
2292	ret = abx500_get_register_interruptible(dev: di->dev, AB8500_USB,
2293	AB8500_USB_LINK1_STAT_REG, value: &val);
2294
2295	if (ret >= 0)
2296	dev_dbg(di->dev, "UsbLineStatus register = 0x%02x\n", val);
2297	else
2298	dev_dbg(di->dev, "Error reading USB link status\n");
2299
2300	if (is_ab8500(ab: di->parent))
2301	link_status = AB8500_USB_LINK_STATUS;
2302	else
2303	link_status = AB8505_USB_LINK_STATUS;
2304
2305	if (detected_chargers & USB_PW_CONN) {
2306	if (((val & link_status) >> USB_LINK_STATUS_SHIFT) ==
2307	USB_STAT_NOT_VALID_LINK &&
2308	di->invalid_charger_detect_state == 0) {
2309	dev_dbg(di->dev,
2310	"Invalid charger detected, state= 0\n");
2311	/*Enable charger*/
2312	abx500_mask_and_set_register_interruptible(dev: di->dev,
2313	AB8500_CHARGER, AB8500_USBCH_CTRL1_REG,
2314	USB_CH_ENA, USB_CH_ENA);
2315	/*Enable charger detection*/
2316	abx500_mask_and_set_register_interruptible(dev: di->dev,
2317	AB8500_USB, AB8500_USB_LINE_CTRL2_REG,
2318	USB_CH_DET, USB_CH_DET);
2319	di->invalid_charger_detect_state = 1;
2320	/*exit and wait for new link status interrupt.*/
2321	return;
2322
2323	}
2324	if (di->invalid_charger_detect_state == 1) {
2325	dev_dbg(di->dev,
2326	"Invalid charger detected, state= 1\n");
2327	/*Stop charger detection*/
2328	abx500_mask_and_set_register_interruptible(dev: di->dev,
2329	AB8500_USB, AB8500_USB_LINE_CTRL2_REG,
2330	USB_CH_DET, bitvalues: 0x00);
2331	/*Check link status*/
2332	if (is_ab8500(ab: di->parent))
2333	ret = abx500_get_register_interruptible(dev: di->dev,
2334	AB8500_USB, AB8500_USB_LINE_STAT_REG,
2335	value: &val);
2336	else
2337	ret = abx500_get_register_interruptible(dev: di->dev,
2338	AB8500_USB, AB8500_USB_LINK1_STAT_REG,
2339	value: &val);
2340
2341	dev_dbg(di->dev, "USB link status= 0x%02x\n",
2342	(val & link_status) >> USB_LINK_STATUS_SHIFT);
2343	di->invalid_charger_detect_state = 2;
2344	}
2345	} else {
2346	di->invalid_charger_detect_state = 0;
2347	}
2348
2349	if (!(detected_chargers & USB_PW_CONN)) {
2350	di->vbus_detected = false;
2351	ab8500_charger_set_usb_connected(di, connected: false);
2352	ab8500_power_supply_changed(di, psy: di->usb_chg.psy);
2353	return;
2354	}
2355
2356	dev_dbg(di->dev,"%s di->vbus_detected = true\n",__func__);
2357	di->vbus_detected = true;
2358	ret = ab8500_charger_read_usb_type(di);
2359	if (ret) {
2360	if (ret == -ENXIO) {
2361	/* No valid charger type detected */
2362	ab8500_charger_set_usb_connected(di, connected: false);
2363	ab8500_power_supply_changed(di, psy: di->usb_chg.psy);
2364	}
2365	return;
2366	}
2367
2368	if (di->usb_device_is_unrecognised) {
2369	dev_dbg(di->dev,
2370	"Potential Legacy Charger device. "
2371	"Delay work for %d msec for USB enum "
2372	"to finish",
2373	WAIT_ACA_RID_ENUMERATION);
2374	queue_delayed_work(wq: di->charger_wq,
2375	dwork: &di->attach_work,
2376	delay: msecs_to_jiffies(WAIT_ACA_RID_ENUMERATION));
2377	} else if (di->is_aca_rid == 1) {
2378	/* Only wait once */
2379	di->is_aca_rid++;
2380	dev_dbg(di->dev,
2381	"%s Wait %d msec for USB enum to finish",
2382	__func__, WAIT_ACA_RID_ENUMERATION);
2383	queue_delayed_work(wq: di->charger_wq,
2384	dwork: &di->attach_work,
2385	delay: msecs_to_jiffies(WAIT_ACA_RID_ENUMERATION));
2386	} else {
2387	queue_delayed_work(wq: di->charger_wq,
2388	dwork: &di->attach_work,
2389	delay: 0);
2390	}
2391	}
2392
2393	static void ab8500_charger_usb_state_changed_work(struct work_struct *work)
2394	{
2395	int ret;
2396	unsigned long flags;
2397
2398	struct ab8500_charger *di = container_of(work,
2399	struct ab8500_charger, usb_state_changed_work.work);
2400
2401	if (!di->vbus_detected) {
2402	dev_dbg(di->dev,
2403	"%s !di->vbus_detected\n",
2404	__func__);
2405	return;
2406	}
2407
2408	spin_lock_irqsave(&di->usb_state.usb_lock, flags);
2409	di->usb_state.state = di->usb_state.state_tmp;
2410	di->usb_state.usb_current_ua = di->usb_state.usb_current_tmp_ua;
2411	spin_unlock_irqrestore(lock: &di->usb_state.usb_lock, flags);
2412
2413	dev_dbg(di->dev, "%s USB state: 0x%02x uA: %d\n",
2414	__func__, di->usb_state.state, di->usb_state.usb_current_ua);
2415
2416	switch (di->usb_state.state) {
2417	case AB8500_BM_USB_STATE_RESET_HS:
2418	case AB8500_BM_USB_STATE_RESET_FS:
2419	case AB8500_BM_USB_STATE_SUSPEND:
2420	case AB8500_BM_USB_STATE_MAX:
2421	ab8500_charger_set_usb_connected(di, connected: false);
2422	ab8500_power_supply_changed(di, psy: di->usb_chg.psy);
2423	break;
2424
2425	case AB8500_BM_USB_STATE_RESUME:
2426	/*
2427	* when suspend->resume there should be delay
2428	* of 1sec for enabling charging
2429	*/
2430	msleep(msecs: 1000);
2431	fallthrough;
2432	case AB8500_BM_USB_STATE_CONFIGURED:
2433	/*
2434	* USB is configured, enable charging with the charging
2435	* input current obtained from USB driver
2436	*/
2437	if (!ab8500_charger_get_usb_cur(di)) {
2438	/* Update maximum input current */
2439	ret = ab8500_charger_set_vbus_in_curr(di,
2440	ich_in_ua: di->max_usb_in_curr.usb_type_max_ua);
2441	if (ret)
2442	return;
2443
2444	ab8500_charger_set_usb_connected(di, connected: true);
2445	ab8500_power_supply_changed(di, psy: di->usb_chg.psy);
2446	}
2447	break;
2448
2449	default:
2450	break;
2451	}
2452	}
2453
2454	/**
2455	* ab8500_charger_check_usbchargernotok_work() - check USB chg not ok status
2456	* @work: pointer to the work_struct structure
2457	*
2458	* Work queue function for checking the USB charger Not OK status
2459	*/
2460	static void ab8500_charger_check_usbchargernotok_work(struct work_struct *work)
2461	{
2462	int ret;
2463	u8 reg_value;
2464	bool prev_status;
2465
2466	struct ab8500_charger *di = container_of(work,
2467	struct ab8500_charger, check_usbchgnotok_work.work);
2468
2469	/* Check if the status bit for usbchargernotok is still active */
2470	ret = abx500_get_register_interruptible(dev: di->dev,
2471	AB8500_CHARGER, AB8500_CH_USBCH_STAT2_REG, value: &reg_value);
2472	if (ret < 0) {
2473	dev_err(di->dev, "%s ab8500 read failed\n", __func__);
2474	return;
2475	}
2476	prev_status = di->flags.usbchargernotok;
2477
2478	if (reg_value & VBUS_CH_NOK) {
2479	di->flags.usbchargernotok = true;
2480	/* Check again in 1sec */
2481	queue_delayed_work(wq: di->charger_wq,
2482	dwork: &di->check_usbchgnotok_work, HZ);
2483	} else {
2484	di->flags.usbchargernotok = false;
2485	di->flags.vbus_collapse = false;
2486	}
2487
2488	if (prev_status != di->flags.usbchargernotok)
2489	ab8500_power_supply_changed(di, psy: di->usb_chg.psy);
2490	}
2491
2492	/**
2493	* ab8500_charger_check_main_thermal_prot_work() - check main thermal status
2494	* @work: pointer to the work_struct structure
2495	*
2496	* Work queue function for checking the Main thermal prot status
2497	*/
2498	static void ab8500_charger_check_main_thermal_prot_work(
2499	struct work_struct *work)
2500	{
2501	int ret;
2502	u8 reg_value;
2503
2504	struct ab8500_charger *di = container_of(work,
2505	struct ab8500_charger, check_main_thermal_prot_work);
2506
2507	/* Check if the status bit for main_thermal_prot is still active */
2508	ret = abx500_get_register_interruptible(dev: di->dev,
2509	AB8500_CHARGER, AB8500_CH_STATUS2_REG, value: &reg_value);
2510	if (ret < 0) {
2511	dev_err(di->dev, "%s ab8500 read failed\n", __func__);
2512	return;
2513	}
2514	if (reg_value & MAIN_CH_TH_PROT)
2515	di->flags.main_thermal_prot = true;
2516	else
2517	di->flags.main_thermal_prot = false;
2518
2519	ab8500_power_supply_changed(di, psy: di->ac_chg.psy);
2520	}
2521
2522	/**
2523	* ab8500_charger_check_usb_thermal_prot_work() - check usb thermal status
2524	* @work: pointer to the work_struct structure
2525	*
2526	* Work queue function for checking the USB thermal prot status
2527	*/
2528	static void ab8500_charger_check_usb_thermal_prot_work(
2529	struct work_struct *work)
2530	{
2531	int ret;
2532	u8 reg_value;
2533
2534	struct ab8500_charger *di = container_of(work,
2535	struct ab8500_charger, check_usb_thermal_prot_work);
2536
2537	/* Check if the status bit for usb_thermal_prot is still active */
2538	ret = abx500_get_register_interruptible(dev: di->dev,
2539	AB8500_CHARGER, AB8500_CH_USBCH_STAT2_REG, value: &reg_value);
2540	if (ret < 0) {
2541	dev_err(di->dev, "%s ab8500 read failed\n", __func__);
2542	return;
2543	}
2544	if (reg_value & USB_CH_TH_PROT)
2545	di->flags.usb_thermal_prot = true;
2546	else
2547	di->flags.usb_thermal_prot = false;
2548
2549	ab8500_power_supply_changed(di, psy: di->usb_chg.psy);
2550	}
2551
2552	/**
2553	* ab8500_charger_mainchunplugdet_handler() - main charger unplugged
2554	* @irq: interrupt number
2555	* @_di: pointer to the ab8500_charger structure
2556	*
2557	* Returns IRQ status(IRQ_HANDLED)
2558	*/
2559	static irqreturn_t ab8500_charger_mainchunplugdet_handler(int irq, void *_di)
2560	{
2561	struct ab8500_charger *di = _di;
2562
2563	dev_dbg(di->dev, "Main charger unplugged\n");
2564	queue_work(wq: di->charger_wq, work: &di->ac_work);
2565
2566	cancel_delayed_work_sync(dwork: &di->ac_charger_attached_work);
2567	mutex_lock(&di->charger_attached_mutex);
2568	mutex_unlock(lock: &di->charger_attached_mutex);
2569
2570	return IRQ_HANDLED;
2571	}
2572
2573	/**
2574	* ab8500_charger_mainchplugdet_handler() - main charger plugged
2575	* @irq: interrupt number
2576	* @_di: pointer to the ab8500_charger structure
2577	*
2578	* Returns IRQ status(IRQ_HANDLED)
2579	*/
2580	static irqreturn_t ab8500_charger_mainchplugdet_handler(int irq, void *_di)
2581	{
2582	struct ab8500_charger *di = _di;
2583
2584	dev_dbg(di->dev, "Main charger plugged\n");
2585	queue_work(wq: di->charger_wq, work: &di->ac_work);
2586
2587	mutex_lock(&di->charger_attached_mutex);
2588	mutex_unlock(lock: &di->charger_attached_mutex);
2589
2590	if (is_ab8500(ab: di->parent))
2591	queue_delayed_work(wq: di->charger_wq,
2592	dwork: &di->ac_charger_attached_work,
2593	HZ);
2594	return IRQ_HANDLED;
2595	}
2596
2597	/**
2598	* ab8500_charger_mainextchnotok_handler() - main charger not ok
2599	* @irq: interrupt number
2600	* @_di: pointer to the ab8500_charger structure
2601	*
2602	* Returns IRQ status(IRQ_HANDLED)
2603	*/
2604	static irqreturn_t ab8500_charger_mainextchnotok_handler(int irq, void *_di)
2605	{
2606	struct ab8500_charger *di = _di;
2607
2608	dev_dbg(di->dev, "Main charger not ok\n");
2609	di->flags.mainextchnotok = true;
2610	ab8500_power_supply_changed(di, psy: di->ac_chg.psy);
2611
2612	/* Schedule a new HW failure check */
2613	queue_delayed_work(wq: di->charger_wq, dwork: &di->check_hw_failure_work, delay: 0);
2614
2615	return IRQ_HANDLED;
2616	}
2617
2618	/**
2619	* ab8500_charger_mainchthprotr_handler() - Die temp is above main charger
2620	* thermal protection threshold
2621	* @irq: interrupt number
2622	* @_di: pointer to the ab8500_charger structure
2623	*
2624	* Returns IRQ status(IRQ_HANDLED)
2625	*/
2626	static irqreturn_t ab8500_charger_mainchthprotr_handler(int irq, void *_di)
2627	{
2628	struct ab8500_charger *di = _di;
2629
2630	dev_dbg(di->dev,
2631	"Die temp above Main charger thermal protection threshold\n");
2632	queue_work(wq: di->charger_wq, work: &di->check_main_thermal_prot_work);
2633
2634	return IRQ_HANDLED;
2635	}
2636
2637	/**
2638	* ab8500_charger_mainchthprotf_handler() - Die temp is below main charger
2639	* thermal protection threshold
2640	* @irq: interrupt number
2641	* @_di: pointer to the ab8500_charger structure
2642	*
2643	* Returns IRQ status(IRQ_HANDLED)
2644	*/
2645	static irqreturn_t ab8500_charger_mainchthprotf_handler(int irq, void *_di)
2646	{
2647	struct ab8500_charger *di = _di;
2648
2649	dev_dbg(di->dev,
2650	"Die temp ok for Main charger thermal protection threshold\n");
2651	queue_work(wq: di->charger_wq, work: &di->check_main_thermal_prot_work);
2652
2653	return IRQ_HANDLED;
2654	}
2655
2656	static void ab8500_charger_vbus_drop_end_work(struct work_struct *work)
2657	{
2658	struct ab8500_charger *di = container_of(work,
2659	struct ab8500_charger, vbus_drop_end_work.work);
2660	int ret, curr_ua;
2661	u8 reg_value;
2662
2663	di->flags.vbus_drop_end = false;
2664
2665	/* Reset the drop counter */
2666	abx500_set_register_interruptible(dev: di->dev,
2667	AB8500_CHARGER, AB8500_CHARGER_CTRL, value: 0x01);
2668
2669	ret = abx500_get_register_interruptible(dev: di->dev, AB8500_CHARGER,
2670	AB8500_CH_USBCH_STAT2_REG, value: &reg_value);
2671	if (ret < 0) {
2672	dev_err(di->dev, "%s read failed\n", __func__);
2673	return;
2674	}
2675
2676	curr_ua = ab8500_charge_input_curr_map[
2677	reg_value >> AUTO_VBUS_IN_CURR_LIM_SHIFT];
2678
2679	if (di->max_usb_in_curr.calculated_max_ua != curr_ua) {
2680	/* USB source is collapsing */
2681	di->max_usb_in_curr.calculated_max_ua = curr_ua;
2682	dev_dbg(di->dev,
2683	"VBUS input current limiting to %d uA\n",
2684	di->max_usb_in_curr.calculated_max_ua);
2685	} else {
2686	/*
2687	* USB source can not give more than this amount.
2688	* Taking more will collapse the source.
2689	*/
2690	di->max_usb_in_curr.set_max_ua =
2691	di->max_usb_in_curr.calculated_max_ua;
2692	dev_dbg(di->dev,
2693	"VBUS input current limited to %d uA\n",
2694	di->max_usb_in_curr.set_max_ua);
2695	}
2696
2697	if (di->usb.charger_connected)
2698	ab8500_charger_set_vbus_in_curr(di,
2699	ich_in_ua: di->max_usb_in_curr.usb_type_max_ua);
2700	}
2701
2702	/**
2703	* ab8500_charger_vbusdetf_handler() - VBUS falling detected
2704	* @irq: interrupt number
2705	* @_di: pointer to the ab8500_charger structure
2706	*
2707	* Returns IRQ status(IRQ_HANDLED)
2708	*/
2709	static irqreturn_t ab8500_charger_vbusdetf_handler(int irq, void *_di)
2710	{
2711	struct ab8500_charger *di = _di;
2712
2713	di->vbus_detected = false;
2714	dev_dbg(di->dev, "VBUS falling detected\n");
2715	queue_work(wq: di->charger_wq, work: &di->detect_usb_type_work);
2716
2717	return IRQ_HANDLED;
2718	}
2719
2720	/**
2721	* ab8500_charger_vbusdetr_handler() - VBUS rising detected
2722	* @irq: interrupt number
2723	* @_di: pointer to the ab8500_charger structure
2724	*
2725	* Returns IRQ status(IRQ_HANDLED)
2726	*/
2727	static irqreturn_t ab8500_charger_vbusdetr_handler(int irq, void *_di)
2728	{
2729	struct ab8500_charger *di = _di;
2730
2731	di->vbus_detected = true;
2732	dev_dbg(di->dev, "VBUS rising detected\n");
2733
2734	queue_work(wq: di->charger_wq, work: &di->detect_usb_type_work);
2735
2736	return IRQ_HANDLED;
2737	}
2738
2739	/**
2740	* ab8500_charger_usblinkstatus_handler() - USB link status has changed
2741	* @irq: interrupt number
2742	* @_di: pointer to the ab8500_charger structure
2743	*
2744	* Returns IRQ status(IRQ_HANDLED)
2745	*/
2746	static irqreturn_t ab8500_charger_usblinkstatus_handler(int irq, void *_di)
2747	{
2748	struct ab8500_charger *di = _di;
2749
2750	dev_dbg(di->dev, "USB link status changed\n");
2751
2752	queue_work(wq: di->charger_wq, work: &di->usb_link_status_work);
2753
2754	return IRQ_HANDLED;
2755	}
2756
2757	/**
2758	* ab8500_charger_usbchthprotr_handler() - Die temp is above usb charger
2759	* thermal protection threshold
2760	* @irq: interrupt number
2761	* @_di: pointer to the ab8500_charger structure
2762	*
2763	* Returns IRQ status(IRQ_HANDLED)
2764	*/
2765	static irqreturn_t ab8500_charger_usbchthprotr_handler(int irq, void *_di)
2766	{
2767	struct ab8500_charger *di = _di;
2768
2769	dev_dbg(di->dev,
2770	"Die temp above USB charger thermal protection threshold\n");
2771	queue_work(wq: di->charger_wq, work: &di->check_usb_thermal_prot_work);
2772
2773	return IRQ_HANDLED;
2774	}
2775
2776	/**
2777	* ab8500_charger_usbchthprotf_handler() - Die temp is below usb charger
2778	* thermal protection threshold
2779	* @irq: interrupt number
2780	* @_di: pointer to the ab8500_charger structure
2781	*
2782	* Returns IRQ status(IRQ_HANDLED)
2783	*/
2784	static irqreturn_t ab8500_charger_usbchthprotf_handler(int irq, void *_di)
2785	{
2786	struct ab8500_charger *di = _di;
2787
2788	dev_dbg(di->dev,
2789	"Die temp ok for USB charger thermal protection threshold\n");
2790	queue_work(wq: di->charger_wq, work: &di->check_usb_thermal_prot_work);
2791
2792	return IRQ_HANDLED;
2793	}
2794
2795	/**
2796	* ab8500_charger_usbchargernotokr_handler() - USB charger not ok detected
2797	* @irq: interrupt number
2798	* @_di: pointer to the ab8500_charger structure
2799	*
2800	* Returns IRQ status(IRQ_HANDLED)
2801	*/
2802	static irqreturn_t ab8500_charger_usbchargernotokr_handler(int irq, void *_di)
2803	{
2804	struct ab8500_charger *di = _di;
2805
2806	dev_dbg(di->dev, "Not allowed USB charger detected\n");
2807	queue_delayed_work(wq: di->charger_wq, dwork: &di->check_usbchgnotok_work, delay: 0);
2808
2809	return IRQ_HANDLED;
2810	}
2811
2812	/**
2813	* ab8500_charger_chwdexp_handler() - Charger watchdog expired
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_chwdexp_handler(int irq, void *_di)
2820	{
2821	struct ab8500_charger *di = _di;
2822
2823	dev_dbg(di->dev, "Charger watchdog expired\n");
2824
2825	/*
2826	* The charger that was online when the watchdog expired
2827	* needs to be restarted for charging to start again
2828	*/
2829	if (di->ac.charger_online) {
2830	di->ac.wd_expired = true;
2831	ab8500_power_supply_changed(di, psy: di->ac_chg.psy);
2832	}
2833	if (di->usb.charger_online) {
2834	di->usb.wd_expired = true;
2835	ab8500_power_supply_changed(di, psy: di->usb_chg.psy);
2836	}
2837
2838	return IRQ_HANDLED;
2839	}
2840
2841	/**
2842	* ab8500_charger_vbuschdropend_handler() - VBUS drop removed
2843	* @irq: interrupt number
2844	* @_di: pointer to the ab8500_charger structure
2845	*
2846	* Returns IRQ status(IRQ_HANDLED)
2847	*/
2848	static irqreturn_t ab8500_charger_vbuschdropend_handler(int irq, void *_di)
2849	{
2850	struct ab8500_charger *di = _di;
2851
2852	dev_dbg(di->dev, "VBUS charger drop ended\n");
2853	di->flags.vbus_drop_end = true;
2854
2855	/*
2856	* VBUS might have dropped due to bad connection.
2857	* Schedule a new input limit set to the value SW requests.
2858	*/
2859	queue_delayed_work(wq: di->charger_wq, dwork: &di->vbus_drop_end_work,
2860	delay: round_jiffies(VBUS_IN_CURR_LIM_RETRY_SET_TIME * HZ));
2861
2862	return IRQ_HANDLED;
2863	}
2864
2865	/**
2866	* ab8500_charger_vbusovv_handler() - VBUS overvoltage detected
2867	* @irq: interrupt number
2868	* @_di: pointer to the ab8500_charger structure
2869	*
2870	* Returns IRQ status(IRQ_HANDLED)
2871	*/
2872	static irqreturn_t ab8500_charger_vbusovv_handler(int irq, void *_di)
2873	{
2874	struct ab8500_charger *di = _di;
2875
2876	dev_dbg(di->dev, "VBUS overvoltage detected\n");
2877	di->flags.vbus_ovv = true;
2878	ab8500_power_supply_changed(di, psy: di->usb_chg.psy);
2879
2880	/* Schedule a new HW failure check */
2881	queue_delayed_work(wq: di->charger_wq, dwork: &di->check_hw_failure_work, delay: 0);
2882
2883	return IRQ_HANDLED;
2884	}
2885
2886	/**
2887	* ab8500_charger_ac_get_property() - get the ac/mains properties
2888	* @psy: pointer to the power_supply structure
2889	* @psp: pointer to the power_supply_property structure
2890	* @val: pointer to the power_supply_propval union
2891	*
2892	* This function gets called when an application tries to get the ac/mains
2893	* properties by reading the sysfs files.
2894	* AC/Mains properties are online, present and voltage.
2895	* online: ac/mains charging is in progress or not
2896	* present: presence of the ac/mains
2897	* voltage: AC/Mains voltage
2898	* Returns error code in case of failure else 0(on success)
2899	*/
2900	static int ab8500_charger_ac_get_property(struct power_supply *psy,
2901	enum power_supply_property psp,
2902	union power_supply_propval *val)
2903	{
2904	struct ab8500_charger *di;
2905	int ret;
2906
2907	di = to_ab8500_charger_ac_device_info(psy_to_ux500_charger(psy));
2908
2909	switch (psp) {
2910	case POWER_SUPPLY_PROP_HEALTH:
2911	if (di->flags.mainextchnotok)
2912	val->intval = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
2913	else if (di->ac.wd_expired || di->usb.wd_expired)
2914	val->intval = POWER_SUPPLY_HEALTH_DEAD;
2915	else if (di->flags.main_thermal_prot)
2916	val->intval = POWER_SUPPLY_HEALTH_OVERHEAT;
2917	else
2918	val->intval = POWER_SUPPLY_HEALTH_GOOD;
2919	break;
2920	case POWER_SUPPLY_PROP_ONLINE:
2921	val->intval = di->ac.charger_online;
2922	break;
2923	case POWER_SUPPLY_PROP_PRESENT:
2924	val->intval = di->ac.charger_connected;
2925	break;
2926	case POWER_SUPPLY_PROP_VOLTAGE_NOW:
2927	ret = ab8500_charger_get_ac_voltage(di);
2928	if (ret >= 0)
2929	di->ac.charger_voltage_uv = ret;
2930	/* On error, use previous value */
2931	val->intval = di->ac.charger_voltage_uv;
2932	break;
2933	case POWER_SUPPLY_PROP_VOLTAGE_AVG:
2934	/*
2935	* This property is used to indicate when CV mode is entered
2936	* for the AC charger
2937	*/
2938	di->ac.cv_active = ab8500_charger_ac_cv(di);
2939	val->intval = di->ac.cv_active;
2940	break;
2941	case POWER_SUPPLY_PROP_CURRENT_NOW:
2942	ret = ab8500_charger_get_ac_current(di);
2943	if (ret >= 0)
2944	di->ac.charger_current_ua = ret;
2945	val->intval = di->ac.charger_current_ua;
2946	break;
2947	default:
2948	return -EINVAL;
2949	}
2950	return 0;
2951	}
2952
2953	/**
2954	* ab8500_charger_usb_get_property() - get the usb properties
2955	* @psy: pointer to the power_supply structure
2956	* @psp: pointer to the power_supply_property structure
2957	* @val: pointer to the power_supply_propval union
2958	*
2959	* This function gets called when an application tries to get the usb
2960	* properties by reading the sysfs files.
2961	* USB properties are online, present and voltage.
2962	* online: usb charging is in progress or not
2963	* present: presence of the usb
2964	* voltage: vbus voltage
2965	* Returns error code in case of failure else 0(on success)
2966	*/
2967	static int ab8500_charger_usb_get_property(struct power_supply *psy,
2968	enum power_supply_property psp,
2969	union power_supply_propval *val)
2970	{
2971	struct ab8500_charger *di;
2972	int ret;
2973
2974	di = to_ab8500_charger_usb_device_info(psy_to_ux500_charger(psy));
2975
2976	switch (psp) {
2977	case POWER_SUPPLY_PROP_HEALTH:
2978	if (di->flags.usbchargernotok)
2979	val->intval = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
2980	else if (di->ac.wd_expired || di->usb.wd_expired)
2981	val->intval = POWER_SUPPLY_HEALTH_DEAD;
2982	else if (di->flags.usb_thermal_prot)
2983	val->intval = POWER_SUPPLY_HEALTH_OVERHEAT;
2984	else if (di->flags.vbus_ovv)
2985	val->intval = POWER_SUPPLY_HEALTH_OVERVOLTAGE;
2986	else
2987	val->intval = POWER_SUPPLY_HEALTH_GOOD;
2988	break;
2989	case POWER_SUPPLY_PROP_ONLINE:
2990	val->intval = di->usb.charger_online;
2991	break;
2992	case POWER_SUPPLY_PROP_PRESENT:
2993	val->intval = di->usb.charger_connected;
2994	break;
2995	case POWER_SUPPLY_PROP_VOLTAGE_NOW:
2996	ret = ab8500_charger_get_vbus_voltage(di);
2997	if (ret >= 0)
2998	di->usb.charger_voltage_uv = ret;
2999	val->intval = di->usb.charger_voltage_uv;
3000	break;
3001	case POWER_SUPPLY_PROP_VOLTAGE_AVG:
3002	/*
3003	* This property is used to indicate when CV mode is entered
3004	* for the USB charger
3005	*/
3006	di->usb.cv_active = ab8500_charger_usb_cv(di);
3007	val->intval = di->usb.cv_active;
3008	break;
3009	case POWER_SUPPLY_PROP_CURRENT_NOW:
3010	ret = ab8500_charger_get_usb_current(di);
3011	if (ret >= 0)
3012	di->usb.charger_current_ua = ret;
3013	val->intval = di->usb.charger_current_ua;
3014	break;
3015	case POWER_SUPPLY_PROP_CURRENT_AVG:
3016	/*
3017	* This property is used to indicate when VBUS has collapsed
3018	* due to too high output current from the USB charger
3019	*/
3020	if (di->flags.vbus_collapse)
3021	val->intval = 1;
3022	else
3023	val->intval = 0;
3024	break;
3025	default:
3026	return -EINVAL;
3027	}
3028	return 0;
3029	}
3030
3031	/**
3032	* ab8500_charger_init_hw_registers() - Set up charger related registers
3033	* @di: pointer to the ab8500_charger structure
3034	*
3035	* Set up charger OVV, watchdog and maximum voltage registers as well as
3036	* charging of the backup battery
3037	*/
3038	static int ab8500_charger_init_hw_registers(struct ab8500_charger *di)
3039	{
3040	int ret = 0;
3041
3042	/* Setup maximum charger current and voltage for ABB cut2.0 */
3043	if (!is_ab8500_1p1_or_earlier(ab: di->parent)) {
3044	ret = abx500_set_register_interruptible(dev: di->dev,
3045	AB8500_CHARGER,
3046	AB8500_CH_VOLT_LVL_MAX_REG, CH_VOL_LVL_4P6);
3047	if (ret) {
3048	dev_err(di->dev,
3049	"failed to set CH_VOLT_LVL_MAX_REG\n");
3050	goto out;
3051	}
3052
3053	ret = abx500_set_register_interruptible(dev: di->dev,
3054	AB8500_CHARGER, AB8500_CH_OPT_CRNTLVL_MAX_REG,
3055	CH_OP_CUR_LVL_1P6);
3056	if (ret) {
3057	dev_err(di->dev,
3058	"failed to set CH_OPT_CRNTLVL_MAX_REG\n");
3059	goto out;
3060	}
3061	}
3062
3063	if (is_ab8505_2p0(ab: di->parent))
3064	ret = abx500_mask_and_set_register_interruptible(dev: di->dev,
3065	AB8500_CHARGER,
3066	AB8500_USBCH_CTRL2_REG,
3067	VBUS_AUTO_IN_CURR_LIM_ENA,
3068	VBUS_AUTO_IN_CURR_LIM_ENA);
3069	else
3070	/*
3071	* VBUS OVV set to 6.3V and enable automatic current limitation
3072	*/
3073	ret = abx500_set_register_interruptible(dev: di->dev,
3074	AB8500_CHARGER,
3075	AB8500_USBCH_CTRL2_REG,
3076	VBUS_OVV_SELECT_6P3V | VBUS_AUTO_IN_CURR_LIM_ENA);
3077	if (ret) {
3078	dev_err(di->dev,
3079	"failed to set automatic current limitation\n");
3080	goto out;
3081	}
3082
3083	/* Enable main watchdog in OTP */
3084	ret = abx500_set_register_interruptible(dev: di->dev,
3085	AB8500_OTP_EMUL, AB8500_OTP_CONF_15, OTP_ENABLE_WD);
3086	if (ret) {
3087	dev_err(di->dev, "failed to enable main WD in OTP\n");
3088	goto out;
3089	}
3090
3091	/* Enable main watchdog */
3092	ret = abx500_set_register_interruptible(dev: di->dev,
3093	AB8500_SYS_CTRL2_BLOCK,
3094	AB8500_MAIN_WDOG_CTRL_REG, MAIN_WDOG_ENA);
3095	if (ret) {
3096	dev_err(di->dev, "failed to enable main watchdog\n");
3097	goto out;
3098	}
3099
3100	/*
3101	* Due to internal synchronisation, Enable and Kick watchdog bits
3102	* cannot be enabled in a single write.
3103	* A minimum delay of 2*32 kHz period (62.5µs) must be inserted
3104	* between writing Enable then Kick bits.
3105	*/
3106	udelay(63);
3107
3108	/* Kick main watchdog */
3109	ret = abx500_set_register_interruptible(dev: di->dev,
3110	AB8500_SYS_CTRL2_BLOCK,
3111	AB8500_MAIN_WDOG_CTRL_REG,
3112	value: (MAIN_WDOG_ENA | MAIN_WDOG_KICK));
3113	if (ret) {
3114	dev_err(di->dev, "failed to kick main watchdog\n");
3115	goto out;
3116	}
3117
3118	/* Disable main watchdog */
3119	ret = abx500_set_register_interruptible(dev: di->dev,
3120	AB8500_SYS_CTRL2_BLOCK,
3121	AB8500_MAIN_WDOG_CTRL_REG, MAIN_WDOG_DIS);
3122	if (ret) {
3123	dev_err(di->dev, "failed to disable main watchdog\n");
3124	goto out;
3125	}
3126
3127	/* Set watchdog timeout */
3128	ret = abx500_set_register_interruptible(dev: di->dev, AB8500_CHARGER,
3129	AB8500_CH_WD_TIMER_REG, WD_TIMER);
3130	if (ret) {
3131	dev_err(di->dev, "failed to set charger watchdog timeout\n");
3132	goto out;
3133	}
3134
3135	ret = ab8500_charger_led_en(di, on: false);
3136	if (ret < 0) {
3137	dev_err(di->dev, "failed to disable LED\n");
3138	goto out;
3139	}
3140
3141	ret = abx500_set_register_interruptible(dev: di->dev,
3142	AB8500_RTC,
3143	AB8500_RTC_BACKUP_CHG_REG,
3144	value: (di->bm->bkup_bat_v & 0x3) | di->bm->bkup_bat_i);
3145	if (ret) {
3146	dev_err(di->dev, "failed to setup backup battery charging\n");
3147	goto out;
3148	}
3149
3150	/* Enable backup battery charging */
3151	ret = abx500_mask_and_set_register_interruptible(dev: di->dev,
3152	AB8500_RTC, AB8500_RTC_CTRL_REG,
3153	RTC_BUP_CH_ENA, RTC_BUP_CH_ENA);
3154	if (ret < 0) {
3155	dev_err(di->dev, "%s mask and set failed\n", __func__);
3156	goto out;
3157	}
3158
3159	out:
3160	return ret;
3161	}
3162
3163	/*
3164	* ab8500 charger driver interrupts and their respective isr
3165	*/
3166	static struct ab8500_charger_interrupts ab8500_charger_irq[] = {
3167	{"MAIN_CH_UNPLUG_DET", ab8500_charger_mainchunplugdet_handler},
3168	{"MAIN_CHARGE_PLUG_DET", ab8500_charger_mainchplugdet_handler},
3169	{"MAIN_EXT_CH_NOT_OK", ab8500_charger_mainextchnotok_handler},
3170	{"MAIN_CH_TH_PROT_R", ab8500_charger_mainchthprotr_handler},
3171	{"MAIN_CH_TH_PROT_F", ab8500_charger_mainchthprotf_handler},
3172	{"VBUS_DET_F", ab8500_charger_vbusdetf_handler},
3173	{"VBUS_DET_R", ab8500_charger_vbusdetr_handler},
3174	{"USB_LINK_STATUS", ab8500_charger_usblinkstatus_handler},
3175	{"USB_CH_TH_PROT_R", ab8500_charger_usbchthprotr_handler},
3176	{"USB_CH_TH_PROT_F", ab8500_charger_usbchthprotf_handler},
3177	{"USB_CHARGER_NOT_OKR", ab8500_charger_usbchargernotokr_handler},
3178	{"VBUS_OVV", ab8500_charger_vbusovv_handler},
3179	{"CH_WD_EXP", ab8500_charger_chwdexp_handler},
3180	{"VBUS_CH_DROP_END", ab8500_charger_vbuschdropend_handler},
3181	};
3182
3183	static int ab8500_charger_usb_notifier_call(struct notifier_block *nb,
3184	unsigned long event, void *power)
3185	{
3186	struct ab8500_charger *di =
3187	container_of(nb, struct ab8500_charger, nb);
3188	enum ab8500_usb_state bm_usb_state;
3189	/*
3190	* FIXME: it appears the AB8500 PHY never sends what it should here.
3191	* Fix the PHY driver to properly notify the desired current.
3192	* Also broadcast microampere and not milliampere.
3193	*/
3194	unsigned mA = *((unsigned *)power);
3195
3196	if (event != USB_EVENT_VBUS) {
3197	dev_dbg(di->dev, "not a standard host, returning\n");
3198	return NOTIFY_DONE;
3199	}
3200
3201	/* TODO: State is fabricate here. See if charger really needs USB
3202	* state or if mA is enough
3203	*/
3204	if ((di->usb_state.usb_current_ua == 2000) && (mA > 2))
3205	bm_usb_state = AB8500_BM_USB_STATE_RESUME;
3206	else if (mA == 0)
3207	bm_usb_state = AB8500_BM_USB_STATE_RESET_HS;
3208	else if (mA == 2)
3209	bm_usb_state = AB8500_BM_USB_STATE_SUSPEND;
3210	else if (mA >= 8) /* 8, 100, 500 */
3211	bm_usb_state = AB8500_BM_USB_STATE_CONFIGURED;
3212	else /* Should never occur */
3213	bm_usb_state = AB8500_BM_USB_STATE_RESET_FS;
3214
3215	dev_dbg(di->dev, "%s usb_state: 0x%02x mA: %d\n",
3216	__func__, bm_usb_state, mA);
3217
3218	spin_lock(lock: &di->usb_state.usb_lock);
3219	di->usb_state.state_tmp = bm_usb_state;
3220	/* FIXME: broadcast ua instead, see above */
3221	di->usb_state.usb_current_tmp_ua = mA * 1000;
3222	spin_unlock(lock: &di->usb_state.usb_lock);
3223
3224	/*
3225	* wait for some time until you get updates from the usb stack
3226	* and negotiations are completed
3227	*/
3228	queue_delayed_work(wq: di->charger_wq, dwork: &di->usb_state_changed_work, HZ/2);
3229
3230	return NOTIFY_OK;
3231	}
3232
3233	static int __maybe_unused ab8500_charger_resume(struct device *dev)
3234	{
3235	int ret;
3236	struct ab8500_charger *di = dev_get_drvdata(dev);
3237
3238	/*
3239	* For ABB revision 1.0 and 1.1 there is a bug in the watchdog
3240	* logic. That means we have to continuously kick the charger
3241	* watchdog even when no charger is connected. This is only
3242	* valid once the AC charger has been enabled. This is
3243	* a bug that is not handled by the algorithm and the
3244	* watchdog have to be kicked by the charger driver
3245	* when the AC charger is disabled
3246	*/
3247	if (di->ac_conn && is_ab8500_1p1_or_earlier(ab: di->parent)) {
3248	ret = abx500_set_register_interruptible(dev: di->dev, AB8500_CHARGER,
3249	AB8500_CHARG_WD_CTRL, CHARG_WD_KICK);
3250	if (ret)
3251	dev_err(di->dev, "Failed to kick WD!\n");
3252
3253	/* If not already pending start a new timer */
3254	queue_delayed_work(wq: di->charger_wq, dwork: &di->kick_wd_work,
3255	delay: round_jiffies(WD_KICK_INTERVAL));
3256	}
3257
3258	/* If we still have a HW failure, schedule a new check */
3259	if (di->flags.mainextchnotok || di->flags.vbus_ovv) {
3260	queue_delayed_work(wq: di->charger_wq,
3261	dwork: &di->check_hw_failure_work, delay: 0);
3262	}
3263
3264	if (di->flags.vbus_drop_end)
3265	queue_delayed_work(wq: di->charger_wq, dwork: &di->vbus_drop_end_work, delay: 0);
3266
3267	return 0;
3268	}
3269
3270	static int __maybe_unused ab8500_charger_suspend(struct device *dev)
3271	{
3272	struct ab8500_charger *di = dev_get_drvdata(dev);
3273
3274	/* Cancel any pending jobs */
3275	cancel_delayed_work(dwork: &di->check_hw_failure_work);
3276	cancel_delayed_work(dwork: &di->vbus_drop_end_work);
3277
3278	flush_delayed_work(dwork: &di->attach_work);
3279	flush_delayed_work(dwork: &di->usb_charger_attached_work);
3280	flush_delayed_work(dwork: &di->ac_charger_attached_work);
3281	flush_delayed_work(dwork: &di->check_usbchgnotok_work);
3282	flush_delayed_work(dwork: &di->check_vbat_work);
3283	flush_delayed_work(dwork: &di->kick_wd_work);
3284
3285	flush_work(work: &di->usb_link_status_work);
3286	flush_work(work: &di->ac_work);
3287	flush_work(work: &di->detect_usb_type_work);
3288
3289	if (atomic_read(v: &di->current_stepping_sessions))
3290	return -EAGAIN;
3291
3292	return 0;
3293	}
3294
3295	static char *supply_interface[] = {
3296	"ab8500_chargalg",
3297	"ab8500_fg",
3298	"ab8500_btemp",
3299	};
3300
3301	static const struct power_supply_desc ab8500_ac_chg_desc = {
3302	.name = "ab8500_ac",
3303	.type = POWER_SUPPLY_TYPE_MAINS,
3304	.properties = ab8500_charger_ac_props,
3305	.num_properties = ARRAY_SIZE(ab8500_charger_ac_props),
3306	.get_property = ab8500_charger_ac_get_property,
3307	};
3308
3309	static const struct power_supply_desc ab8500_usb_chg_desc = {
3310	.name = "ab8500_usb",
3311	.type = POWER_SUPPLY_TYPE_USB,
3312	.properties = ab8500_charger_usb_props,
3313	.num_properties = ARRAY_SIZE(ab8500_charger_usb_props),
3314	.get_property = ab8500_charger_usb_get_property,
3315	};
3316
3317	static int ab8500_charger_bind(struct device *dev)
3318	{
3319	struct ab8500_charger *di = dev_get_drvdata(dev);
3320	int ch_stat;
3321	int ret;
3322
3323	/* Create a work queue for the charger */
3324	di->charger_wq = alloc_ordered_workqueue("ab8500_charger_wq",
3325	WQ_MEM_RECLAIM);
3326	if (di->charger_wq == NULL) {
3327	dev_err(dev, "failed to create work queue\n");
3328	return -ENOMEM;
3329	}
3330
3331	ch_stat = ab8500_charger_detect_chargers(di, probe: false);
3332
3333	if (ch_stat & AC_PW_CONN) {
3334	if (is_ab8500(ab: di->parent))
3335	queue_delayed_work(wq: di->charger_wq,
3336	dwork: &di->ac_charger_attached_work,
3337	HZ);
3338	}
3339	if (ch_stat & USB_PW_CONN) {
3340	if (is_ab8500(ab: di->parent))
3341	queue_delayed_work(wq: di->charger_wq,
3342	dwork: &di->usb_charger_attached_work,
3343	HZ);
3344	di->vbus_detected = true;
3345	di->vbus_detected_start = true;
3346	queue_work(wq: di->charger_wq,
3347	work: &di->detect_usb_type_work);
3348	}
3349
3350	ret = component_bind_all(parent: dev, data: di);
3351	if (ret) {
3352	dev_err(dev, "can't bind component devices\n");
3353	destroy_workqueue(wq: di->charger_wq);
3354	return ret;
3355	}
3356
3357	return 0;
3358	}
3359
3360	static void ab8500_charger_unbind(struct device *dev)
3361	{
3362	struct ab8500_charger *di = dev_get_drvdata(dev);
3363	int ret;
3364
3365	/* Disable AC charging */
3366	ab8500_charger_ac_en(charger: &di->ac_chg, enable: false, vset_uv: 0, iset_ua: 0);
3367
3368	/* Disable USB charging */
3369	ab8500_charger_usb_en(charger: &di->usb_chg, enable: false, vset_uv: 0, ich_out_ua: 0);
3370
3371	/* Backup battery voltage and current disable */
3372	ret = abx500_mask_and_set_register_interruptible(dev: di->dev,
3373	AB8500_RTC, AB8500_RTC_CTRL_REG, RTC_BUP_CH_ENA, bitvalues: 0);
3374	if (ret < 0)
3375	dev_err(di->dev, "%s mask and set failed\n", __func__);
3376
3377	/* Delete the work queue */
3378	destroy_workqueue(wq: di->charger_wq);
3379
3380	/* Unbind fg, btemp, algorithm */
3381	component_unbind_all(parent: dev, data: di);
3382	}
3383
3384	static const struct component_master_ops ab8500_charger_comp_ops = {
3385	.bind = ab8500_charger_bind,
3386	.unbind = ab8500_charger_unbind,
3387	};
3388
3389	static struct platform_driver *const ab8500_charger_component_drivers[] = {
3390	&ab8500_fg_driver,
3391	&ab8500_btemp_driver,
3392	&ab8500_chargalg_driver,
3393	};
3394
3395	static int ab8500_charger_probe(struct platform_device *pdev)
3396	{
3397	struct device *dev = &pdev->dev;
3398	struct device_node *np = dev->of_node;
3399	struct component_match *match = NULL;
3400	struct power_supply_config ac_psy_cfg = {}, usb_psy_cfg = {};
3401	struct ab8500_charger *di;
3402	int charger_status;
3403	int i, irq;
3404	int ret;
3405
3406	di = devm_kzalloc(dev, size: sizeof(*di), GFP_KERNEL);
3407	if (!di)
3408	return -ENOMEM;
3409
3410	di->bm = &ab8500_bm_data;
3411
3412	di->autopower_cfg = of_property_read_bool(np, propname: "autopower_cfg");
3413
3414	/* get parent data */
3415	di->dev = dev;
3416	di->parent = dev_get_drvdata(dev: pdev->dev.parent);
3417
3418	/* Get ADC channels */
3419	if (!is_ab8505(ab: di->parent)) {
3420	di->adc_main_charger_v = devm_iio_channel_get(dev, consumer_channel: "main_charger_v");
3421	if (IS_ERR(ptr: di->adc_main_charger_v)) {
3422	ret = dev_err_probe(dev, err: PTR_ERR(ptr: di->adc_main_charger_v),
3423	fmt: "failed to get ADC main charger voltage\n");
3424	return ret;
3425	}
3426	di->adc_main_charger_c = devm_iio_channel_get(dev, consumer_channel: "main_charger_c");
3427	if (IS_ERR(ptr: di->adc_main_charger_c)) {
3428	ret = dev_err_probe(dev, err: PTR_ERR(ptr: di->adc_main_charger_c),
3429	fmt: "failed to get ADC main charger current\n");
3430	return ret;
3431	}
3432	}
3433	di->adc_vbus_v = devm_iio_channel_get(dev, consumer_channel: "vbus_v");
3434	if (IS_ERR(ptr: di->adc_vbus_v)) {
3435	ret = dev_err_probe(dev, err: PTR_ERR(ptr: di->adc_vbus_v),
3436	fmt: "failed to get ADC USB charger voltage\n");
3437	return ret;
3438	}
3439	di->adc_usb_charger_c = devm_iio_channel_get(dev, consumer_channel: "usb_charger_c");
3440	if (IS_ERR(ptr: di->adc_usb_charger_c)) {
3441	ret = dev_err_probe(dev, err: PTR_ERR(ptr: di->adc_usb_charger_c),
3442	fmt: "failed to get ADC USB charger current\n");
3443	return ret;
3444	}
3445
3446	/*
3447	* VDD ADC supply needs to be enabled from this driver when there
3448	* is a charger connected to avoid erroneous BTEMP_HIGH/LOW
3449	* interrupts during charging
3450	*/
3451	di->regu = devm_regulator_get(dev, id: "vddadc");
3452	if (IS_ERR(ptr: di->regu)) {
3453	ret = PTR_ERR(ptr: di->regu);
3454	dev_err(dev, "failed to get vddadc regulator\n");
3455	return ret;
3456	}
3457
3458	/* Request interrupts */
3459	for (i = 0; i < ARRAY_SIZE(ab8500_charger_irq); i++) {
3460	irq = platform_get_irq_byname(pdev, ab8500_charger_irq[i].name);
3461	if (irq < 0)
3462	return irq;
3463
3464	ret = devm_request_threaded_irq(dev,
3465	irq, NULL, thread_fn: ab8500_charger_irq[i].isr,
3466	IRQF_SHARED | IRQF_NO_SUSPEND | IRQF_ONESHOT,
3467	devname: ab8500_charger_irq[i].name, dev_id: di);
3468
3469	if (ret != 0) {
3470	dev_err(dev, "failed to request %s IRQ %d: %d\n"
3471	, ab8500_charger_irq[i].name, irq, ret);
3472	return ret;
3473	}
3474	dev_dbg(dev, "Requested %s IRQ %d: %d\n",
3475	ab8500_charger_irq[i].name, irq, ret);
3476	}
3477
3478	/* initialize lock */
3479	spin_lock_init(&di->usb_state.usb_lock);
3480	mutex_init(&di->usb_ipt_crnt_lock);
3481
3482	di->autopower = false;
3483	di->invalid_charger_detect_state = 0;
3484
3485	/* AC and USB supply config */
3486	ac_psy_cfg.of_node = np;
3487	ac_psy_cfg.supplied_to = supply_interface;
3488	ac_psy_cfg.num_supplicants = ARRAY_SIZE(supply_interface);
3489	ac_psy_cfg.drv_data = &di->ac_chg;
3490	usb_psy_cfg.of_node = np;
3491	usb_psy_cfg.supplied_to = supply_interface;
3492	usb_psy_cfg.num_supplicants = ARRAY_SIZE(supply_interface);
3493	usb_psy_cfg.drv_data = &di->usb_chg;
3494
3495	/* AC supply */
3496	/* ux500_charger sub-class */
3497	di->ac_chg.ops.enable = &ab8500_charger_ac_en;
3498	di->ac_chg.ops.check_enable = &ab8500_charger_ac_check_enable;
3499	di->ac_chg.ops.kick_wd = &ab8500_charger_watchdog_kick;
3500	di->ac_chg.ops.update_curr = &ab8500_charger_update_charger_current;
3501	di->ac_chg.max_out_volt_uv = ab8500_charger_voltage_map[
3502	ARRAY_SIZE(ab8500_charger_voltage_map) - 1];
3503	di->ac_chg.max_out_curr_ua =
3504	ab8500_charge_output_curr_map[ARRAY_SIZE(ab8500_charge_output_curr_map) - 1];
3505	di->ac_chg.wdt_refresh = CHG_WD_INTERVAL;
3506	/*
3507	* The AB8505 only supports USB charging. If we are not the
3508	* AB8505, register an AC charger.
3509	*
3510	* TODO: if this should be opt-in, add DT properties for this.
3511	*/
3512	if (!is_ab8505(ab: di->parent))
3513	di->ac_chg.enabled = true;
3514
3515	/* USB supply */
3516	/* ux500_charger sub-class */
3517	di->usb_chg.ops.enable = &ab8500_charger_usb_en;
3518	di->usb_chg.ops.check_enable = &ab8500_charger_usb_check_enable;
3519	di->usb_chg.ops.kick_wd = &ab8500_charger_watchdog_kick;
3520	di->usb_chg.ops.update_curr = &ab8500_charger_update_charger_current;
3521	di->usb_chg.max_out_volt_uv = ab8500_charger_voltage_map[
3522	ARRAY_SIZE(ab8500_charger_voltage_map) - 1];
3523	di->usb_chg.max_out_curr_ua =
3524	ab8500_charge_output_curr_map[ARRAY_SIZE(ab8500_charge_output_curr_map) - 1];
3525	di->usb_chg.wdt_refresh = CHG_WD_INTERVAL;
3526	di->usb_state.usb_current_ua = -1;
3527
3528	mutex_init(&di->charger_attached_mutex);
3529
3530	/* Init work for HW failure check */
3531	INIT_DEFERRABLE_WORK(&di->check_hw_failure_work,
3532	ab8500_charger_check_hw_failure_work);
3533	INIT_DEFERRABLE_WORK(&di->check_usbchgnotok_work,
3534	ab8500_charger_check_usbchargernotok_work);
3535
3536	INIT_DELAYED_WORK(&di->ac_charger_attached_work,
3537	ab8500_charger_ac_attached_work);
3538	INIT_DELAYED_WORK(&di->usb_charger_attached_work,
3539	ab8500_charger_usb_attached_work);
3540
3541	/*
3542	* For ABB revision 1.0 and 1.1 there is a bug in the watchdog
3543	* logic. That means we have to continuously kick the charger
3544	* watchdog even when no charger is connected. This is only
3545	* valid once the AC charger has been enabled. This is
3546	* a bug that is not handled by the algorithm and the
3547	* watchdog have to be kicked by the charger driver
3548	* when the AC charger is disabled
3549	*/
3550	INIT_DEFERRABLE_WORK(&di->kick_wd_work,
3551	ab8500_charger_kick_watchdog_work);
3552
3553	INIT_DEFERRABLE_WORK(&di->check_vbat_work,
3554	ab8500_charger_check_vbat_work);
3555
3556	INIT_DELAYED_WORK(&di->attach_work,
3557	ab8500_charger_usb_link_attach_work);
3558
3559	INIT_DELAYED_WORK(&di->usb_state_changed_work,
3560	ab8500_charger_usb_state_changed_work);
3561
3562	INIT_DELAYED_WORK(&di->vbus_drop_end_work,
3563	ab8500_charger_vbus_drop_end_work);
3564
3565	/* Init work for charger detection */
3566	INIT_WORK(&di->usb_link_status_work,
3567	ab8500_charger_usb_link_status_work);
3568	INIT_WORK(&di->ac_work, ab8500_charger_ac_work);
3569	INIT_WORK(&di->detect_usb_type_work,
3570	ab8500_charger_detect_usb_type_work);
3571
3572	/* Init work for checking HW status */
3573	INIT_WORK(&di->check_main_thermal_prot_work,
3574	ab8500_charger_check_main_thermal_prot_work);
3575	INIT_WORK(&di->check_usb_thermal_prot_work,
3576	ab8500_charger_check_usb_thermal_prot_work);
3577
3578
3579	/* Initialize OVV, and other registers */
3580	ret = ab8500_charger_init_hw_registers(di);
3581	if (ret) {
3582	dev_err(dev, "failed to initialize ABB registers\n");
3583	return ret;
3584	}
3585
3586	/* Register AC charger class */
3587	if (di->ac_chg.enabled) {
3588	di->ac_chg.psy = devm_power_supply_register(parent: dev,
3589	desc: &ab8500_ac_chg_desc,
3590	cfg: &ac_psy_cfg);
3591	if (IS_ERR(ptr: di->ac_chg.psy)) {
3592	dev_err(dev, "failed to register AC charger\n");
3593	return PTR_ERR(ptr: di->ac_chg.psy);
3594	}
3595	}
3596
3597	/* Register USB charger class */
3598	di->usb_chg.psy = devm_power_supply_register(parent: dev,
3599	desc: &ab8500_usb_chg_desc,
3600	cfg: &usb_psy_cfg);
3601	if (IS_ERR(ptr: di->usb_chg.psy)) {
3602	dev_err(dev, "failed to register USB charger\n");
3603	return PTR_ERR(ptr: di->usb_chg.psy);
3604	}
3605
3606	/*
3607	* Check what battery we have, since we always have the USB
3608	* psy, use that as a handle.
3609	*/
3610	ret = ab8500_bm_of_probe(psy: di->usb_chg.psy, bm: di->bm);
3611	if (ret)
3612	return dev_err_probe(dev, err: ret,
3613	fmt: "failed to get battery information\n");
3614
3615	/* Identify the connected charger types during startup */
3616	charger_status = ab8500_charger_detect_chargers(di, probe: true);
3617	if (charger_status & AC_PW_CONN) {
3618	di->ac.charger_connected = 1;
3619	di->ac_conn = true;
3620	ab8500_power_supply_changed(di, psy: di->ac_chg.psy);
3621	sysfs_notify(kobj: &di->ac_chg.psy->dev.kobj, NULL, attr: "present");
3622	}
3623
3624	platform_set_drvdata(pdev, data: di);
3625
3626	/* Create something that will match the subdrivers when we bind */
3627	for (i = 0; i < ARRAY_SIZE(ab8500_charger_component_drivers); i++) {
3628	struct device_driver *drv = &ab8500_charger_component_drivers[i]->driver;
3629	struct device *p = NULL, *d;
3630
3631	while ((d = platform_find_device_by_driver(start: p, drv))) {
3632	put_device(dev: p);
3633	component_match_add(parent: dev, matchptr: &match, compare: component_compare_dev, compare_data: d);
3634	p = d;
3635	}
3636	put_device(dev: p);
3637	}
3638	if (!match) {
3639	dev_err(dev, "no matching components\n");
3640	ret = -ENODEV;
3641	goto remove_ab8500_bm;
3642	}
3643	if (IS_ERR(ptr: match)) {
3644	dev_err(dev, "could not create component match\n");
3645	ret = PTR_ERR(ptr: match);
3646	goto remove_ab8500_bm;
3647	}
3648
3649	di->usb_phy = usb_get_phy(type: USB_PHY_TYPE_USB2);
3650	if (IS_ERR_OR_NULL(ptr: di->usb_phy)) {
3651	dev_err(dev, "failed to get usb transceiver\n");
3652	ret = -EINVAL;
3653	goto remove_ab8500_bm;
3654	}
3655	di->nb.notifier_call = ab8500_charger_usb_notifier_call;
3656	ret = usb_register_notifier(x: di->usb_phy, nb: &di->nb);
3657	if (ret) {
3658	dev_err(dev, "failed to register usb notifier\n");
3659	goto put_usb_phy;
3660	}
3661
3662	ret = component_master_add_with_match(&pdev->dev,
3663	&ab8500_charger_comp_ops,
3664	match);
3665	if (ret) {
3666	dev_err(dev, "failed to add component master\n");
3667	goto free_notifier;
3668	}
3669
3670	return 0;
3671
3672	free_notifier:
3673	usb_unregister_notifier(x: di->usb_phy, nb: &di->nb);
3674	put_usb_phy:
3675	usb_put_phy(di->usb_phy);
3676	remove_ab8500_bm:
3677	ab8500_bm_of_remove(psy: di->usb_chg.psy, bm: di->bm);
3678	return ret;
3679	}
3680
3681	static void ab8500_charger_remove(struct platform_device *pdev)
3682	{
3683	struct ab8500_charger *di = platform_get_drvdata(pdev);
3684
3685	component_master_del(&pdev->dev, &ab8500_charger_comp_ops);
3686
3687	usb_unregister_notifier(x: di->usb_phy, nb: &di->nb);
3688	ab8500_bm_of_remove(psy: di->usb_chg.psy, bm: di->bm);
3689	usb_put_phy(di->usb_phy);
3690	}
3691
3692	static SIMPLE_DEV_PM_OPS(ab8500_charger_pm_ops, ab8500_charger_suspend, ab8500_charger_resume);
3693
3694	static const struct of_device_id ab8500_charger_match[] = {
3695	{ .compatible = "stericsson,ab8500-charger", },
3696	{ },
3697	};
3698	MODULE_DEVICE_TABLE(of, ab8500_charger_match);
3699
3700	static struct platform_driver ab8500_charger_driver = {
3701	.probe = ab8500_charger_probe,
3702	.remove_new = ab8500_charger_remove,
3703	.driver = {
3704	.name = "ab8500-charger",
3705	.of_match_table = ab8500_charger_match,
3706	.pm = &ab8500_charger_pm_ops,
3707	},
3708	};
3709
3710	static int __init ab8500_charger_init(void)
3711	{
3712	int ret;
3713
3714	ret = platform_register_drivers(ab8500_charger_component_drivers,
3715	ARRAY_SIZE(ab8500_charger_component_drivers));
3716	if (ret)
3717	return ret;
3718
3719	ret = platform_driver_register(&ab8500_charger_driver);
3720	if (ret) {
3721	platform_unregister_drivers(drivers: ab8500_charger_component_drivers,
3722	ARRAY_SIZE(ab8500_charger_component_drivers));
3723	return ret;
3724	}
3725
3726	return 0;
3727	}
3728
3729	static void __exit ab8500_charger_exit(void)
3730	{
3731	platform_unregister_drivers(drivers: ab8500_charger_component_drivers,
3732	ARRAY_SIZE(ab8500_charger_component_drivers));
3733	platform_driver_unregister(&ab8500_charger_driver);
3734	}
3735
3736	module_init(ab8500_charger_init);
3737	module_exit(ab8500_charger_exit);
3738
3739	MODULE_LICENSE("GPL v2");
3740	MODULE_AUTHOR("Johan Palsson, Karl Komierowski, Arun R Murthy");
3741	MODULE_ALIAS("platform:ab8500-charger");
3742	MODULE_DESCRIPTION("AB8500 charger management driver");
3743