1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * extcon-axp288.c - X-Power AXP288 PMIC extcon cable detection driver
4  *
5  * Copyright (c) 2017-2018 Hans de Goede <hdegoede@redhat.com>
6  * Copyright (C) 2015 Intel Corporation
7  * Author: Ramakrishna Pallala <ramakrishna.pallala@intel.com>
8  */
9 
10 #include <linux/acpi.h>
11 #include <linux/module.h>
12 #include <linux/kernel.h>
13 #include <linux/io.h>
14 #include <linux/slab.h>
15 #include <linux/interrupt.h>
16 #include <linux/platform_device.h>
17 #include <linux/property.h>
18 #include <linux/notifier.h>
19 #include <linux/extcon-provider.h>
20 #include <linux/regmap.h>
21 #include <linux/mfd/axp20x.h>
22 #include <linux/usb/role.h>
23 #include <linux/workqueue.h>
24 
25 #include <asm/cpu_device_id.h>
26 #include <asm/intel-family.h>
27 
28 /* Power source status register */
29 #define PS_STAT_VBUS_TRIGGER		BIT(0)
30 #define PS_STAT_BAT_CHRG_DIR		BIT(2)
31 #define PS_STAT_VBUS_ABOVE_VHOLD	BIT(3)
32 #define PS_STAT_VBUS_VALID		BIT(4)
33 #define PS_STAT_VBUS_PRESENT		BIT(5)
34 
35 /* BC module global register */
36 #define BC_GLOBAL_RUN			BIT(0)
37 #define BC_GLOBAL_DET_STAT		BIT(2)
38 #define BC_GLOBAL_DBP_TOUT		BIT(3)
39 #define BC_GLOBAL_VLGC_COM_SEL		BIT(4)
40 #define BC_GLOBAL_DCD_TOUT_MASK		(BIT(6)|BIT(5))
41 #define BC_GLOBAL_DCD_TOUT_300MS	0
42 #define BC_GLOBAL_DCD_TOUT_100MS	1
43 #define BC_GLOBAL_DCD_TOUT_500MS	2
44 #define BC_GLOBAL_DCD_TOUT_900MS	3
45 #define BC_GLOBAL_DCD_DET_SEL		BIT(7)
46 
47 /* BC module vbus control and status register */
48 #define VBUS_CNTL_DPDM_PD_EN		BIT(4)
49 #define VBUS_CNTL_DPDM_FD_EN		BIT(5)
50 #define VBUS_CNTL_FIRST_PO_STAT		BIT(6)
51 
52 /* BC USB status register */
53 #define USB_STAT_BUS_STAT_MASK		(BIT(3)|BIT(2)|BIT(1)|BIT(0))
54 #define USB_STAT_BUS_STAT_SHIFT		0
55 #define USB_STAT_BUS_STAT_ATHD		0
56 #define USB_STAT_BUS_STAT_CONN		1
57 #define USB_STAT_BUS_STAT_SUSP		2
58 #define USB_STAT_BUS_STAT_CONF		3
59 #define USB_STAT_USB_SS_MODE		BIT(4)
60 #define USB_STAT_DEAD_BAT_DET		BIT(6)
61 #define USB_STAT_DBP_UNCFG		BIT(7)
62 
63 /* BC detect status register */
64 #define DET_STAT_MASK			(BIT(7)|BIT(6)|BIT(5))
65 #define DET_STAT_SHIFT			5
66 #define DET_STAT_SDP			1
67 #define DET_STAT_CDP			2
68 #define DET_STAT_DCP			3
69 
70 enum axp288_extcon_reg {
71 	AXP288_PS_STAT_REG		= 0x00,
72 	AXP288_PS_BOOT_REASON_REG	= 0x02,
73 	AXP288_BC_GLOBAL_REG		= 0x2c,
74 	AXP288_BC_VBUS_CNTL_REG		= 0x2d,
75 	AXP288_BC_USB_STAT_REG		= 0x2e,
76 	AXP288_BC_DET_STAT_REG		= 0x2f,
77 };
78 
79 enum axp288_extcon_irq {
80 	VBUS_FALLING_IRQ = 0,
81 	VBUS_RISING_IRQ,
82 	MV_CHNG_IRQ,
83 	BC_USB_CHNG_IRQ,
84 	EXTCON_IRQ_END,
85 };
86 
87 static const unsigned int axp288_extcon_cables[] = {
88 	EXTCON_CHG_USB_SDP,
89 	EXTCON_CHG_USB_CDP,
90 	EXTCON_CHG_USB_DCP,
91 	EXTCON_USB,
92 	EXTCON_NONE,
93 };
94 
95 struct axp288_extcon_info {
96 	struct device *dev;
97 	struct regmap *regmap;
98 	struct regmap_irq_chip_data *regmap_irqc;
99 	struct usb_role_switch *role_sw;
100 	struct work_struct role_work;
101 	int irq[EXTCON_IRQ_END];
102 	struct extcon_dev *edev;
103 	struct extcon_dev *id_extcon;
104 	struct notifier_block id_nb;
105 	unsigned int previous_cable;
106 	bool vbus_attach;
107 };
108 
109 static const struct x86_cpu_id cherry_trail_cpu_ids[] = {
110 	{ X86_VENDOR_INTEL, 6, INTEL_FAM6_ATOM_AIRMONT, X86_FEATURE_ANY },
111 	{}
112 };
113 
114 /* Power up/down reason string array */
115 static const char * const axp288_pwr_up_down_info[] = {
116 	"Last wake caused by user pressing the power button",
117 	"Last wake caused by a charger insertion",
118 	"Last wake caused by a battery insertion",
119 	"Last wake caused by SOC initiated global reset",
120 	"Last wake caused by cold reset",
121 	"Last shutdown caused by PMIC UVLO threshold",
122 	"Last shutdown caused by SOC initiated cold off",
123 	"Last shutdown caused by user pressing the power button",
124 	NULL,
125 };
126 
127 /*
128  * Decode and log the given "reset source indicator" (rsi)
129  * register and then clear it.
130  */
131 static void axp288_extcon_log_rsi(struct axp288_extcon_info *info)
132 {
133 	const char * const *rsi;
134 	unsigned int val, i, clear_mask = 0;
135 	int ret;
136 
137 	ret = regmap_read(info->regmap, AXP288_PS_BOOT_REASON_REG, &val);
138 	for (i = 0, rsi = axp288_pwr_up_down_info; *rsi; rsi++, i++) {
139 		if (val & BIT(i)) {
140 			dev_dbg(info->dev, "%s\n", *rsi);
141 			clear_mask |= BIT(i);
142 		}
143 	}
144 
145 	/* Clear the register value for next reboot (write 1 to clear bit) */
146 	regmap_write(info->regmap, AXP288_PS_BOOT_REASON_REG, clear_mask);
147 }
148 
149 /*
150  * The below code to control the USB role-switch on devices with an AXP288
151  * may seem out of place, but there are 2 reasons why this is the best place
152  * to control the USB role-switch on such devices:
153  * 1) On many devices the USB role is controlled by AML code, but the AML code
154  *    only switches between the host and none roles, because of Windows not
155  *    really using device mode. To make device mode work we need to toggle
156  *    between the none/device roles based on Vbus presence, and this driver
157  *    gets interrupts on Vbus insertion / removal.
158  * 2) In order for our BC1.2 charger detection to work properly the role
159  *    mux must be properly set to device mode before we do the detection.
160  */
161 
162 /* Returns the id-pin value, note pulled low / false == host-mode */
163 static bool axp288_get_id_pin(struct axp288_extcon_info *info)
164 {
165 	enum usb_role role;
166 
167 	if (info->id_extcon)
168 		return extcon_get_state(info->id_extcon, EXTCON_USB_HOST) <= 0;
169 
170 	/* We cannot access the id-pin, see what mode the AML code has set */
171 	role = usb_role_switch_get_role(info->role_sw);
172 	return role != USB_ROLE_HOST;
173 }
174 
175 static void axp288_usb_role_work(struct work_struct *work)
176 {
177 	struct axp288_extcon_info *info =
178 		container_of(work, struct axp288_extcon_info, role_work);
179 	enum usb_role role;
180 	bool id_pin;
181 	int ret;
182 
183 	id_pin = axp288_get_id_pin(info);
184 	if (!id_pin)
185 		role = USB_ROLE_HOST;
186 	else if (info->vbus_attach)
187 		role = USB_ROLE_DEVICE;
188 	else
189 		role = USB_ROLE_NONE;
190 
191 	ret = usb_role_switch_set_role(info->role_sw, role);
192 	if (ret)
193 		dev_err(info->dev, "failed to set role: %d\n", ret);
194 }
195 
196 static bool axp288_get_vbus_attach(struct axp288_extcon_info *info)
197 {
198 	int ret, pwr_stat;
199 
200 	ret = regmap_read(info->regmap, AXP288_PS_STAT_REG, &pwr_stat);
201 	if (ret < 0) {
202 		dev_err(info->dev, "failed to read vbus status\n");
203 		return false;
204 	}
205 
206 	return !!(pwr_stat & PS_STAT_VBUS_VALID);
207 }
208 
209 static int axp288_handle_chrg_det_event(struct axp288_extcon_info *info)
210 {
211 	int ret, stat, cfg;
212 	u8 chrg_type;
213 	unsigned int cable = info->previous_cable;
214 	bool vbus_attach = false;
215 
216 	vbus_attach = axp288_get_vbus_attach(info);
217 	if (!vbus_attach)
218 		goto no_vbus;
219 
220 	/* Check charger detection completion status */
221 	ret = regmap_read(info->regmap, AXP288_BC_GLOBAL_REG, &cfg);
222 	if (ret < 0)
223 		goto dev_det_ret;
224 	if (cfg & BC_GLOBAL_DET_STAT) {
225 		dev_dbg(info->dev, "can't complete the charger detection\n");
226 		goto dev_det_ret;
227 	}
228 
229 	ret = regmap_read(info->regmap, AXP288_BC_DET_STAT_REG, &stat);
230 	if (ret < 0)
231 		goto dev_det_ret;
232 
233 	chrg_type = (stat & DET_STAT_MASK) >> DET_STAT_SHIFT;
234 
235 	switch (chrg_type) {
236 	case DET_STAT_SDP:
237 		dev_dbg(info->dev, "sdp cable is connected\n");
238 		cable = EXTCON_CHG_USB_SDP;
239 		break;
240 	case DET_STAT_CDP:
241 		dev_dbg(info->dev, "cdp cable is connected\n");
242 		cable = EXTCON_CHG_USB_CDP;
243 		break;
244 	case DET_STAT_DCP:
245 		dev_dbg(info->dev, "dcp cable is connected\n");
246 		cable = EXTCON_CHG_USB_DCP;
247 		break;
248 	default:
249 		dev_warn(info->dev, "unknown (reserved) bc detect result\n");
250 		cable = EXTCON_CHG_USB_SDP;
251 	}
252 
253 no_vbus:
254 	extcon_set_state_sync(info->edev, info->previous_cable, false);
255 	if (info->previous_cable == EXTCON_CHG_USB_SDP)
256 		extcon_set_state_sync(info->edev, EXTCON_USB, false);
257 
258 	if (vbus_attach) {
259 		extcon_set_state_sync(info->edev, cable, vbus_attach);
260 		if (cable == EXTCON_CHG_USB_SDP)
261 			extcon_set_state_sync(info->edev, EXTCON_USB,
262 						vbus_attach);
263 
264 		info->previous_cable = cable;
265 	}
266 
267 	if (info->role_sw && info->vbus_attach != vbus_attach) {
268 		info->vbus_attach = vbus_attach;
269 		/* Setting the role can take a while */
270 		queue_work(system_long_wq, &info->role_work);
271 	}
272 
273 	return 0;
274 
275 dev_det_ret:
276 	if (ret < 0)
277 		dev_err(info->dev, "failed to detect BC Mod\n");
278 
279 	return ret;
280 }
281 
282 static int axp288_extcon_id_evt(struct notifier_block *nb,
283 				unsigned long event, void *param)
284 {
285 	struct axp288_extcon_info *info =
286 		container_of(nb, struct axp288_extcon_info, id_nb);
287 
288 	/* We may not sleep and setting the role can take a while */
289 	queue_work(system_long_wq, &info->role_work);
290 
291 	return NOTIFY_OK;
292 }
293 
294 static irqreturn_t axp288_extcon_isr(int irq, void *data)
295 {
296 	struct axp288_extcon_info *info = data;
297 	int ret;
298 
299 	ret = axp288_handle_chrg_det_event(info);
300 	if (ret < 0)
301 		dev_err(info->dev, "failed to handle the interrupt\n");
302 
303 	return IRQ_HANDLED;
304 }
305 
306 static void axp288_extcon_enable(struct axp288_extcon_info *info)
307 {
308 	regmap_update_bits(info->regmap, AXP288_BC_GLOBAL_REG,
309 						BC_GLOBAL_RUN, 0);
310 	/* Enable the charger detection logic */
311 	regmap_update_bits(info->regmap, AXP288_BC_GLOBAL_REG,
312 					BC_GLOBAL_RUN, BC_GLOBAL_RUN);
313 }
314 
315 static void axp288_put_role_sw(void *data)
316 {
317 	struct axp288_extcon_info *info = data;
318 
319 	cancel_work_sync(&info->role_work);
320 	usb_role_switch_put(info->role_sw);
321 }
322 
323 static int axp288_extcon_probe(struct platform_device *pdev)
324 {
325 	struct axp288_extcon_info *info;
326 	struct axp20x_dev *axp20x = dev_get_drvdata(pdev->dev.parent);
327 	struct device *dev = &pdev->dev;
328 	struct acpi_device *adev;
329 	int ret, i, pirq;
330 
331 	info = devm_kzalloc(&pdev->dev, sizeof(*info), GFP_KERNEL);
332 	if (!info)
333 		return -ENOMEM;
334 
335 	info->dev = &pdev->dev;
336 	info->regmap = axp20x->regmap;
337 	info->regmap_irqc = axp20x->regmap_irqc;
338 	info->previous_cable = EXTCON_NONE;
339 	INIT_WORK(&info->role_work, axp288_usb_role_work);
340 	info->id_nb.notifier_call = axp288_extcon_id_evt;
341 
342 	platform_set_drvdata(pdev, info);
343 
344 	info->role_sw = usb_role_switch_get(dev);
345 	if (IS_ERR(info->role_sw))
346 		return PTR_ERR(info->role_sw);
347 	if (info->role_sw) {
348 		ret = devm_add_action_or_reset(dev, axp288_put_role_sw, info);
349 		if (ret)
350 			return ret;
351 
352 		adev = acpi_dev_get_first_match_dev("INT3496", NULL, -1);
353 		if (adev) {
354 			info->id_extcon = extcon_get_extcon_dev(acpi_dev_name(adev));
355 			put_device(&adev->dev);
356 			if (!info->id_extcon)
357 				return -EPROBE_DEFER;
358 
359 			dev_info(dev, "controlling USB role\n");
360 		} else {
361 			dev_info(dev, "controlling USB role based on Vbus presence\n");
362 		}
363 	}
364 
365 	info->vbus_attach = axp288_get_vbus_attach(info);
366 
367 	axp288_extcon_log_rsi(info);
368 
369 	/* Initialize extcon device */
370 	info->edev = devm_extcon_dev_allocate(&pdev->dev,
371 					      axp288_extcon_cables);
372 	if (IS_ERR(info->edev)) {
373 		dev_err(&pdev->dev, "failed to allocate memory for extcon\n");
374 		return PTR_ERR(info->edev);
375 	}
376 
377 	/* Register extcon device */
378 	ret = devm_extcon_dev_register(&pdev->dev, info->edev);
379 	if (ret) {
380 		dev_err(&pdev->dev, "failed to register extcon device\n");
381 		return ret;
382 	}
383 
384 	for (i = 0; i < EXTCON_IRQ_END; i++) {
385 		pirq = platform_get_irq(pdev, i);
386 		if (pirq < 0)
387 			return pirq;
388 
389 		info->irq[i] = regmap_irq_get_virq(info->regmap_irqc, pirq);
390 		if (info->irq[i] < 0) {
391 			dev_err(&pdev->dev,
392 				"failed to get virtual interrupt=%d\n", pirq);
393 			ret = info->irq[i];
394 			return ret;
395 		}
396 
397 		ret = devm_request_threaded_irq(&pdev->dev, info->irq[i],
398 				NULL, axp288_extcon_isr,
399 				IRQF_ONESHOT | IRQF_NO_SUSPEND,
400 				pdev->name, info);
401 		if (ret) {
402 			dev_err(&pdev->dev, "failed to request interrupt=%d\n",
403 							info->irq[i]);
404 			return ret;
405 		}
406 	}
407 
408 	if (info->id_extcon) {
409 		ret = devm_extcon_register_notifier_all(dev, info->id_extcon,
410 							&info->id_nb);
411 		if (ret)
412 			return ret;
413 	}
414 
415 	/* Make sure the role-sw is set correctly before doing BC detection */
416 	if (info->role_sw) {
417 		queue_work(system_long_wq, &info->role_work);
418 		flush_work(&info->role_work);
419 	}
420 
421 	/* Start charger cable type detection */
422 	axp288_extcon_enable(info);
423 
424 	return 0;
425 }
426 
427 static const struct platform_device_id axp288_extcon_table[] = {
428 	{ .name = "axp288_extcon" },
429 	{},
430 };
431 MODULE_DEVICE_TABLE(platform, axp288_extcon_table);
432 
433 static struct platform_driver axp288_extcon_driver = {
434 	.probe = axp288_extcon_probe,
435 	.id_table = axp288_extcon_table,
436 	.driver = {
437 		.name = "axp288_extcon",
438 	},
439 };
440 
441 static struct device_connection axp288_extcon_role_sw_conn = {
442 	.endpoint[0] = "axp288_extcon",
443 	.endpoint[1] = "intel_xhci_usb_sw-role-switch",
444 	.id = "usb-role-switch",
445 };
446 
447 static int __init axp288_extcon_init(void)
448 {
449 	if (x86_match_cpu(cherry_trail_cpu_ids))
450 		device_connection_add(&axp288_extcon_role_sw_conn);
451 
452 	return platform_driver_register(&axp288_extcon_driver);
453 }
454 module_init(axp288_extcon_init);
455 
456 static void __exit axp288_extcon_exit(void)
457 {
458 	if (x86_match_cpu(cherry_trail_cpu_ids))
459 		device_connection_remove(&axp288_extcon_role_sw_conn);
460 
461 	platform_driver_unregister(&axp288_extcon_driver);
462 }
463 module_exit(axp288_extcon_exit);
464 
465 MODULE_AUTHOR("Ramakrishna Pallala <ramakrishna.pallala@intel.com>");
466 MODULE_AUTHOR("Hans de Goede <hdegoede@redhat.com>");
467 MODULE_DESCRIPTION("X-Powers AXP288 extcon driver");
468 MODULE_LICENSE("GPL v2");
469