1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * axp288_charger.c - X-power AXP288 PMIC Charger driver
4  *
5  * Copyright (C) 2016-2017 Hans de Goede <hdegoede@redhat.com>
6  * Copyright (C) 2014 Intel Corporation
7  * Author: Ramakrishna Pallala <ramakrishna.pallala@intel.com>
8  */
9 
10 #include <linux/acpi.h>
11 #include <linux/bitops.h>
12 #include <linux/module.h>
13 #include <linux/device.h>
14 #include <linux/regmap.h>
15 #include <linux/workqueue.h>
16 #include <linux/delay.h>
17 #include <linux/platform_device.h>
18 #include <linux/usb/otg.h>
19 #include <linux/notifier.h>
20 #include <linux/power_supply.h>
21 #include <linux/property.h>
22 #include <linux/mfd/axp20x.h>
23 #include <linux/extcon.h>
24 #include <linux/dmi.h>
25 
26 #define PS_STAT_VBUS_TRIGGER		BIT(0)
27 #define PS_STAT_BAT_CHRG_DIR		BIT(2)
28 #define PS_STAT_VBAT_ABOVE_VHOLD	BIT(3)
29 #define PS_STAT_VBUS_VALID		BIT(4)
30 #define PS_STAT_VBUS_PRESENT		BIT(5)
31 
32 #define CHRG_STAT_BAT_SAFE_MODE		BIT(3)
33 #define CHRG_STAT_BAT_VALID		BIT(4)
34 #define CHRG_STAT_BAT_PRESENT		BIT(5)
35 #define CHRG_STAT_CHARGING		BIT(6)
36 #define CHRG_STAT_PMIC_OTP		BIT(7)
37 
38 #define VBUS_ISPOUT_CUR_LIM_MASK	0x03
39 #define VBUS_ISPOUT_CUR_LIM_BIT_POS	0
40 #define VBUS_ISPOUT_CUR_LIM_900MA	0x0	/* 900mA */
41 #define VBUS_ISPOUT_CUR_LIM_1500MA	0x1	/* 1500mA */
42 #define VBUS_ISPOUT_CUR_LIM_2000MA	0x2	/* 2000mA */
43 #define VBUS_ISPOUT_CUR_NO_LIM		0x3	/* 2500mA */
44 #define VBUS_ISPOUT_VHOLD_SET_MASK	0x31
45 #define VBUS_ISPOUT_VHOLD_SET_BIT_POS	0x3
46 #define VBUS_ISPOUT_VHOLD_SET_OFFSET	4000	/* 4000mV */
47 #define VBUS_ISPOUT_VHOLD_SET_LSB_RES	100	/* 100mV */
48 #define VBUS_ISPOUT_VHOLD_SET_4300MV	0x3	/* 4300mV */
49 #define VBUS_ISPOUT_VBUS_PATH_DIS	BIT(7)
50 
51 #define CHRG_CCCV_CC_MASK		0xf		/* 4 bits */
52 #define CHRG_CCCV_CC_BIT_POS		0
53 #define CHRG_CCCV_CC_OFFSET		200		/* 200mA */
54 #define CHRG_CCCV_CC_LSB_RES		200		/* 200mA */
55 #define CHRG_CCCV_ITERM_20P		BIT(4)		/* 20% of CC */
56 #define CHRG_CCCV_CV_MASK		0x60		/* 2 bits */
57 #define CHRG_CCCV_CV_BIT_POS		5
58 #define CHRG_CCCV_CV_4100MV		0x0		/* 4.10V */
59 #define CHRG_CCCV_CV_4150MV		0x1		/* 4.15V */
60 #define CHRG_CCCV_CV_4200MV		0x2		/* 4.20V */
61 #define CHRG_CCCV_CV_4350MV		0x3		/* 4.35V */
62 #define CHRG_CCCV_CHG_EN		BIT(7)
63 
64 #define CNTL2_CC_TIMEOUT_MASK		0x3	/* 2 bits */
65 #define CNTL2_CC_TIMEOUT_OFFSET		6	/* 6 Hrs */
66 #define CNTL2_CC_TIMEOUT_LSB_RES	2	/* 2 Hrs */
67 #define CNTL2_CC_TIMEOUT_12HRS		0x3	/* 12 Hrs */
68 #define CNTL2_CHGLED_TYPEB		BIT(4)
69 #define CNTL2_CHG_OUT_TURNON		BIT(5)
70 #define CNTL2_PC_TIMEOUT_MASK		0xC0
71 #define CNTL2_PC_TIMEOUT_OFFSET		40	/* 40 mins */
72 #define CNTL2_PC_TIMEOUT_LSB_RES	10	/* 10 mins */
73 #define CNTL2_PC_TIMEOUT_70MINS		0x3
74 
75 #define CHRG_ILIM_TEMP_LOOP_EN		BIT(3)
76 #define CHRG_VBUS_ILIM_MASK		0xf0
77 #define CHRG_VBUS_ILIM_BIT_POS		4
78 #define CHRG_VBUS_ILIM_100MA		0x0	/* 100mA */
79 #define CHRG_VBUS_ILIM_500MA		0x1	/* 500mA */
80 #define CHRG_VBUS_ILIM_900MA		0x2	/* 900mA */
81 #define CHRG_VBUS_ILIM_1500MA		0x3	/* 1500mA */
82 #define CHRG_VBUS_ILIM_2000MA		0x4	/* 2000mA */
83 #define CHRG_VBUS_ILIM_2500MA		0x5	/* 2500mA */
84 #define CHRG_VBUS_ILIM_3000MA		0x6	/* 3000mA */
85 #define CHRG_VBUS_ILIM_3500MA		0x7	/* 3500mA */
86 #define CHRG_VBUS_ILIM_4000MA		0x8	/* 4000mA */
87 
88 #define CHRG_VLTFC_0C			0xA5	/* 0 DegC */
89 #define CHRG_VHTFC_45C			0x1F	/* 45 DegC */
90 
91 #define FG_CNTL_OCV_ADJ_EN		BIT(3)
92 
93 #define CV_4100MV			4100	/* 4100mV */
94 #define CV_4150MV			4150	/* 4150mV */
95 #define CV_4200MV			4200	/* 4200mV */
96 #define CV_4350MV			4350	/* 4350mV */
97 
98 #define AXP288_EXTCON_DEV_NAME		"axp288_extcon"
99 #define USB_HOST_EXTCON_HID		"INT3496"
100 #define USB_HOST_EXTCON_NAME		"INT3496:00"
101 
102 enum {
103 	VBUS_OV_IRQ = 0,
104 	CHARGE_DONE_IRQ,
105 	CHARGE_CHARGING_IRQ,
106 	BAT_SAFE_QUIT_IRQ,
107 	BAT_SAFE_ENTER_IRQ,
108 	QCBTU_IRQ,
109 	CBTU_IRQ,
110 	QCBTO_IRQ,
111 	CBTO_IRQ,
112 	CHRG_INTR_END,
113 };
114 
115 struct axp288_chrg_info {
116 	struct platform_device *pdev;
117 	struct regmap *regmap;
118 	struct regmap_irq_chip_data *regmap_irqc;
119 	int irq[CHRG_INTR_END];
120 	struct power_supply *psy_usb;
121 
122 	/* OTG/Host mode */
123 	struct {
124 		struct work_struct work;
125 		struct extcon_dev *cable;
126 		struct notifier_block id_nb;
127 		bool id_short;
128 	} otg;
129 
130 	/* SDP/CDP/DCP USB charging cable notifications */
131 	struct {
132 		struct extcon_dev *edev;
133 		struct notifier_block nb;
134 		struct work_struct work;
135 	} cable;
136 
137 	int cc;
138 	int cv;
139 	int max_cc;
140 	int max_cv;
141 };
142 
143 static inline int axp288_charger_set_cc(struct axp288_chrg_info *info, int cc)
144 {
145 	u8 reg_val;
146 	int ret;
147 
148 	if (cc < CHRG_CCCV_CC_OFFSET)
149 		cc = CHRG_CCCV_CC_OFFSET;
150 	else if (cc > info->max_cc)
151 		cc = info->max_cc;
152 
153 	reg_val = (cc - CHRG_CCCV_CC_OFFSET) / CHRG_CCCV_CC_LSB_RES;
154 	cc = (reg_val * CHRG_CCCV_CC_LSB_RES) + CHRG_CCCV_CC_OFFSET;
155 	reg_val = reg_val << CHRG_CCCV_CC_BIT_POS;
156 
157 	ret = regmap_update_bits(info->regmap,
158 				AXP20X_CHRG_CTRL1,
159 				CHRG_CCCV_CC_MASK, reg_val);
160 	if (ret >= 0)
161 		info->cc = cc;
162 
163 	return ret;
164 }
165 
166 static inline int axp288_charger_set_cv(struct axp288_chrg_info *info, int cv)
167 {
168 	u8 reg_val;
169 	int ret;
170 
171 	if (cv <= CV_4100MV) {
172 		reg_val = CHRG_CCCV_CV_4100MV;
173 		cv = CV_4100MV;
174 	} else if (cv <= CV_4150MV) {
175 		reg_val = CHRG_CCCV_CV_4150MV;
176 		cv = CV_4150MV;
177 	} else if (cv <= CV_4200MV) {
178 		reg_val = CHRG_CCCV_CV_4200MV;
179 		cv = CV_4200MV;
180 	} else {
181 		reg_val = CHRG_CCCV_CV_4350MV;
182 		cv = CV_4350MV;
183 	}
184 
185 	reg_val = reg_val << CHRG_CCCV_CV_BIT_POS;
186 
187 	ret = regmap_update_bits(info->regmap,
188 				AXP20X_CHRG_CTRL1,
189 				CHRG_CCCV_CV_MASK, reg_val);
190 
191 	if (ret >= 0)
192 		info->cv = cv;
193 
194 	return ret;
195 }
196 
197 static int axp288_charger_get_vbus_inlmt(struct axp288_chrg_info *info)
198 {
199 	unsigned int val;
200 	int ret;
201 
202 	ret = regmap_read(info->regmap, AXP20X_CHRG_BAK_CTRL, &val);
203 	if (ret < 0)
204 		return ret;
205 
206 	val >>= CHRG_VBUS_ILIM_BIT_POS;
207 	switch (val) {
208 	case CHRG_VBUS_ILIM_100MA:
209 		return 100000;
210 	case CHRG_VBUS_ILIM_500MA:
211 		return 500000;
212 	case CHRG_VBUS_ILIM_900MA:
213 		return 900000;
214 	case CHRG_VBUS_ILIM_1500MA:
215 		return 1500000;
216 	case CHRG_VBUS_ILIM_2000MA:
217 		return 2000000;
218 	case CHRG_VBUS_ILIM_2500MA:
219 		return 2500000;
220 	case CHRG_VBUS_ILIM_3000MA:
221 		return 3000000;
222 	case CHRG_VBUS_ILIM_3500MA:
223 		return 3500000;
224 	default:
225 		/* All b1xxx values map to 4000 mA */
226 		return 4000000;
227 	}
228 }
229 
230 static inline int axp288_charger_set_vbus_inlmt(struct axp288_chrg_info *info,
231 					   int inlmt)
232 {
233 	int ret;
234 	u8 reg_val;
235 
236 	if (inlmt >= 4000000)
237 		reg_val = CHRG_VBUS_ILIM_4000MA << CHRG_VBUS_ILIM_BIT_POS;
238 	else if (inlmt >= 3500000)
239 		reg_val = CHRG_VBUS_ILIM_3500MA << CHRG_VBUS_ILIM_BIT_POS;
240 	else if (inlmt >= 3000000)
241 		reg_val = CHRG_VBUS_ILIM_3000MA << CHRG_VBUS_ILIM_BIT_POS;
242 	else if (inlmt >= 2500000)
243 		reg_val = CHRG_VBUS_ILIM_2500MA << CHRG_VBUS_ILIM_BIT_POS;
244 	else if (inlmt >= 2000000)
245 		reg_val = CHRG_VBUS_ILIM_2000MA << CHRG_VBUS_ILIM_BIT_POS;
246 	else if (inlmt >= 1500000)
247 		reg_val = CHRG_VBUS_ILIM_1500MA << CHRG_VBUS_ILIM_BIT_POS;
248 	else if (inlmt >= 900000)
249 		reg_val = CHRG_VBUS_ILIM_900MA << CHRG_VBUS_ILIM_BIT_POS;
250 	else if (inlmt >= 500000)
251 		reg_val = CHRG_VBUS_ILIM_500MA << CHRG_VBUS_ILIM_BIT_POS;
252 	else
253 		reg_val = CHRG_VBUS_ILIM_100MA << CHRG_VBUS_ILIM_BIT_POS;
254 
255 	ret = regmap_update_bits(info->regmap, AXP20X_CHRG_BAK_CTRL,
256 				 CHRG_VBUS_ILIM_MASK, reg_val);
257 	if (ret < 0)
258 		dev_err(&info->pdev->dev, "charger BAK control %d\n", ret);
259 
260 	return ret;
261 }
262 
263 static int axp288_charger_vbus_path_select(struct axp288_chrg_info *info,
264 								bool enable)
265 {
266 	int ret;
267 
268 	if (enable)
269 		ret = regmap_update_bits(info->regmap, AXP20X_VBUS_IPSOUT_MGMT,
270 					VBUS_ISPOUT_VBUS_PATH_DIS, 0);
271 	else
272 		ret = regmap_update_bits(info->regmap, AXP20X_VBUS_IPSOUT_MGMT,
273 			VBUS_ISPOUT_VBUS_PATH_DIS, VBUS_ISPOUT_VBUS_PATH_DIS);
274 
275 	if (ret < 0)
276 		dev_err(&info->pdev->dev, "axp288 vbus path select %d\n", ret);
277 
278 	return ret;
279 }
280 
281 static int axp288_charger_enable_charger(struct axp288_chrg_info *info,
282 								bool enable)
283 {
284 	int ret;
285 
286 	if (enable)
287 		ret = regmap_update_bits(info->regmap, AXP20X_CHRG_CTRL1,
288 				CHRG_CCCV_CHG_EN, CHRG_CCCV_CHG_EN);
289 	else
290 		ret = regmap_update_bits(info->regmap, AXP20X_CHRG_CTRL1,
291 				CHRG_CCCV_CHG_EN, 0);
292 	if (ret < 0)
293 		dev_err(&info->pdev->dev, "axp288 enable charger %d\n", ret);
294 
295 	return ret;
296 }
297 
298 static int axp288_charger_is_present(struct axp288_chrg_info *info)
299 {
300 	int ret, present = 0;
301 	unsigned int val;
302 
303 	ret = regmap_read(info->regmap, AXP20X_PWR_INPUT_STATUS, &val);
304 	if (ret < 0)
305 		return ret;
306 
307 	if (val & PS_STAT_VBUS_PRESENT)
308 		present = 1;
309 	return present;
310 }
311 
312 static int axp288_charger_is_online(struct axp288_chrg_info *info)
313 {
314 	int ret, online = 0;
315 	unsigned int val;
316 
317 	ret = regmap_read(info->regmap, AXP20X_PWR_INPUT_STATUS, &val);
318 	if (ret < 0)
319 		return ret;
320 
321 	if (val & PS_STAT_VBUS_VALID)
322 		online = 1;
323 	return online;
324 }
325 
326 static int axp288_get_charger_health(struct axp288_chrg_info *info)
327 {
328 	int ret, pwr_stat, chrg_stat;
329 	int health = POWER_SUPPLY_HEALTH_UNKNOWN;
330 	unsigned int val;
331 
332 	ret = regmap_read(info->regmap, AXP20X_PWR_INPUT_STATUS, &val);
333 	if ((ret < 0) || !(val & PS_STAT_VBUS_PRESENT))
334 		goto health_read_fail;
335 	else
336 		pwr_stat = val;
337 
338 	ret = regmap_read(info->regmap, AXP20X_PWR_OP_MODE, &val);
339 	if (ret < 0)
340 		goto health_read_fail;
341 	else
342 		chrg_stat = val;
343 
344 	if (!(pwr_stat & PS_STAT_VBUS_VALID))
345 		health = POWER_SUPPLY_HEALTH_DEAD;
346 	else if (chrg_stat & CHRG_STAT_PMIC_OTP)
347 		health = POWER_SUPPLY_HEALTH_OVERHEAT;
348 	else if (chrg_stat & CHRG_STAT_BAT_SAFE_MODE)
349 		health = POWER_SUPPLY_HEALTH_SAFETY_TIMER_EXPIRE;
350 	else
351 		health = POWER_SUPPLY_HEALTH_GOOD;
352 
353 health_read_fail:
354 	return health;
355 }
356 
357 static int axp288_charger_usb_set_property(struct power_supply *psy,
358 				    enum power_supply_property psp,
359 				    const union power_supply_propval *val)
360 {
361 	struct axp288_chrg_info *info = power_supply_get_drvdata(psy);
362 	int ret = 0;
363 	int scaled_val;
364 
365 	switch (psp) {
366 	case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT:
367 		scaled_val = min(val->intval, info->max_cc);
368 		scaled_val = DIV_ROUND_CLOSEST(scaled_val, 1000);
369 		ret = axp288_charger_set_cc(info, scaled_val);
370 		if (ret < 0)
371 			dev_warn(&info->pdev->dev, "set charge current failed\n");
372 		break;
373 	case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE:
374 		scaled_val = min(val->intval, info->max_cv);
375 		scaled_val = DIV_ROUND_CLOSEST(scaled_val, 1000);
376 		ret = axp288_charger_set_cv(info, scaled_val);
377 		if (ret < 0)
378 			dev_warn(&info->pdev->dev, "set charge voltage failed\n");
379 		break;
380 	case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
381 		ret = axp288_charger_set_vbus_inlmt(info, val->intval);
382 		if (ret < 0)
383 			dev_warn(&info->pdev->dev, "set input current limit failed\n");
384 		break;
385 	default:
386 		ret = -EINVAL;
387 	}
388 
389 	return ret;
390 }
391 
392 static int axp288_charger_usb_get_property(struct power_supply *psy,
393 				    enum power_supply_property psp,
394 				    union power_supply_propval *val)
395 {
396 	struct axp288_chrg_info *info = power_supply_get_drvdata(psy);
397 	int ret;
398 
399 	switch (psp) {
400 	case POWER_SUPPLY_PROP_PRESENT:
401 		/* Check for OTG case first */
402 		if (info->otg.id_short) {
403 			val->intval = 0;
404 			break;
405 		}
406 		ret = axp288_charger_is_present(info);
407 		if (ret < 0)
408 			return ret;
409 		val->intval = ret;
410 		break;
411 	case POWER_SUPPLY_PROP_ONLINE:
412 		/* Check for OTG case first */
413 		if (info->otg.id_short) {
414 			val->intval = 0;
415 			break;
416 		}
417 		ret = axp288_charger_is_online(info);
418 		if (ret < 0)
419 			return ret;
420 		val->intval = ret;
421 		break;
422 	case POWER_SUPPLY_PROP_HEALTH:
423 		val->intval = axp288_get_charger_health(info);
424 		break;
425 	case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT:
426 		val->intval = info->cc * 1000;
427 		break;
428 	case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX:
429 		val->intval = info->max_cc * 1000;
430 		break;
431 	case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE:
432 		val->intval = info->cv * 1000;
433 		break;
434 	case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX:
435 		val->intval = info->max_cv * 1000;
436 		break;
437 	case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
438 		ret = axp288_charger_get_vbus_inlmt(info);
439 		if (ret < 0)
440 			return ret;
441 		val->intval = ret;
442 		break;
443 	default:
444 		return -EINVAL;
445 	}
446 
447 	return 0;
448 }
449 
450 static int axp288_charger_property_is_writeable(struct power_supply *psy,
451 		enum power_supply_property psp)
452 {
453 	int ret;
454 
455 	switch (psp) {
456 	case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT:
457 	case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE:
458 	case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
459 		ret = 1;
460 		break;
461 	default:
462 		ret = 0;
463 	}
464 
465 	return ret;
466 }
467 
468 static enum power_supply_property axp288_usb_props[] = {
469 	POWER_SUPPLY_PROP_PRESENT,
470 	POWER_SUPPLY_PROP_ONLINE,
471 	POWER_SUPPLY_PROP_TYPE,
472 	POWER_SUPPLY_PROP_HEALTH,
473 	POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT,
474 	POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX,
475 	POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE,
476 	POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX,
477 	POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT,
478 };
479 
480 static const struct power_supply_desc axp288_charger_desc = {
481 	.name			= "axp288_charger",
482 	.type			= POWER_SUPPLY_TYPE_USB,
483 	.properties		= axp288_usb_props,
484 	.num_properties		= ARRAY_SIZE(axp288_usb_props),
485 	.get_property		= axp288_charger_usb_get_property,
486 	.set_property		= axp288_charger_usb_set_property,
487 	.property_is_writeable	= axp288_charger_property_is_writeable,
488 };
489 
490 static irqreturn_t axp288_charger_irq_thread_handler(int irq, void *dev)
491 {
492 	struct axp288_chrg_info *info = dev;
493 	int i;
494 
495 	for (i = 0; i < CHRG_INTR_END; i++) {
496 		if (info->irq[i] == irq)
497 			break;
498 	}
499 
500 	if (i >= CHRG_INTR_END) {
501 		dev_warn(&info->pdev->dev, "spurious interrupt!!\n");
502 		return IRQ_NONE;
503 	}
504 
505 	switch (i) {
506 	case VBUS_OV_IRQ:
507 		dev_dbg(&info->pdev->dev, "VBUS Over Voltage INTR\n");
508 		break;
509 	case CHARGE_DONE_IRQ:
510 		dev_dbg(&info->pdev->dev, "Charging Done INTR\n");
511 		break;
512 	case CHARGE_CHARGING_IRQ:
513 		dev_dbg(&info->pdev->dev, "Start Charging IRQ\n");
514 		break;
515 	case BAT_SAFE_QUIT_IRQ:
516 		dev_dbg(&info->pdev->dev,
517 			"Quit Safe Mode(restart timer) Charging IRQ\n");
518 		break;
519 	case BAT_SAFE_ENTER_IRQ:
520 		dev_dbg(&info->pdev->dev,
521 			"Enter Safe Mode(timer expire) Charging IRQ\n");
522 		break;
523 	case QCBTU_IRQ:
524 		dev_dbg(&info->pdev->dev,
525 			"Quit Battery Under Temperature(CHRG) INTR\n");
526 		break;
527 	case CBTU_IRQ:
528 		dev_dbg(&info->pdev->dev,
529 			"Hit Battery Under Temperature(CHRG) INTR\n");
530 		break;
531 	case QCBTO_IRQ:
532 		dev_dbg(&info->pdev->dev,
533 			"Quit Battery Over Temperature(CHRG) INTR\n");
534 		break;
535 	case CBTO_IRQ:
536 		dev_dbg(&info->pdev->dev,
537 			"Hit Battery Over Temperature(CHRG) INTR\n");
538 		break;
539 	default:
540 		dev_warn(&info->pdev->dev, "Spurious Interrupt!!!\n");
541 		goto out;
542 	}
543 
544 	power_supply_changed(info->psy_usb);
545 out:
546 	return IRQ_HANDLED;
547 }
548 
549 /*
550  * The HP Pavilion x2 10 series comes in a number of variants:
551  * Bay Trail SoC    + AXP288 PMIC, Micro-USB, DMI_BOARD_NAME: "8021"
552  * Bay Trail SoC    + AXP288 PMIC, Type-C,    DMI_BOARD_NAME: "815D"
553  * Cherry Trail SoC + AXP288 PMIC, Type-C,    DMI_BOARD_NAME: "813E"
554  * Cherry Trail SoC + TI PMIC,     Type-C,    DMI_BOARD_NAME: "827C" or "82F4"
555  *
556  * The variants with the AXP288 + Type-C connector are all kinds of special:
557  *
558  * 1. They use a Type-C connector which the AXP288 does not support, so when
559  * using a Type-C charger it is not recognized. Unlike most AXP288 devices,
560  * this model actually has mostly working ACPI AC / Battery code, the ACPI code
561  * "solves" this by simply setting the input_current_limit to 3A.
562  * There are still some issues with the ACPI code, so we use this native driver,
563  * and to solve the charging not working (500mA is not enough) issue we hardcode
564  * the 3A input_current_limit like the ACPI code does.
565  *
566  * 2. If no charger is connected the machine boots with the vbus-path disabled.
567  * Normally this is done when a 5V boost converter is active to avoid the PMIC
568  * trying to charge from the 5V boost converter's output. This is done when
569  * an OTG host cable is inserted and the ID pin on the micro-B receptacle is
570  * pulled low and the ID pin has an ACPI event handler associated with it
571  * which re-enables the vbus-path when the ID pin is pulled high when the
572  * OTG host cable is removed. The Type-C connector has no ID pin, there is
573  * no ID pin handler and there appears to be no 5V boost converter, so we
574  * end up not charging because the vbus-path is disabled, until we unplug
575  * the charger which automatically clears the vbus-path disable bit and then
576  * on the second plug-in of the adapter we start charging. To solve the not
577  * charging on first charger plugin we unconditionally enable the vbus-path at
578  * probe on this model, which is safe since there is no 5V boost converter.
579  */
580 static const struct dmi_system_id axp288_hp_x2_dmi_ids[] = {
581 	{
582 		.matches = {
583 			DMI_EXACT_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
584 			DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "HP Pavilion x2 Detachable"),
585 			DMI_EXACT_MATCH(DMI_BOARD_NAME, "815D"),
586 		},
587 	},
588 	{
589 		.matches = {
590 			DMI_EXACT_MATCH(DMI_SYS_VENDOR, "HP"),
591 			DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "HP Pavilion x2 Detachable"),
592 			DMI_EXACT_MATCH(DMI_BOARD_NAME, "813E"),
593 		},
594 	},
595 	{} /* Terminating entry */
596 };
597 
598 static void axp288_charger_extcon_evt_worker(struct work_struct *work)
599 {
600 	struct axp288_chrg_info *info =
601 	    container_of(work, struct axp288_chrg_info, cable.work);
602 	int ret, current_limit;
603 	struct extcon_dev *edev = info->cable.edev;
604 	unsigned int val;
605 
606 	ret = regmap_read(info->regmap, AXP20X_PWR_INPUT_STATUS, &val);
607 	if (ret < 0) {
608 		dev_err(&info->pdev->dev, "Error reading status (%d)\n", ret);
609 		return;
610 	}
611 
612 	/* Offline? Disable charging and bail */
613 	if (!(val & PS_STAT_VBUS_VALID)) {
614 		dev_dbg(&info->pdev->dev, "USB charger disconnected\n");
615 		axp288_charger_enable_charger(info, false);
616 		power_supply_changed(info->psy_usb);
617 		return;
618 	}
619 
620 	/* Determine cable/charger type */
621 	if (dmi_check_system(axp288_hp_x2_dmi_ids)) {
622 		/* See comment above axp288_hp_x2_dmi_ids declaration */
623 		dev_dbg(&info->pdev->dev, "HP X2 with Type-C, setting inlmt to 3A\n");
624 		current_limit = 3000000;
625 	} else if (extcon_get_state(edev, EXTCON_CHG_USB_SDP) > 0) {
626 		dev_dbg(&info->pdev->dev, "USB SDP charger is connected\n");
627 		current_limit = 500000;
628 	} else if (extcon_get_state(edev, EXTCON_CHG_USB_CDP) > 0) {
629 		dev_dbg(&info->pdev->dev, "USB CDP charger is connected\n");
630 		current_limit = 1500000;
631 	} else if (extcon_get_state(edev, EXTCON_CHG_USB_DCP) > 0) {
632 		dev_dbg(&info->pdev->dev, "USB DCP charger is connected\n");
633 		current_limit = 2000000;
634 	} else {
635 		/* Charger type detection still in progress, bail. */
636 		return;
637 	}
638 
639 	/* Set vbus current limit first, then enable charger */
640 	ret = axp288_charger_set_vbus_inlmt(info, current_limit);
641 	if (ret == 0)
642 		axp288_charger_enable_charger(info, true);
643 	else
644 		dev_err(&info->pdev->dev,
645 			"error setting current limit (%d)\n", ret);
646 
647 	power_supply_changed(info->psy_usb);
648 }
649 
650 static int axp288_charger_handle_cable_evt(struct notifier_block *nb,
651 					   unsigned long event, void *param)
652 {
653 	struct axp288_chrg_info *info =
654 		container_of(nb, struct axp288_chrg_info, cable.nb);
655 	schedule_work(&info->cable.work);
656 	return NOTIFY_OK;
657 }
658 
659 static void axp288_charger_otg_evt_worker(struct work_struct *work)
660 {
661 	struct axp288_chrg_info *info =
662 	    container_of(work, struct axp288_chrg_info, otg.work);
663 	struct extcon_dev *edev = info->otg.cable;
664 	int ret, usb_host = extcon_get_state(edev, EXTCON_USB_HOST);
665 
666 	dev_dbg(&info->pdev->dev, "external connector USB-Host is %s\n",
667 				usb_host ? "attached" : "detached");
668 
669 	/*
670 	 * Set usb_id_short flag to avoid running charger detection logic
671 	 * in case usb host.
672 	 */
673 	info->otg.id_short = usb_host;
674 
675 	/* Disable VBUS path before enabling the 5V boost */
676 	ret = axp288_charger_vbus_path_select(info, !info->otg.id_short);
677 	if (ret < 0)
678 		dev_warn(&info->pdev->dev, "vbus path disable failed\n");
679 }
680 
681 static int axp288_charger_handle_otg_evt(struct notifier_block *nb,
682 				   unsigned long event, void *param)
683 {
684 	struct axp288_chrg_info *info =
685 	    container_of(nb, struct axp288_chrg_info, otg.id_nb);
686 
687 	schedule_work(&info->otg.work);
688 
689 	return NOTIFY_OK;
690 }
691 
692 static int charger_init_hw_regs(struct axp288_chrg_info *info)
693 {
694 	int ret, cc, cv;
695 	unsigned int val;
696 
697 	/* Program temperature thresholds */
698 	ret = regmap_write(info->regmap, AXP20X_V_LTF_CHRG, CHRG_VLTFC_0C);
699 	if (ret < 0) {
700 		dev_err(&info->pdev->dev, "register(%x) write error(%d)\n",
701 							AXP20X_V_LTF_CHRG, ret);
702 		return ret;
703 	}
704 
705 	ret = regmap_write(info->regmap, AXP20X_V_HTF_CHRG, CHRG_VHTFC_45C);
706 	if (ret < 0) {
707 		dev_err(&info->pdev->dev, "register(%x) write error(%d)\n",
708 							AXP20X_V_HTF_CHRG, ret);
709 		return ret;
710 	}
711 
712 	/* Do not turn-off charger o/p after charge cycle ends */
713 	ret = regmap_update_bits(info->regmap,
714 				AXP20X_CHRG_CTRL2,
715 				CNTL2_CHG_OUT_TURNON, CNTL2_CHG_OUT_TURNON);
716 	if (ret < 0) {
717 		dev_err(&info->pdev->dev, "register(%x) write error(%d)\n",
718 						AXP20X_CHRG_CTRL2, ret);
719 		return ret;
720 	}
721 
722 	/* Setup ending condition for charging to be 10% of I(chrg) */
723 	ret = regmap_update_bits(info->regmap,
724 				AXP20X_CHRG_CTRL1,
725 				CHRG_CCCV_ITERM_20P, 0);
726 	if (ret < 0) {
727 		dev_err(&info->pdev->dev, "register(%x) write error(%d)\n",
728 						AXP20X_CHRG_CTRL1, ret);
729 		return ret;
730 	}
731 
732 	/* Disable OCV-SOC curve calibration */
733 	ret = regmap_update_bits(info->regmap,
734 				AXP20X_CC_CTRL,
735 				FG_CNTL_OCV_ADJ_EN, 0);
736 	if (ret < 0) {
737 		dev_err(&info->pdev->dev, "register(%x) write error(%d)\n",
738 						AXP20X_CC_CTRL, ret);
739 		return ret;
740 	}
741 
742 	if (dmi_check_system(axp288_hp_x2_dmi_ids)) {
743 		/* See comment above axp288_hp_x2_dmi_ids declaration */
744 		ret = axp288_charger_vbus_path_select(info, true);
745 		if (ret < 0)
746 			return ret;
747 	}
748 
749 	/* Read current charge voltage and current limit */
750 	ret = regmap_read(info->regmap, AXP20X_CHRG_CTRL1, &val);
751 	if (ret < 0) {
752 		dev_err(&info->pdev->dev, "register(%x) read error(%d)\n",
753 			AXP20X_CHRG_CTRL1, ret);
754 		return ret;
755 	}
756 
757 	/* Determine charge voltage */
758 	cv = (val & CHRG_CCCV_CV_MASK) >> CHRG_CCCV_CV_BIT_POS;
759 	switch (cv) {
760 	case CHRG_CCCV_CV_4100MV:
761 		info->cv = CV_4100MV;
762 		break;
763 	case CHRG_CCCV_CV_4150MV:
764 		info->cv = CV_4150MV;
765 		break;
766 	case CHRG_CCCV_CV_4200MV:
767 		info->cv = CV_4200MV;
768 		break;
769 	case CHRG_CCCV_CV_4350MV:
770 		info->cv = CV_4350MV;
771 		break;
772 	}
773 
774 	/* Determine charge current limit */
775 	cc = (val & CHRG_CCCV_CC_MASK) >> CHRG_CCCV_CC_BIT_POS;
776 	cc = (cc * CHRG_CCCV_CC_LSB_RES) + CHRG_CCCV_CC_OFFSET;
777 	info->cc = cc;
778 
779 	/*
780 	 * Do not allow the user to configure higher settings then those
781 	 * set by the firmware
782 	 */
783 	info->max_cv = info->cv;
784 	info->max_cc = info->cc;
785 
786 	return 0;
787 }
788 
789 static void axp288_charger_cancel_work(void *data)
790 {
791 	struct axp288_chrg_info *info = data;
792 
793 	cancel_work_sync(&info->otg.work);
794 	cancel_work_sync(&info->cable.work);
795 }
796 
797 static int axp288_charger_probe(struct platform_device *pdev)
798 {
799 	int ret, i, pirq;
800 	struct axp288_chrg_info *info;
801 	struct device *dev = &pdev->dev;
802 	struct axp20x_dev *axp20x = dev_get_drvdata(pdev->dev.parent);
803 	struct power_supply_config charger_cfg = {};
804 	unsigned int val;
805 
806 	/*
807 	 * On some devices the fuelgauge and charger parts of the axp288 are
808 	 * not used, check that the fuelgauge is enabled (CC_CTRL != 0).
809 	 */
810 	ret = regmap_read(axp20x->regmap, AXP20X_CC_CTRL, &val);
811 	if (ret < 0)
812 		return ret;
813 	if (val == 0)
814 		return -ENODEV;
815 
816 	info = devm_kzalloc(&pdev->dev, sizeof(*info), GFP_KERNEL);
817 	if (!info)
818 		return -ENOMEM;
819 
820 	info->pdev = pdev;
821 	info->regmap = axp20x->regmap;
822 	info->regmap_irqc = axp20x->regmap_irqc;
823 
824 	info->cable.edev = extcon_get_extcon_dev(AXP288_EXTCON_DEV_NAME);
825 	if (info->cable.edev == NULL) {
826 		dev_dbg(&pdev->dev, "%s is not ready, probe deferred\n",
827 			AXP288_EXTCON_DEV_NAME);
828 		return -EPROBE_DEFER;
829 	}
830 
831 	if (acpi_dev_present(USB_HOST_EXTCON_HID, NULL, -1)) {
832 		info->otg.cable = extcon_get_extcon_dev(USB_HOST_EXTCON_NAME);
833 		if (info->otg.cable == NULL) {
834 			dev_dbg(dev, "EXTCON_USB_HOST is not ready, probe deferred\n");
835 			return -EPROBE_DEFER;
836 		}
837 		dev_info(&pdev->dev,
838 			 "Using " USB_HOST_EXTCON_HID " extcon for usb-id\n");
839 	}
840 
841 	platform_set_drvdata(pdev, info);
842 
843 	ret = charger_init_hw_regs(info);
844 	if (ret)
845 		return ret;
846 
847 	/* Register with power supply class */
848 	charger_cfg.drv_data = info;
849 	info->psy_usb = devm_power_supply_register(dev, &axp288_charger_desc,
850 						   &charger_cfg);
851 	if (IS_ERR(info->psy_usb)) {
852 		ret = PTR_ERR(info->psy_usb);
853 		dev_err(dev, "failed to register power supply: %d\n", ret);
854 		return ret;
855 	}
856 
857 	/* Cancel our work on cleanup, register this before the notifiers */
858 	ret = devm_add_action(dev, axp288_charger_cancel_work, info);
859 	if (ret)
860 		return ret;
861 
862 	/* Register for extcon notification */
863 	INIT_WORK(&info->cable.work, axp288_charger_extcon_evt_worker);
864 	info->cable.nb.notifier_call = axp288_charger_handle_cable_evt;
865 	ret = devm_extcon_register_notifier_all(dev, info->cable.edev,
866 						&info->cable.nb);
867 	if (ret) {
868 		dev_err(dev, "failed to register cable extcon notifier\n");
869 		return ret;
870 	}
871 	schedule_work(&info->cable.work);
872 
873 	/* Register for OTG notification */
874 	INIT_WORK(&info->otg.work, axp288_charger_otg_evt_worker);
875 	info->otg.id_nb.notifier_call = axp288_charger_handle_otg_evt;
876 	if (info->otg.cable) {
877 		ret = devm_extcon_register_notifier(&pdev->dev, info->otg.cable,
878 					EXTCON_USB_HOST, &info->otg.id_nb);
879 		if (ret) {
880 			dev_err(dev, "failed to register EXTCON_USB_HOST notifier\n");
881 			return ret;
882 		}
883 		schedule_work(&info->otg.work);
884 	}
885 
886 	/* Register charger interrupts */
887 	for (i = 0; i < CHRG_INTR_END; i++) {
888 		pirq = platform_get_irq(info->pdev, i);
889 		if (pirq < 0)
890 			return pirq;
891 
892 		info->irq[i] = regmap_irq_get_virq(info->regmap_irqc, pirq);
893 		if (info->irq[i] < 0) {
894 			dev_warn(&info->pdev->dev,
895 				"failed to get virtual interrupt=%d\n", pirq);
896 			return info->irq[i];
897 		}
898 		ret = devm_request_threaded_irq(&info->pdev->dev, info->irq[i],
899 					NULL, axp288_charger_irq_thread_handler,
900 					IRQF_ONESHOT, info->pdev->name, info);
901 		if (ret) {
902 			dev_err(&pdev->dev, "failed to request interrupt=%d\n",
903 								info->irq[i]);
904 			return ret;
905 		}
906 	}
907 
908 	return 0;
909 }
910 
911 static const struct platform_device_id axp288_charger_id_table[] = {
912 	{ .name = "axp288_charger" },
913 	{},
914 };
915 MODULE_DEVICE_TABLE(platform, axp288_charger_id_table);
916 
917 static struct platform_driver axp288_charger_driver = {
918 	.probe = axp288_charger_probe,
919 	.id_table = axp288_charger_id_table,
920 	.driver = {
921 		.name = "axp288_charger",
922 	},
923 };
924 
925 module_platform_driver(axp288_charger_driver);
926 
927 MODULE_AUTHOR("Ramakrishna Pallala <ramakrishna.pallala@intel.com>");
928 MODULE_DESCRIPTION("X-power AXP288 Charger Driver");
929 MODULE_LICENSE("GPL v2");
930