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

// SPDX-License-Identifier: GPL-2.0-only
/*
 * 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>
 */

#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>
#include <asm/iosf_mbi.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_MATCH_INTEL_FAM6_MODEL(ATOM_AIRMONT,	NULL),
	{}
};

/* 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",
};

/*
 * 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)
{
	unsigned int val, i, clear_mask = 0;
	unsigned long bits;
	int ret;

	ret = regmap_read(info->regmap, AXP288_PS_BOOT_REASON_REG, &val);
	if (ret < 0) {
		dev_err(info->dev, "failed to read reset source indicator\n");
		return;
	}

	bits = val & GENMASK(ARRAY_SIZE(axp288_pwr_up_down_info) - 1, 0);
	for_each_set_bit(i, &bits, ARRAY_SIZE(axp288_pwr_up_down_info))
		dev_dbg(info->dev, "%s\n", axp288_pwr_up_down_info[i]);
	clear_mask = bits;

	/* 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;

	ret = iosf_mbi_block_punit_i2c_access();
	if (ret < 0)
		return ret;

	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:
	iosf_mbi_unblock_punit_i2c_access();

	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:
	iosf_mbi_unblock_punit_i2c_access();

	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 int axp288_extcon_enable(struct axp288_extcon_info *info)
{
	int ret = 0;

	ret = iosf_mbi_block_punit_i2c_access();
	if (ret < 0)
		return ret;

	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);

	iosf_mbi_unblock_punit_i2c_access();

	return ret;
}

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_find_role_sw(struct axp288_extcon_info *info)
{
	const struct software_node *swnode;
	struct fwnode_handle *fwnode;

	if (!x86_match_cpu(cherry_trail_cpu_ids))
		return 0;

	swnode = software_node_find_by_name(NULL, "intel-xhci-usb-sw");
	if (!swnode)
		return -EPROBE_DEFER;

	fwnode = software_node_fwnode(swnode);
	info->role_sw = usb_role_switch_find_by_fwnode(fwnode);
	fwnode_handle_put(fwnode);

	return info->role_sw ? 0 : -EPROBE_DEFER;
}

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;
	struct acpi_device *adev;
	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);

	ret = axp288_extcon_find_role_sw(info);
	if (ret)
		return ret;

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

		adev = acpi_dev_get_first_match_dev("INT3496", NULL, -1);
		if (adev) {
			info->id_extcon = extcon_get_extcon_dev(acpi_dev_name(adev));
			put_device(&adev->dev);
			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");
		}
	}

	ret = iosf_mbi_block_punit_i2c_access();
	if (ret < 0)
		return ret;

	info->vbus_attach = axp288_get_vbus_attach(info);

	axp288_extcon_log_rsi(info);

	iosf_mbi_unblock_punit_i2c_access();

	/* 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 */
	ret = axp288_extcon_enable(info);
	if (ret < 0)
		return ret;

	device_init_wakeup(dev, true);
	platform_set_drvdata(pdev, info);

	return 0;
}

static int __maybe_unused axp288_extcon_suspend(struct device *dev)
{
	struct axp288_extcon_info *info = dev_get_drvdata(dev);

	if (device_may_wakeup(dev))
		enable_irq_wake(info->irq[VBUS_RISING_IRQ]);

	return 0;
}

static int __maybe_unused axp288_extcon_resume(struct device *dev)
{
	struct axp288_extcon_info *info = dev_get_drvdata(dev);

	/*
	 * Wakeup when a charger is connected to do charger-type
	 * connection and generate an extcon event which makes the
	 * axp288 charger driver set the input current limit.
	 */
	if (device_may_wakeup(dev))
		disable_irq_wake(info->irq[VBUS_RISING_IRQ]);

	return 0;
}

static SIMPLE_DEV_PM_OPS(axp288_extcon_pm_ops, axp288_extcon_suspend,
			 axp288_extcon_resume);

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",
		.pm = &axp288_extcon_pm_ops,
	},
};
module_platform_driver(axp288_extcon_driver);

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
1802d0be	1	// SPDX-License-Identifier: GPL-2.0-only
f0312378 RP	2	/*
	3	* extcon-axp288.c - X-Power AXP288 PMIC extcon cable detection driver
	4	*
d54f063c	5	* Copyright (c) 2017-2018 Hans de Goede <hdegoede@redhat.com>
f0312378 RP	6	* Copyright (C) 2015 Intel Corporation
f0312378 RP	7	* Author: Ramakrishna Pallala <ramakrishna.pallala@intel.com>
f0312378 RP	8	*/
f0312378 RP	9
d54f063c	10	#include <linux/acpi.h>
f0312378 RP	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>
f0312378	18	#include <linux/notifier.h>
176aa360	19	#include <linux/extcon-provider.h>
f0312378	20	#include <linux/regmap.h>
f0312378	21	#include <linux/mfd/axp20x.h>
d54f063c HG	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>
968bd3f0	27	#include <asm/iosf_mbi.h>
f0312378 RP	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
f0312378 RP	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,
f0312378 RP	78	};
f0312378 RP	79
f0312378 RP	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
73b6ecdb	88	static const unsigned int axp288_extcon_cables[] = {
11eecf91 CC	89	EXTCON_CHG_USB_SDP,
	90	EXTCON_CHG_USB_CDP,
	91	EXTCON_CHG_USB_DCP,
5298b836	92	EXTCON_USB,
2a9de9c0	93	EXTCON_NONE,
f0312378 RP	94	};
	95
	96	struct axp288_extcon_info {
	97	struct device *dev;
	98	struct regmap *regmap;
	99	struct regmap_irq_chip_data *regmap_irqc;
d54f063c HG	100	struct usb_role_switch *role_sw;
d54f063c HG	101	struct work_struct role_work;
f0312378 RP	102	int irq[EXTCON_IRQ_END];
f0312378 RP	103	struct extcon_dev *edev;
d54f063c HG	104	struct extcon_dev *id_extcon;
d54f063c HG	105	struct notifier_block id_nb;
5d2199ea	106	unsigned int previous_cable;
d54f063c HG	107	bool vbus_attach;
	108	};
	109
	110	static const struct x86_cpu_id cherry_trail_cpu_ids[] = {
20d320c6	111	X86_MATCH_INTEL_FAM6_MODEL(ATOM_AIRMONT, NULL),
d54f063c	112	{}
f0312378 RP	113	};
	114
	115	/* Power up/down reason string array */
5b4e64be	116	static const char * const axp288_pwr_up_down_info[] = {
f0312378 RP	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",
f0312378 RP	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	{
f0312378	133	unsigned int val, i, clear_mask = 0;
21be848e	134	unsigned long bits;
f0312378 RP	135	int ret;
	136
	137	ret = regmap_read(info->regmap, AXP288_PS_BOOT_REASON_REG, &val);
d72e3dc7 AS	138	if (ret < 0) {
	139	dev_err(info->dev, "failed to read reset source indicator\n");
	140	return;
	141	}
	142
21be848e AS	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;
f0312378 RP	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
d54f063c HG	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)
f0312378	167	{
d54f063c HG	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;
f0312378 RP	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");
d54f063c	206	return false;
f0312378 RP	207	}
f0312378 RP	208
d54f063c HG	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
968bd3f0 FA	219	ret = iosf_mbi_block_punit_i2c_access();
	220	if (ret < 0)
	221	return ret;
	222
d54f063c	223	vbus_attach = axp288_get_vbus_attach(info);
f0312378	224	if (!vbus_attach)
3fe1e0e2	225	goto no_vbus;
f0312378 RP	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:
525867db	244	dev_dbg(info->dev, "sdp cable is connected\n");
11eecf91	245	cable = EXTCON_CHG_USB_SDP;
f0312378 RP	246	break;
f0312378 RP	247	case DET_STAT_CDP:
525867db	248	dev_dbg(info->dev, "cdp cable is connected\n");
11eecf91	249	cable = EXTCON_CHG_USB_CDP;
f0312378 RP	250	break;
f0312378 RP	251	case DET_STAT_DCP:
525867db	252	dev_dbg(info->dev, "dcp cable is connected\n");
11eecf91	253	cable = EXTCON_CHG_USB_DCP;
f0312378 RP	254	break;
f0312378 RP	255	default:
ca90a64d HG	256	dev_warn(info->dev, "unknown (reserved) bc detect result\n");
ca90a64d HG	257	cable = EXTCON_CHG_USB_SDP;
f0312378 RP	258	}
f0312378 RP	259
3fe1e0e2	260	no_vbus:
968bd3f0 FA	261	iosf_mbi_unblock_punit_i2c_access();
968bd3f0 FA	262
5d2199ea	263	extcon_set_state_sync(info->edev, info->previous_cable, false);
5298b836 BW	264	if (info->previous_cable == EXTCON_CHG_USB_SDP)
	265	extcon_set_state_sync(info->edev, EXTCON_USB, false);
	266
5d2199ea HG	267	if (vbus_attach) {
5d2199ea HG	268	extcon_set_state_sync(info->edev, cable, vbus_attach);
5298b836 BW	269	if (cable == EXTCON_CHG_USB_SDP)
	270	extcon_set_state_sync(info->edev, EXTCON_USB,
	271	vbus_attach);
	272
5d2199ea HG	273	info->previous_cable = cable;
5d2199ea HG	274	}
f0312378	275
d54f063c HG	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
f0312378 RP	282	return 0;
	283
	284	dev_det_ret:
968bd3f0 FA	285	iosf_mbi_unblock_punit_i2c_access();
968bd3f0 FA	286
f0312378 RP	287	if (ret < 0)
	288	dev_err(info->dev, "failed to detect BC Mod\n");
	289
	290	return ret;
	291	}
	292
d54f063c HG	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
f0312378 RP	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
968bd3f0	317	static int axp288_extcon_enable(struct axp288_extcon_info *info)
f0312378	318	{
968bd3f0 FA	319	int ret = 0;
	320
	321	ret = iosf_mbi_block_punit_i2c_access();
	322	if (ret < 0)
	323	return ret;
	324
f0312378 RP	325	regmap_update_bits(info->regmap, AXP288_BC_GLOBAL_REG,
f0312378 RP	326	BC_GLOBAL_RUN, 0);
f0312378 RP	327	/* Enable the charger detection logic */
	328	regmap_update_bits(info->regmap, AXP288_BC_GLOBAL_REG,
	329	BC_GLOBAL_RUN, BC_GLOBAL_RUN);
968bd3f0 FA	330
	331	iosf_mbi_unblock_punit_i2c_access();
	332
	333	return ret;
f0312378 RP	334	}
f0312378 RP	335
d54f063c HG	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
a69dff99 HK	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
f0312378 RP	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);
d54f063c	367	struct device *dev = &pdev->dev;
0cf064db	368	struct acpi_device *adev;
9bf317e9	369	int ret, i, pirq;
f0312378 RP	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;
5d2199ea	378	info->previous_cable = EXTCON_NONE;
d54f063c HG	379	INIT_WORK(&info->role_work, axp288_usb_role_work);
d54f063c HG	380	info->id_nb.notifier_call = axp288_extcon_id_evt;
76884241	381
f0312378 RP	382	platform_set_drvdata(pdev, info);
f0312378 RP	383
a69dff99 HK	384	ret = axp288_extcon_find_role_sw(info);
	385	if (ret)
	386	return ret;
	387
d54f063c HG	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
0cf064db AS	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);
d54f063c HG	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
968bd3f0 FA	406	ret = iosf_mbi_block_punit_i2c_access();
	407	if (ret < 0)
	408	return ret;
	409
d54f063c HG	410	info->vbus_attach = axp288_get_vbus_attach(info);
d54f063c HG	411
f0312378 RP	412	axp288_extcon_log_rsi(info);
f0312378 RP	413
968bd3f0 FA	414	iosf_mbi_unblock_punit_i2c_access();
968bd3f0 FA	415
f0312378 RP	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
f0312378 RP	431	for (i = 0; i < EXTCON_IRQ_END; i++) {
f0312378 RP	432	pirq = platform_get_irq(pdev, i);
01e1429b AY	433	if (pirq < 0)
	434	return pirq;
	435
f0312378 RP	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];
4bf27b70	441	return ret;
f0312378 RP	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]);
4bf27b70	451	return ret;
f0312378 RP	452	}
	453	}
	454
d54f063c HG	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
be174952	468	/* Start charger cable type detection */
968bd3f0 FA	469	ret = axp288_extcon_enable(info);
	470	if (ret < 0)
	471	return ret;
f0312378	472
9c945530 HG	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
f0312378	486	return 0;
f0312378 RP	487	}
f0312378 RP	488
9c945530 HG	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
dd3a55fc HG	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
f0312378 RP	513	static struct platform_driver axp288_extcon_driver = {
f0312378 RP	514	.probe = axp288_extcon_probe,
dd3a55fc	515	.id_table = axp288_extcon_table,
f0312378 RP	516	.driver = {
f0312378 RP	517	.name = "axp288_extcon",
9c945530	518	.pm = &axp288_extcon_pm_ops,
f0312378 RP	519	},
f0312378 RP	520	};
dbc88807	521	module_platform_driver(axp288_extcon_driver);
f0312378 RP	522
f0312378 RP	523	MODULE_AUTHOR("Ramakrishna Pallala <ramakrishna.pallala@intel.com>");
d54f063c	524	MODULE_AUTHOR("Hans de Goede <hdegoede@redhat.com>");
f0312378 RP	525	MODULE_DESCRIPTION("X-Powers AXP288 extcon driver");
f0312378 RP	526	MODULE_LICENSE("GPL v2");