[linux-2.6-block.git] / drivers / extcon / extcon-axp288.c

/*
 * extcon-axp288.c - X-Power AXP288 PMIC extcon cable detection driver
 *
 * Copyright (c) 2017-2018 Hans de Goede <hdegoede@redhat.com>
 * Copyright (C) 2015 Intel Corporation
 * Author: Ramakrishna Pallala <ramakrishna.pallala@intel.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 */

#include <linux/acpi.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/io.h>
#include <linux/slab.h>
#include <linux/interrupt.h>
#include <linux/platform_device.h>
#include <linux/property.h>
#include <linux/notifier.h>
#include <linux/extcon-provider.h>
#include <linux/regmap.h>
#include <linux/mfd/axp20x.h>
#include <linux/usb/role.h>
#include <linux/workqueue.h>

#include <asm/cpu_device_id.h>
#include <asm/intel-family.h>

/* Power source status register */
#define PS_STAT_VBUS_TRIGGER		BIT(0)
#define PS_STAT_BAT_CHRG_DIR		BIT(2)
#define PS_STAT_VBUS_ABOVE_VHOLD	BIT(3)
#define PS_STAT_VBUS_VALID		BIT(4)
#define PS_STAT_VBUS_PRESENT		BIT(5)

/* BC module global register */
#define BC_GLOBAL_RUN			BIT(0)
#define BC_GLOBAL_DET_STAT		BIT(2)
#define BC_GLOBAL_DBP_TOUT		BIT(3)
#define BC_GLOBAL_VLGC_COM_SEL		BIT(4)
#define BC_GLOBAL_DCD_TOUT_MASK		(BIT(6)|BIT(5))
#define BC_GLOBAL_DCD_TOUT_300MS	0
#define BC_GLOBAL_DCD_TOUT_100MS	1
#define BC_GLOBAL_DCD_TOUT_500MS	2
#define BC_GLOBAL_DCD_TOUT_900MS	3
#define BC_GLOBAL_DCD_DET_SEL		BIT(7)

/* BC module vbus control and status register */
#define VBUS_CNTL_DPDM_PD_EN		BIT(4)
#define VBUS_CNTL_DPDM_FD_EN		BIT(5)
#define VBUS_CNTL_FIRST_PO_STAT		BIT(6)

/* BC USB status register */
#define USB_STAT_BUS_STAT_MASK		(BIT(3)|BIT(2)|BIT(1)|BIT(0))
#define USB_STAT_BUS_STAT_SHIFT		0
#define USB_STAT_BUS_STAT_ATHD		0
#define USB_STAT_BUS_STAT_CONN		1
#define USB_STAT_BUS_STAT_SUSP		2
#define USB_STAT_BUS_STAT_CONF		3
#define USB_STAT_USB_SS_MODE		BIT(4)
#define USB_STAT_DEAD_BAT_DET		BIT(6)
#define USB_STAT_DBP_UNCFG		BIT(7)

/* BC detect status register */
#define DET_STAT_MASK			(BIT(7)|BIT(6)|BIT(5))
#define DET_STAT_SHIFT			5
#define DET_STAT_SDP			1
#define DET_STAT_CDP			2
#define DET_STAT_DCP			3

enum axp288_extcon_reg {
	AXP288_PS_STAT_REG		= 0x00,
	AXP288_PS_BOOT_REASON_REG	= 0x02,
	AXP288_BC_GLOBAL_REG		= 0x2c,
	AXP288_BC_VBUS_CNTL_REG		= 0x2d,
	AXP288_BC_USB_STAT_REG		= 0x2e,
	AXP288_BC_DET_STAT_REG		= 0x2f,
};

enum axp288_extcon_irq {
	VBUS_FALLING_IRQ = 0,
	VBUS_RISING_IRQ,
	MV_CHNG_IRQ,
	BC_USB_CHNG_IRQ,
	EXTCON_IRQ_END,
};

static const unsigned int axp288_extcon_cables[] = {
	EXTCON_CHG_USB_SDP,
	EXTCON_CHG_USB_CDP,
	EXTCON_CHG_USB_DCP,
	EXTCON_USB,
	EXTCON_NONE,
};

struct axp288_extcon_info {
	struct device *dev;
	struct regmap *regmap;
	struct regmap_irq_chip_data *regmap_irqc;
	struct usb_role_switch *role_sw;
	struct work_struct role_work;
	int irq[EXTCON_IRQ_END];
	struct extcon_dev *edev;
	struct extcon_dev *id_extcon;
	struct notifier_block id_nb;
	unsigned int previous_cable;
	bool vbus_attach;
};

static const struct x86_cpu_id cherry_trail_cpu_ids[] = {
	{ X86_VENDOR_INTEL, 6, INTEL_FAM6_ATOM_AIRMONT, X86_FEATURE_ANY },
	{}
};

/* Power up/down reason string array */
static const char * const axp288_pwr_up_down_info[] = {
	"Last wake caused by user pressing the power button",
	"Last wake caused by a charger insertion",
	"Last wake caused by a battery insertion",
	"Last wake caused by SOC initiated global reset",
	"Last wake caused by cold reset",
	"Last shutdown caused by PMIC UVLO threshold",
	"Last shutdown caused by SOC initiated cold off",
	"Last shutdown caused by user pressing the power button",
	NULL,
};

/*
 * Decode and log the given "reset source indicator" (rsi)
 * register and then clear it.
 */
static void axp288_extcon_log_rsi(struct axp288_extcon_info *info)
{
	const char * const *rsi;
	unsigned int val, i, clear_mask = 0;
	int ret;

	ret = regmap_read(info->regmap, AXP288_PS_BOOT_REASON_REG, &val);
	for (i = 0, rsi = axp288_pwr_up_down_info; *rsi; rsi++, i++) {
		if (val & BIT(i)) {
			dev_dbg(info->dev, "%s\n", *rsi);
			clear_mask |= BIT(i);
		}
	}

	/* Clear the register value for next reboot (write 1 to clear bit) */
	regmap_write(info->regmap, AXP288_PS_BOOT_REASON_REG, clear_mask);
}

/*
 * The below code to control the USB role-switch on devices with an AXP288
 * may seem out of place, but there are 2 reasons why this is the best place
 * to control the USB role-switch on such devices:
 * 1) On many devices the USB role is controlled by AML code, but the AML code
 *    only switches between the host and none roles, because of Windows not
 *    really using device mode. To make device mode work we need to toggle
 *    between the none/device roles based on Vbus presence, and this driver
 *    gets interrupts on Vbus insertion / removal.
 * 2) In order for our BC1.2 charger detection to work properly the role
 *    mux must be properly set to device mode before we do the detection.
 */

/* Returns the id-pin value, note pulled low / false == host-mode */
static bool axp288_get_id_pin(struct axp288_extcon_info *info)
{
	enum usb_role role;

	if (info->id_extcon)
		return extcon_get_state(info->id_extcon, EXTCON_USB_HOST) <= 0;

	/* We cannot access the id-pin, see what mode the AML code has set */
	role = usb_role_switch_get_role(info->role_sw);
	return role != USB_ROLE_HOST;
}

static void axp288_usb_role_work(struct work_struct *work)
{
	struct axp288_extcon_info *info =
		container_of(work, struct axp288_extcon_info, role_work);
	enum usb_role role;
	bool id_pin;
	int ret;

	id_pin = axp288_get_id_pin(info);
	if (!id_pin)
		role = USB_ROLE_HOST;
	else if (info->vbus_attach)
		role = USB_ROLE_DEVICE;
	else
		role = USB_ROLE_NONE;

	ret = usb_role_switch_set_role(info->role_sw, role);
	if (ret)
		dev_err(info->dev, "failed to set role: %d\n", ret);
}

static bool axp288_get_vbus_attach(struct axp288_extcon_info *info)
{
	int ret, pwr_stat;

	ret = regmap_read(info->regmap, AXP288_PS_STAT_REG, &pwr_stat);
	if (ret < 0) {
		dev_err(info->dev, "failed to read vbus status\n");
		return false;
	}

	return !!(pwr_stat & PS_STAT_VBUS_VALID);
}

static int axp288_handle_chrg_det_event(struct axp288_extcon_info *info)
{
	int ret, stat, cfg;
	u8 chrg_type;
	unsigned int cable = info->previous_cable;
	bool vbus_attach = false;

	vbus_attach = axp288_get_vbus_attach(info);
	if (!vbus_attach)
		goto no_vbus;

	/* Check charger detection completion status */
	ret = regmap_read(info->regmap, AXP288_BC_GLOBAL_REG, &cfg);
	if (ret < 0)
		goto dev_det_ret;
	if (cfg & BC_GLOBAL_DET_STAT) {
		dev_dbg(info->dev, "can't complete the charger detection\n");
		goto dev_det_ret;
	}

	ret = regmap_read(info->regmap, AXP288_BC_DET_STAT_REG, &stat);
	if (ret < 0)
		goto dev_det_ret;

	chrg_type = (stat & DET_STAT_MASK) >> DET_STAT_SHIFT;

	switch (chrg_type) {
	case DET_STAT_SDP:
		dev_dbg(info->dev, "sdp cable is connected\n");
		cable = EXTCON_CHG_USB_SDP;
		break;
	case DET_STAT_CDP:
		dev_dbg(info->dev, "cdp cable is connected\n");
		cable = EXTCON_CHG_USB_CDP;
		break;
	case DET_STAT_DCP:
		dev_dbg(info->dev, "dcp cable is connected\n");
		cable = EXTCON_CHG_USB_DCP;
		break;
	default:
		dev_warn(info->dev, "unknown (reserved) bc detect result\n");
		cable = EXTCON_CHG_USB_SDP;
	}

no_vbus:
	extcon_set_state_sync(info->edev, info->previous_cable, false);
	if (info->previous_cable == EXTCON_CHG_USB_SDP)
		extcon_set_state_sync(info->edev, EXTCON_USB, false);

	if (vbus_attach) {
		extcon_set_state_sync(info->edev, cable, vbus_attach);
		if (cable == EXTCON_CHG_USB_SDP)
			extcon_set_state_sync(info->edev, EXTCON_USB,
						vbus_attach);

		info->previous_cable = cable;
	}

	if (info->role_sw && info->vbus_attach != vbus_attach) {
		info->vbus_attach = vbus_attach;
		/* Setting the role can take a while */
		queue_work(system_long_wq, &info->role_work);
	}

	return 0;

dev_det_ret:
	if (ret < 0)
		dev_err(info->dev, "failed to detect BC Mod\n");

	return ret;
}

static int axp288_extcon_id_evt(struct notifier_block *nb,
				unsigned long event, void *param)
{
	struct axp288_extcon_info *info =
		container_of(nb, struct axp288_extcon_info, id_nb);

	/* We may not sleep and setting the role can take a while */
	queue_work(system_long_wq, &info->role_work);

	return NOTIFY_OK;
}

static irqreturn_t axp288_extcon_isr(int irq, void *data)
{
	struct axp288_extcon_info *info = data;
	int ret;

	ret = axp288_handle_chrg_det_event(info);
	if (ret < 0)
		dev_err(info->dev, "failed to handle the interrupt\n");

	return IRQ_HANDLED;
}

static void axp288_extcon_enable(struct axp288_extcon_info *info)
{
	regmap_update_bits(info->regmap, AXP288_BC_GLOBAL_REG,
						BC_GLOBAL_RUN, 0);
	/* Enable the charger detection logic */
	regmap_update_bits(info->regmap, AXP288_BC_GLOBAL_REG,
					BC_GLOBAL_RUN, BC_GLOBAL_RUN);
}

static void axp288_put_role_sw(void *data)
{
	struct axp288_extcon_info *info = data;

	cancel_work_sync(&info->role_work);
	usb_role_switch_put(info->role_sw);
}

static int axp288_extcon_probe(struct platform_device *pdev)
{
	struct axp288_extcon_info *info;
	struct axp20x_dev *axp20x = dev_get_drvdata(pdev->dev.parent);
	struct device *dev = &pdev->dev;
	const char *name;
	int ret, i, pirq;

	info = devm_kzalloc(&pdev->dev, sizeof(*info), GFP_KERNEL);
	if (!info)
		return -ENOMEM;

	info->dev = &pdev->dev;
	info->regmap = axp20x->regmap;
	info->regmap_irqc = axp20x->regmap_irqc;
	info->previous_cable = EXTCON_NONE;
	INIT_WORK(&info->role_work, axp288_usb_role_work);
	info->id_nb.notifier_call = axp288_extcon_id_evt;

	platform_set_drvdata(pdev, info);

	info->role_sw = usb_role_switch_get(dev);
	if (IS_ERR(info->role_sw))
		return PTR_ERR(info->role_sw);
	if (info->role_sw) {
		ret = devm_add_action_or_reset(dev, axp288_put_role_sw, info);
		if (ret)
			return ret;

		name = acpi_dev_get_first_match_name("INT3496", NULL, -1);
		if (name) {
			info->id_extcon = extcon_get_extcon_dev(name);
			if (!info->id_extcon)
				return -EPROBE_DEFER;

			dev_info(dev, "controlling USB role\n");
		} else {
			dev_info(dev, "controlling USB role based on Vbus presence\n");
		}
	}

	info->vbus_attach = axp288_get_vbus_attach(info);

	axp288_extcon_log_rsi(info);

	/* Initialize extcon device */
	info->edev = devm_extcon_dev_allocate(&pdev->dev,
					      axp288_extcon_cables);
	if (IS_ERR(info->edev)) {
		dev_err(&pdev->dev, "failed to allocate memory for extcon\n");
		return PTR_ERR(info->edev);
	}

	/* Register extcon device */
	ret = devm_extcon_dev_register(&pdev->dev, info->edev);
	if (ret) {
		dev_err(&pdev->dev, "failed to register extcon device\n");
		return ret;
	}

	for (i = 0; i < EXTCON_IRQ_END; i++) {
		pirq = platform_get_irq(pdev, i);
		if (pirq < 0)
			return pirq;

		info->irq[i] = regmap_irq_get_virq(info->regmap_irqc, pirq);
		if (info->irq[i] < 0) {
			dev_err(&pdev->dev,
				"failed to get virtual interrupt=%d\n", pirq);
			ret = info->irq[i];
			return ret;
		}

		ret = devm_request_threaded_irq(&pdev->dev, info->irq[i],
				NULL, axp288_extcon_isr,
				IRQF_ONESHOT | IRQF_NO_SUSPEND,
				pdev->name, info);
		if (ret) {
			dev_err(&pdev->dev, "failed to request interrupt=%d\n",
							info->irq[i]);
			return ret;
		}
	}

	if (info->id_extcon) {
		ret = devm_extcon_register_notifier_all(dev, info->id_extcon,
							&info->id_nb);
		if (ret)
			return ret;
	}

	/* Make sure the role-sw is set correctly before doing BC detection */
	if (info->role_sw) {
		queue_work(system_long_wq, &info->role_work);
		flush_work(&info->role_work);
	}

	/* Start charger cable type detection */
	axp288_extcon_enable(info);

	return 0;
}

static const struct platform_device_id axp288_extcon_table[] = {
	{ .name = "axp288_extcon" },
	{},
};
MODULE_DEVICE_TABLE(platform, axp288_extcon_table);

static struct platform_driver axp288_extcon_driver = {
	.probe = axp288_extcon_probe,
	.id_table = axp288_extcon_table,
	.driver = {
		.name = "axp288_extcon",
	},
};

static struct device_connection axp288_extcon_role_sw_conn = {
	.endpoint[0] = "axp288_extcon",
	.endpoint[1] = "intel_xhci_usb_sw-role-switch",
	.id = "usb-role-switch",
};

static int __init axp288_extcon_init(void)
{
	if (x86_match_cpu(cherry_trail_cpu_ids))
		device_connection_add(&axp288_extcon_role_sw_conn);

	return platform_driver_register(&axp288_extcon_driver);
}
module_init(axp288_extcon_init);

static void __exit axp288_extcon_exit(void)
{
	if (x86_match_cpu(cherry_trail_cpu_ids))
		device_connection_remove(&axp288_extcon_role_sw_conn);

	platform_driver_unregister(&axp288_extcon_driver);
}
module_exit(axp288_extcon_exit);

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