[mirror_ubuntu-artful-kernel.git] / drivers / extcon / extcon-axp288.c

/*
 * extcon-axp288.c - X-Power AXP288 PMIC extcon cable detection driver
 *
 * 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/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.h>
#include <linux/regmap.h>
#include <linux/gpio.h>
#include <linux/gpio/consumer.h>
#include <linux/mfd/axp20x.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_mux_select {
	EXTCON_GPIO_MUX_SEL_PMIC = 0,
	EXTCON_GPIO_MUX_SEL_SOC,
};

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_NONE,
};

struct axp288_extcon_info {
	struct device *dev;
	struct regmap *regmap;
	struct regmap_irq_chip_data *regmap_irqc;
	struct gpio_desc *gpio_mux_cntl;
	int irq[EXTCON_IRQ_END];
	struct extcon_dev *edev;
	struct notifier_block extcon_nb;
	unsigned int previous_cable;
};

/* Power up/down reason string array */
static char *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)
{
	char **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);
}

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

	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 ret;
	}

	vbus_attach = (pwr_stat & PS_STAT_VBUS_VALID);
	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,
			"disconnect or unknown or ID event\n");
	}

no_vbus:
	/*
	 * If VBUS is absent Connect D+/D- lines to PMIC for BC
	 * detection. Else connect them to SOC for USB communication.
	 */
	if (info->gpio_mux_cntl)
		gpiod_set_value(info->gpio_mux_cntl,
			vbus_attach ? EXTCON_GPIO_MUX_SEL_SOC
					: EXTCON_GPIO_MUX_SEL_PMIC);

	extcon_set_state_sync(info->edev, info->previous_cable, false);
	if (vbus_attach) {
		extcon_set_state_sync(info->edev, cable, vbus_attach);
		info->previous_cable = cable;
	}

	return 0;

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

	return ret;
}

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 int axp288_extcon_probe(struct platform_device *pdev)
{
	struct axp288_extcon_info *info;
	struct axp20x_dev *axp20x = dev_get_drvdata(pdev->dev.parent);
	struct axp288_extcon_pdata *pdata = pdev->dev.platform_data;
	int ret, i, pirq, gpio;

	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;
	if (pdata)
		info->gpio_mux_cntl = pdata->gpio_mux_cntl;

	platform_set_drvdata(pdev, 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;
	}

	/* Set up gpio control for USB Mux */
	if (info->gpio_mux_cntl) {
		gpio = desc_to_gpio(info->gpio_mux_cntl);
		ret = devm_gpio_request(&pdev->dev, gpio, "USB_MUX");
		if (ret < 0) {
			dev_err(&pdev->dev,
				"failed to request the gpio=%d\n", gpio);
			return ret;
		}
		gpiod_direction_output(info->gpio_mux_cntl,
						EXTCON_GPIO_MUX_SEL_PMIC);
	}

	for (i = 0; i < EXTCON_IRQ_END; i++) {
		pirq = platform_get_irq(pdev, i);
		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;
		}
	}

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

	return 0;
}

static struct platform_driver axp288_extcon_driver = {
	.probe = axp288_extcon_probe,
	.driver = {
		.name = "axp288_extcon",
	},
};
module_platform_driver(axp288_extcon_driver);

MODULE_AUTHOR("Ramakrishna Pallala <ramakrishna.pallala@intel.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	*
	4	* Copyright (C) 2015 Intel Corporation
	5	* Author: Ramakrishna Pallala <ramakrishna.pallala@intel.com>
	6	*
	7	* This program is free software; you can redistribute it and/or modify
	8	* it under the terms of the GNU General Public License version 2 as
	9	* published by the Free Software Foundation.
	10	*
	11	* This program is distributed in the hope that it will be useful,
	12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	* GNU General Public License for more details.
	15	*/
	16
	17	#include <linux/module.h>
	18	#include <linux/kernel.h>
	19	#include <linux/io.h>
	20	#include <linux/slab.h>
	21	#include <linux/interrupt.h>
	22	#include <linux/platform_device.h>
	23	#include <linux/property.h>
f0312378 RP	24	#include <linux/notifier.h>
	25	#include <linux/extcon.h>
	26	#include <linux/regmap.h>
	27	#include <linux/gpio.h>
	28	#include <linux/gpio/consumer.h>
	29	#include <linux/mfd/axp20x.h>
	30
	31	/* Power source status register */
	32	#define PS_STAT_VBUS_TRIGGER BIT(0)
	33	#define PS_STAT_BAT_CHRG_DIR BIT(2)
	34	#define PS_STAT_VBUS_ABOVE_VHOLD BIT(3)
	35	#define PS_STAT_VBUS_VALID BIT(4)
	36	#define PS_STAT_VBUS_PRESENT BIT(5)
	37
	38	/* BC module global register */
	39	#define BC_GLOBAL_RUN BIT(0)
	40	#define BC_GLOBAL_DET_STAT BIT(2)
	41	#define BC_GLOBAL_DBP_TOUT BIT(3)
	42	#define BC_GLOBAL_VLGC_COM_SEL BIT(4)
	43	#define BC_GLOBAL_DCD_TOUT_MASK (BIT(6)\|BIT(5))
	44	#define BC_GLOBAL_DCD_TOUT_300MS 0
	45	#define BC_GLOBAL_DCD_TOUT_100MS 1
	46	#define BC_GLOBAL_DCD_TOUT_500MS 2
	47	#define BC_GLOBAL_DCD_TOUT_900MS 3
	48	#define BC_GLOBAL_DCD_DET_SEL BIT(7)
	49
	50	/* BC module vbus control and status register */
	51	#define VBUS_CNTL_DPDM_PD_EN BIT(4)
	52	#define VBUS_CNTL_DPDM_FD_EN BIT(5)
	53	#define VBUS_CNTL_FIRST_PO_STAT BIT(6)
	54
	55	/* BC USB status register */
	56	#define USB_STAT_BUS_STAT_MASK (BIT(3)\|BIT(2)\|BIT(1)\|BIT(0))
	57	#define USB_STAT_BUS_STAT_SHIFT 0
	58	#define USB_STAT_BUS_STAT_ATHD 0
	59	#define USB_STAT_BUS_STAT_CONN 1
	60	#define USB_STAT_BUS_STAT_SUSP 2
	61	#define USB_STAT_BUS_STAT_CONF 3
	62	#define USB_STAT_USB_SS_MODE BIT(4)
	63	#define USB_STAT_DEAD_BAT_DET BIT(6)
	64	#define USB_STAT_DBP_UNCFG BIT(7)
	65
	66	/* BC detect status register */
	67	#define DET_STAT_MASK (BIT(7)\|BIT(6)\|BIT(5))
	68	#define DET_STAT_SHIFT 5
	69	#define DET_STAT_SDP 1
	70	#define DET_STAT_CDP 2
	71	#define DET_STAT_DCP 3
	72
f0312378 RP	73	enum axp288_extcon_reg {
	74	AXP288_PS_STAT_REG = 0x00,
	75	AXP288_PS_BOOT_REASON_REG = 0x02,
	76	AXP288_BC_GLOBAL_REG = 0x2c,
	77	AXP288_BC_VBUS_CNTL_REG = 0x2d,
	78	AXP288_BC_USB_STAT_REG = 0x2e,
	79	AXP288_BC_DET_STAT_REG = 0x2f,
f0312378 RP	80	};
	81
	82	enum axp288_mux_select {
	83	EXTCON_GPIO_MUX_SEL_PMIC = 0,
	84	EXTCON_GPIO_MUX_SEL_SOC,
	85	};
	86
	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,
2a9de9c0	99	EXTCON_NONE,
f0312378 RP	100	};
	101
	102	struct axp288_extcon_info {
	103	struct device *dev;
	104	struct regmap *regmap;
	105	struct regmap_irq_chip_data *regmap_irqc;
76884241	106	struct gpio_desc *gpio_mux_cntl;
f0312378 RP	107	int irq[EXTCON_IRQ_END];
	108	struct extcon_dev *edev;
	109	struct notifier_block extcon_nb;
5d2199ea	110	unsigned int previous_cable;
f0312378 RP	111	};
	112
	113	/* Power up/down reason string array */
	114	static char *axp288_pwr_up_down_info[] = {
	115	"Last wake caused by user pressing the power button",
	116	"Last wake caused by a charger insertion",
	117	"Last wake caused by a battery insertion",
	118	"Last wake caused by SOC initiated global reset",
	119	"Last wake caused by cold reset",
	120	"Last shutdown caused by PMIC UVLO threshold",
	121	"Last shutdown caused by SOC initiated cold off",
	122	"Last shutdown caused by user pressing the power button",
	123	NULL,
	124	};
	125
	126	/*
	127	* Decode and log the given "reset source indicator" (rsi)
	128	* register and then clear it.
	129	*/
	130	static void axp288_extcon_log_rsi(struct axp288_extcon_info *info)
	131	{
	132	char **rsi;
	133	unsigned int val, i, clear_mask = 0;
	134	int ret;
	135
	136	ret = regmap_read(info->regmap, AXP288_PS_BOOT_REASON_REG, &val);
	137	for (i = 0, rsi = axp288_pwr_up_down_info; *rsi; rsi++, i++) {
	138	if (val & BIT(i)) {
	139	dev_dbg(info->dev, "%s\n", *rsi);
	140	clear_mask \|= BIT(i);
	141	}
	142	}
	143
	144	/* Clear the register value for next reboot (write 1 to clear bit) */
	145	regmap_write(info->regmap, AXP288_PS_BOOT_REASON_REG, clear_mask);
	146	}
	147
	148	static int axp288_handle_chrg_det_event(struct axp288_extcon_info *info)
	149	{
f0312378 RP	150	int ret, stat, cfg, pwr_stat;
f0312378 RP	151	u8 chrg_type;
5d2199ea	152	unsigned int cable = info->previous_cable;
f0312378 RP	153	bool vbus_attach = false;
	154
	155	ret = regmap_read(info->regmap, AXP288_PS_STAT_REG, &pwr_stat);
	156	if (ret < 0) {
	157	dev_err(info->dev, "failed to read vbus status\n");
	158	return ret;
	159	}
	160
5757aca1	161	vbus_attach = (pwr_stat & PS_STAT_VBUS_VALID);
f0312378	162	if (!vbus_attach)
3fe1e0e2	163	goto no_vbus;
f0312378 RP	164
	165	/* Check charger detection completion status */
	166	ret = regmap_read(info->regmap, AXP288_BC_GLOBAL_REG, &cfg);
	167	if (ret < 0)
	168	goto dev_det_ret;
	169	if (cfg & BC_GLOBAL_DET_STAT) {
	170	dev_dbg(info->dev, "can't complete the charger detection\n");
	171	goto dev_det_ret;
	172	}
	173
	174	ret = regmap_read(info->regmap, AXP288_BC_DET_STAT_REG, &stat);
	175	if (ret < 0)
	176	goto dev_det_ret;
	177
	178	chrg_type = (stat & DET_STAT_MASK) >> DET_STAT_SHIFT;
	179
	180	switch (chrg_type) {
	181	case DET_STAT_SDP:
525867db	182	dev_dbg(info->dev, "sdp cable is connected\n");
11eecf91	183	cable = EXTCON_CHG_USB_SDP;
f0312378 RP	184	break;
f0312378 RP	185	case DET_STAT_CDP:
525867db	186	dev_dbg(info->dev, "cdp cable is connected\n");
11eecf91	187	cable = EXTCON_CHG_USB_CDP;
f0312378 RP	188	break;
f0312378 RP	189	case DET_STAT_DCP:
525867db	190	dev_dbg(info->dev, "dcp cable is connected\n");
11eecf91	191	cable = EXTCON_CHG_USB_DCP;
f0312378 RP	192	break;
	193	default:
	194	dev_warn(info->dev,
	195	"disconnect or unknown or ID event\n");
	196	}
	197
3fe1e0e2 HG	198	no_vbus:
	199	/*
	200	* If VBUS is absent Connect D+/D- lines to PMIC for BC
	201	* detection. Else connect them to SOC for USB communication.
	202	*/
	203	if (info->gpio_mux_cntl)
	204	gpiod_set_value(info->gpio_mux_cntl,
	205	vbus_attach ? EXTCON_GPIO_MUX_SEL_SOC
	206	: EXTCON_GPIO_MUX_SEL_PMIC);
	207
5d2199ea HG	208	extcon_set_state_sync(info->edev, info->previous_cable, false);
	209	if (vbus_attach) {
	210	extcon_set_state_sync(info->edev, cable, vbus_attach);
	211	info->previous_cable = cable;
	212	}
f0312378 RP	213
	214	return 0;
	215
	216	dev_det_ret:
	217	if (ret < 0)
	218	dev_err(info->dev, "failed to detect BC Mod\n");
	219
	220	return ret;
	221	}
	222
	223	static irqreturn_t axp288_extcon_isr(int irq, void *data)
	224	{
	225	struct axp288_extcon_info *info = data;
	226	int ret;
	227
	228	ret = axp288_handle_chrg_det_event(info);
	229	if (ret < 0)
	230	dev_err(info->dev, "failed to handle the interrupt\n");
	231
	232	return IRQ_HANDLED;
	233	}
	234
be174952	235	static void axp288_extcon_enable(struct axp288_extcon_info *info)
f0312378	236	{
f0312378 RP	237	regmap_update_bits(info->regmap, AXP288_BC_GLOBAL_REG,
f0312378 RP	238	BC_GLOBAL_RUN, 0);
f0312378 RP	239	/* Enable the charger detection logic */
	240	regmap_update_bits(info->regmap, AXP288_BC_GLOBAL_REG,
	241	BC_GLOBAL_RUN, BC_GLOBAL_RUN);
	242	}
	243
	244	static int axp288_extcon_probe(struct platform_device *pdev)
	245	{
	246	struct axp288_extcon_info *info;
	247	struct axp20x_dev *axp20x = dev_get_drvdata(pdev->dev.parent);
76884241	248	struct axp288_extcon_pdata *pdata = pdev->dev.platform_data;
f0312378 RP	249	int ret, i, pirq, gpio;
	250
	251	info = devm_kzalloc(&pdev->dev, sizeof(*info), GFP_KERNEL);
	252	if (!info)
	253	return -ENOMEM;
	254
	255	info->dev = &pdev->dev;
	256	info->regmap = axp20x->regmap;
	257	info->regmap_irqc = axp20x->regmap_irqc;
5d2199ea	258	info->previous_cable = EXTCON_NONE;
76884241 HG	259	if (pdata)
	260	info->gpio_mux_cntl = pdata->gpio_mux_cntl;
	261
f0312378 RP	262	platform_set_drvdata(pdev, info);
	263
	264	axp288_extcon_log_rsi(info);
	265
	266	/* Initialize extcon device */
	267	info->edev = devm_extcon_dev_allocate(&pdev->dev,
	268	axp288_extcon_cables);
	269	if (IS_ERR(info->edev)) {
	270	dev_err(&pdev->dev, "failed to allocate memory for extcon\n");
	271	return PTR_ERR(info->edev);
	272	}
	273
	274	/* Register extcon device */
	275	ret = devm_extcon_dev_register(&pdev->dev, info->edev);
	276	if (ret) {
	277	dev_err(&pdev->dev, "failed to register extcon device\n");
	278	return ret;
	279	}
	280
f0312378	281	/* Set up gpio control for USB Mux */
76884241 HG	282	if (info->gpio_mux_cntl) {
76884241 HG	283	gpio = desc_to_gpio(info->gpio_mux_cntl);
4bf27b70	284	ret = devm_gpio_request(&pdev->dev, gpio, "USB_MUX");
f0312378 RP	285	if (ret < 0) {
	286	dev_err(&pdev->dev,
	287	"failed to request the gpio=%d\n", gpio);
4bf27b70	288	return ret;
f0312378	289	}
76884241	290	gpiod_direction_output(info->gpio_mux_cntl,
f0312378 RP	291	EXTCON_GPIO_MUX_SEL_PMIC);
	292	}
	293
	294	for (i = 0; i < EXTCON_IRQ_END; i++) {
	295	pirq = platform_get_irq(pdev, i);
	296	info->irq[i] = regmap_irq_get_virq(info->regmap_irqc, pirq);
	297	if (info->irq[i] < 0) {
	298	dev_err(&pdev->dev,
	299	"failed to get virtual interrupt=%d\n", pirq);
	300	ret = info->irq[i];
4bf27b70	301	return ret;
f0312378 RP	302	}
	303
	304	ret = devm_request_threaded_irq(&pdev->dev, info->irq[i],
	305	NULL, axp288_extcon_isr,
	306	IRQF_ONESHOT \| IRQF_NO_SUSPEND,
	307	pdev->name, info);
	308	if (ret) {
	309	dev_err(&pdev->dev, "failed to request interrupt=%d\n",
	310	info->irq[i]);
4bf27b70	311	return ret;
f0312378 RP	312	}
	313	}
	314
be174952 HG	315	/* Start charger cable type detection */
be174952 HG	316	axp288_extcon_enable(info);
f0312378 RP	317
f0312378 RP	318	return 0;
f0312378 RP	319	}
	320
	321	static struct platform_driver axp288_extcon_driver = {
	322	.probe = axp288_extcon_probe,
f0312378 RP	323	.driver = {
	324	.name = "axp288_extcon",
	325	},
	326	};
	327	module_platform_driver(axp288_extcon_driver);
	328
	329	MODULE_AUTHOR("Ramakrishna Pallala <ramakrishna.pallala@intel.com>");
	330	MODULE_DESCRIPTION("X-Powers AXP288 extcon driver");
	331	MODULE_LICENSE("GPL v2");