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