[mirror_ubuntu-hirsute-kernel.git] / drivers / extcon / extcon-intel-mrfld.c

// SPDX-License-Identifier: GPL-2.0
/*
 * extcon driver for Basin Cove PMIC
 *
 * Copyright (c) 2019, Intel Corporation.
 * Author: Andy Shevchenko <andriy.shevchenko@linux.intel.com>
 */

#include <linux/extcon-provider.h>
#include <linux/interrupt.h>
#include <linux/mfd/intel_soc_pmic.h>
#include <linux/mfd/intel_soc_pmic_mrfld.h>
#include <linux/mod_devicetable.h>
#include <linux/module.h>
#include <linux/platform_device.h>
#include <linux/regmap.h>

#include "extcon-intel.h"

#define BCOVE_USBIDCTRL			0x19
#define BCOVE_USBIDCTRL_ID		BIT(0)
#define BCOVE_USBIDCTRL_ACA		BIT(1)
#define BCOVE_USBIDCTRL_ALL	(BCOVE_USBIDCTRL_ID | BCOVE_USBIDCTRL_ACA)

#define BCOVE_USBIDSTS			0x1a
#define BCOVE_USBIDSTS_GND		BIT(0)
#define BCOVE_USBIDSTS_RARBRC_MASK	GENMASK(2, 1)
#define BCOVE_USBIDSTS_RARBRC_SHIFT	1
#define BCOVE_USBIDSTS_NO_ACA		0
#define BCOVE_USBIDSTS_R_ID_A		1
#define BCOVE_USBIDSTS_R_ID_B		2
#define BCOVE_USBIDSTS_R_ID_C		3
#define BCOVE_USBIDSTS_FLOAT		BIT(3)
#define BCOVE_USBIDSTS_SHORT		BIT(4)

#define BCOVE_CHGRIRQ_ALL	(BCOVE_CHGRIRQ_VBUSDET | BCOVE_CHGRIRQ_DCDET | \
				 BCOVE_CHGRIRQ_BATTDET | BCOVE_CHGRIRQ_USBIDDET)

#define BCOVE_CHGRCTRL0			0x4b
#define BCOVE_CHGRCTRL0_CHGRRESET	BIT(0)
#define BCOVE_CHGRCTRL0_EMRGCHREN	BIT(1)
#define BCOVE_CHGRCTRL0_EXTCHRDIS	BIT(2)
#define BCOVE_CHGRCTRL0_SWCONTROL	BIT(3)
#define BCOVE_CHGRCTRL0_TTLCK		BIT(4)
#define BCOVE_CHGRCTRL0_BIT_5		BIT(5)
#define BCOVE_CHGRCTRL0_BIT_6		BIT(6)
#define BCOVE_CHGRCTRL0_CHR_WDT_NOKICK	BIT(7)

struct mrfld_extcon_data {
	struct device *dev;
	struct regmap *regmap;
	struct extcon_dev *edev;
	unsigned int status;
	unsigned int id;
};

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

static int mrfld_extcon_clear(struct mrfld_extcon_data *data, unsigned int reg,
			      unsigned int mask)
{
	return regmap_update_bits(data->regmap, reg, mask, 0x00);
}

static int mrfld_extcon_set(struct mrfld_extcon_data *data, unsigned int reg,
			    unsigned int mask)
{
	return regmap_update_bits(data->regmap, reg, mask, 0xff);
}

static int mrfld_extcon_sw_control(struct mrfld_extcon_data *data, bool enable)
{
	unsigned int mask = BCOVE_CHGRCTRL0_SWCONTROL;
	struct device *dev = data->dev;
	int ret;

	if (enable)
		ret = mrfld_extcon_set(data, BCOVE_CHGRCTRL0, mask);
	else
		ret = mrfld_extcon_clear(data, BCOVE_CHGRCTRL0, mask);
	if (ret)
		dev_err(dev, "can't set SW control: %d\n", ret);
	return ret;
}

static int mrfld_extcon_get_id(struct mrfld_extcon_data *data)
{
	struct regmap *regmap = data->regmap;
	unsigned int id;
	bool ground;
	int ret;

	ret = regmap_read(regmap, BCOVE_USBIDSTS, &id);
	if (ret)
		return ret;

	if (id & BCOVE_USBIDSTS_FLOAT)
		return INTEL_USB_ID_FLOAT;

	switch ((id & BCOVE_USBIDSTS_RARBRC_MASK) >> BCOVE_USBIDSTS_RARBRC_SHIFT) {
	case BCOVE_USBIDSTS_R_ID_A:
		return INTEL_USB_RID_A;
	case BCOVE_USBIDSTS_R_ID_B:
		return INTEL_USB_RID_B;
	case BCOVE_USBIDSTS_R_ID_C:
		return INTEL_USB_RID_C;
	}

	/*
	 * PMIC A0 reports USBIDSTS_GND = 1 for ID_GND,
	 * but PMIC B0 reports USBIDSTS_GND = 0 for ID_GND.
	 * Thus we must check this bit at last.
	 */
	ground = id & BCOVE_USBIDSTS_GND;
	switch ('A' + BCOVE_MAJOR(data->id)) {
	case 'A':
		return ground ? INTEL_USB_ID_GND : INTEL_USB_ID_FLOAT;
	case 'B':
		return ground ? INTEL_USB_ID_FLOAT : INTEL_USB_ID_GND;
	}

	/* Unknown or unsupported type */
	return INTEL_USB_ID_FLOAT;
}

static int mrfld_extcon_role_detect(struct mrfld_extcon_data *data)
{
	unsigned int id;
	bool usb_host;
	int ret;

	ret = mrfld_extcon_get_id(data);
	if (ret < 0)
		return ret;

	id = ret;

	usb_host = (id == INTEL_USB_ID_GND) || (id == INTEL_USB_RID_A);
	extcon_set_state_sync(data->edev, EXTCON_USB_HOST, usb_host);

	return 0;
}

static int mrfld_extcon_cable_detect(struct mrfld_extcon_data *data)
{
	struct regmap *regmap = data->regmap;
	unsigned int status, change;
	int ret;

	/*
	 * It seems SCU firmware clears the content of BCOVE_CHGRIRQ1
	 * and makes it useless for OS. Instead we compare a previously
	 * stored status to the current one, provided by BCOVE_SCHGRIRQ1.
	 */
	ret = regmap_read(regmap, BCOVE_SCHGRIRQ1, &status);
	if (ret)
		return ret;

	change = status ^ data->status;
	if (!change)
		return -ENODATA;

	if (change & BCOVE_CHGRIRQ_USBIDDET) {
		ret = mrfld_extcon_role_detect(data);
		if (ret)
			return ret;
	}

	data->status = status;

	return 0;
}

static irqreturn_t mrfld_extcon_interrupt(int irq, void *dev_id)
{
	struct mrfld_extcon_data *data = dev_id;
	int ret;

	ret = mrfld_extcon_cable_detect(data);

	mrfld_extcon_clear(data, BCOVE_MIRQLVL1, BCOVE_LVL1_CHGR);

	return ret ? IRQ_NONE: IRQ_HANDLED;
}

static int mrfld_extcon_probe(struct platform_device *pdev)
{
	struct device *dev = &pdev->dev;
	struct intel_soc_pmic *pmic = dev_get_drvdata(dev->parent);
	struct regmap *regmap = pmic->regmap;
	struct mrfld_extcon_data *data;
	unsigned int id;
	int irq, ret;

	irq = platform_get_irq(pdev, 0);
	if (irq < 0)
		return irq;

	data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL);
	if (!data)
		return -ENOMEM;

	data->dev = dev;
	data->regmap = regmap;

	data->edev = devm_extcon_dev_allocate(dev, mrfld_extcon_cable);
	if (IS_ERR(data->edev))
		return -ENOMEM;

	ret = devm_extcon_dev_register(dev, data->edev);
	if (ret < 0) {
		dev_err(dev, "can't register extcon device: %d\n", ret);
		return ret;
	}

	ret = devm_request_threaded_irq(dev, irq, NULL, mrfld_extcon_interrupt,
					IRQF_ONESHOT | IRQF_SHARED, pdev->name,
					data);
	if (ret) {
		dev_err(dev, "can't register IRQ handler: %d\n", ret);
		return ret;
	}

	ret = regmap_read(regmap, BCOVE_ID, &id);
	if (ret) {
		dev_err(dev, "can't read PMIC ID: %d\n", ret);
		return ret;
	}

	data->id = id;

	ret = mrfld_extcon_sw_control(data, true);
	if (ret)
		return ret;

	/* Get initial state */
	mrfld_extcon_role_detect(data);

	mrfld_extcon_clear(data, BCOVE_MIRQLVL1, BCOVE_LVL1_CHGR);
	mrfld_extcon_clear(data, BCOVE_MCHGRIRQ1, BCOVE_CHGRIRQ_ALL);

	mrfld_extcon_set(data, BCOVE_USBIDCTRL, BCOVE_USBIDCTRL_ALL);

	platform_set_drvdata(pdev, data);

	return 0;
}

static int mrfld_extcon_remove(struct platform_device *pdev)
{
	struct mrfld_extcon_data *data = platform_get_drvdata(pdev);

	mrfld_extcon_sw_control(data, false);

	return 0;
}

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

static struct platform_driver mrfld_extcon_driver = {
	.driver = {
		.name	= "mrfld_bcove_pwrsrc",
	},
	.probe		= mrfld_extcon_probe,
	.remove		= mrfld_extcon_remove,
	.id_table	= mrfld_extcon_id_table,
};
module_platform_driver(mrfld_extcon_driver);

MODULE_AUTHOR("Andy Shevchenko <andriy.shevchenko@linux.intel.com>");
MODULE_DESCRIPTION("extcon driver for Intel Merrifield Basin Cove PMIC");
MODULE_LICENSE("GPL v2");
Commit	Line	Data
492929c5 AS	1	// SPDX-License-Identifier: GPL-2.0
	2	/*
	3	* extcon driver for Basin Cove PMIC
	4	*
	5	* Copyright (c) 2019, Intel Corporation.
	6	* Author: Andy Shevchenko <andriy.shevchenko@linux.intel.com>
	7	*/
	8
	9	#include <linux/extcon-provider.h>
	10	#include <linux/interrupt.h>
	11	#include <linux/mfd/intel_soc_pmic.h>
	12	#include <linux/mfd/intel_soc_pmic_mrfld.h>
	13	#include <linux/mod_devicetable.h>
	14	#include <linux/module.h>
	15	#include <linux/platform_device.h>
	16	#include <linux/regmap.h>
	17
	18	#include "extcon-intel.h"
	19
	20	#define BCOVE_USBIDCTRL 0x19
	21	#define BCOVE_USBIDCTRL_ID BIT(0)
	22	#define BCOVE_USBIDCTRL_ACA BIT(1)
	23	#define BCOVE_USBIDCTRL_ALL (BCOVE_USBIDCTRL_ID \| BCOVE_USBIDCTRL_ACA)
	24
	25	#define BCOVE_USBIDSTS 0x1a
	26	#define BCOVE_USBIDSTS_GND BIT(0)
	27	#define BCOVE_USBIDSTS_RARBRC_MASK GENMASK(2, 1)
	28	#define BCOVE_USBIDSTS_RARBRC_SHIFT 1
	29	#define BCOVE_USBIDSTS_NO_ACA 0
	30	#define BCOVE_USBIDSTS_R_ID_A 1
	31	#define BCOVE_USBIDSTS_R_ID_B 2
	32	#define BCOVE_USBIDSTS_R_ID_C 3
	33	#define BCOVE_USBIDSTS_FLOAT BIT(3)
	34	#define BCOVE_USBIDSTS_SHORT BIT(4)
	35
	36	#define BCOVE_CHGRIRQ_ALL (BCOVE_CHGRIRQ_VBUSDET \| BCOVE_CHGRIRQ_DCDET \| \
	37	BCOVE_CHGRIRQ_BATTDET \| BCOVE_CHGRIRQ_USBIDDET)
	38
	39	#define BCOVE_CHGRCTRL0 0x4b
	40	#define BCOVE_CHGRCTRL0_CHGRRESET BIT(0)
	41	#define BCOVE_CHGRCTRL0_EMRGCHREN BIT(1)
	42	#define BCOVE_CHGRCTRL0_EXTCHRDIS BIT(2)
	43	#define BCOVE_CHGRCTRL0_SWCONTROL BIT(3)
	44	#define BCOVE_CHGRCTRL0_TTLCK BIT(4)
	45	#define BCOVE_CHGRCTRL0_BIT_5 BIT(5)
	46	#define BCOVE_CHGRCTRL0_BIT_6 BIT(6)
	47	#define BCOVE_CHGRCTRL0_CHR_WDT_NOKICK BIT(7)
	48
	49	struct mrfld_extcon_data {
	50	struct device *dev;
	51	struct regmap *regmap;
	52	struct extcon_dev *edev;
	53	unsigned int status;
	54	unsigned int id;
	55	};
	56
	57	static const unsigned int mrfld_extcon_cable[] = {
	58	EXTCON_USB,
	59	EXTCON_USB_HOST,
	60	EXTCON_CHG_USB_SDP,
	61	EXTCON_CHG_USB_CDP,
	62	EXTCON_CHG_USB_DCP,
	63	EXTCON_CHG_USB_ACA,
	64	EXTCON_NONE,
65	};
66
67	static int mrfld_extcon_clear(struct mrfld_extcon_data *data, unsigned int reg,
68	unsigned int mask)
69	{
70	return regmap_update_bits(data->regmap, reg, mask, 0x00);
71	}
72
73	static int mrfld_extcon_set(struct mrfld_extcon_data *data, unsigned int reg,
74	unsigned int mask)
75	{
76	return regmap_update_bits(data->regmap, reg, mask, 0xff);
77	}
78
79	static int mrfld_extcon_sw_control(struct mrfld_extcon_data *data, bool enable)
80	{
81	unsigned int mask = BCOVE_CHGRCTRL0_SWCONTROL;
82	struct device *dev = data->dev;
83	int ret;
84
85	if (enable)
86	ret = mrfld_extcon_set(data, BCOVE_CHGRCTRL0, mask);
87	else
88	ret = mrfld_extcon_clear(data, BCOVE_CHGRCTRL0, mask);
89	if (ret)
90	dev_err(dev, "can't set SW control: %d\n", ret);
91	return ret;
92	}
93
94	static int mrfld_extcon_get_id(struct mrfld_extcon_data *data)
95	{
96	struct regmap *regmap = data->regmap;
97	unsigned int id;
98	bool ground;
99	int ret;
100
101	ret = regmap_read(regmap, BCOVE_USBIDSTS, &id);
102	if (ret)
103	return ret;
104
105	if (id & BCOVE_USBIDSTS_FLOAT)
106	return INTEL_USB_ID_FLOAT;
107
108	switch ((id & BCOVE_USBIDSTS_RARBRC_MASK) >> BCOVE_USBIDSTS_RARBRC_SHIFT) {
109	case BCOVE_USBIDSTS_R_ID_A:
110	return INTEL_USB_RID_A;
111	case BCOVE_USBIDSTS_R_ID_B:
112	return INTEL_USB_RID_B;
113	case BCOVE_USBIDSTS_R_ID_C:
114	return INTEL_USB_RID_C;
115	}
116
117	/*
118	* PMIC A0 reports USBIDSTS_GND = 1 for ID_GND,
119	* but PMIC B0 reports USBIDSTS_GND = 0 for ID_GND.
120	* Thus we must check this bit at last.
121	*/
122	ground = id & BCOVE_USBIDSTS_GND;
123	switch ('A' + BCOVE_MAJOR(data->id)) {
124	case 'A':
125	return ground ? INTEL_USB_ID_GND : INTEL_USB_ID_FLOAT;
126	case 'B':
127	return ground ? INTEL_USB_ID_FLOAT : INTEL_USB_ID_GND;
128	}
129
130	/* Unknown or unsupported type */
131	return INTEL_USB_ID_FLOAT;
132	}
133
134	static int mrfld_extcon_role_detect(struct mrfld_extcon_data *data)
135	{
136	unsigned int id;
137	bool usb_host;
138	int ret;
139
140	ret = mrfld_extcon_get_id(data);
141	if (ret < 0)
142	return ret;
143
144	id = ret;
145
146	usb_host = (id == INTEL_USB_ID_GND) \|\| (id == INTEL_USB_RID_A);
147	extcon_set_state_sync(data->edev, EXTCON_USB_HOST, usb_host);
148
149	return 0;
150	}
151
152	static int mrfld_extcon_cable_detect(struct mrfld_extcon_data *data)
153	{
154	struct regmap *regmap = data->regmap;
155	unsigned int status, change;
156	int ret;
157
158	/*
159	* It seems SCU firmware clears the content of BCOVE_CHGRIRQ1
160	* and makes it useless for OS. Instead we compare a previously
161	* stored status to the current one, provided by BCOVE_SCHGRIRQ1.
162	*/
163	ret = regmap_read(regmap, BCOVE_SCHGRIRQ1, &status);
164	if (ret)
165	return ret;
166
167	change = status ^ data->status;
168	if (!change)
169	return -ENODATA;
170
171	if (change & BCOVE_CHGRIRQ_USBIDDET) {
172	ret = mrfld_extcon_role_detect(data);
173	if (ret)
174	return ret;
175	}
176
177	data->status = status;
178
179	return 0;
180	}
181
182	static irqreturn_t mrfld_extcon_interrupt(int irq, void *dev_id)
183	{
184	struct mrfld_extcon_data *data = dev_id;
185	int ret;
186
187	ret = mrfld_extcon_cable_detect(data);
188
189	mrfld_extcon_clear(data, BCOVE_MIRQLVL1, BCOVE_LVL1_CHGR);
190
191	return ret ? IRQ_NONE: IRQ_HANDLED;
192	}
193
194	static int mrfld_extcon_probe(struct platform_device *pdev)
195	{
196	struct device *dev = &pdev->dev;
197	struct intel_soc_pmic *pmic = dev_get_drvdata(dev->parent);
198	struct regmap *regmap = pmic->regmap;
199	struct mrfld_extcon_data *data;
200	unsigned int id;
201	int irq, ret;
202
203	irq = platform_get_irq(pdev, 0);
204	if (irq < 0)
205	return irq;
206
207	data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL);
208	if (!data)
209	return -ENOMEM;
210
211	data->dev = dev;
212	data->regmap = regmap;
213
214	data->edev = devm_extcon_dev_allocate(dev, mrfld_extcon_cable);
215	if (IS_ERR(data->edev))
216	return -ENOMEM;
217
218	ret = devm_extcon_dev_register(dev, data->edev);
219	if (ret < 0) {
220	dev_err(dev, "can't register extcon device: %d\n", ret);
221	return ret;
222	}
223
224	ret = devm_request_threaded_irq(dev, irq, NULL, mrfld_extcon_interrupt,
225	IRQF_ONESHOT \| IRQF_SHARED, pdev->name,
226	data);
227	if (ret) {
228	dev_err(dev, "can't register IRQ handler: %d\n", ret);
229	return ret;
230	}
231
232	ret = regmap_read(regmap, BCOVE_ID, &id);
233	if (ret) {
234	dev_err(dev, "can't read PMIC ID: %d\n", ret);
235	return ret;
236	}
237
238	data->id = id;
239
240	ret = mrfld_extcon_sw_control(data, true);
241	if (ret)
242	return ret;
243
244	/* Get initial state */
245	mrfld_extcon_role_detect(data);
246
247	mrfld_extcon_clear(data, BCOVE_MIRQLVL1, BCOVE_LVL1_CHGR);
248	mrfld_extcon_clear(data, BCOVE_MCHGRIRQ1, BCOVE_CHGRIRQ_ALL);
249
250	mrfld_extcon_set(data, BCOVE_USBIDCTRL, BCOVE_USBIDCTRL_ALL);
251
252	platform_set_drvdata(pdev, data);
253
254	return 0;
255	}
256
257	static int mrfld_extcon_remove(struct platform_device *pdev)
258	{
259	struct mrfld_extcon_data *data = platform_get_drvdata(pdev);
260
261	mrfld_extcon_sw_control(data, false);
262
263	return 0;
264	}
265
266	static const struct platform_device_id mrfld_extcon_id_table[] = {
267	{ .name = "mrfld_bcove_pwrsrc" },
268	{}
269	};
270	MODULE_DEVICE_TABLE(platform, mrfld_extcon_id_table);
271
272	static struct platform_driver mrfld_extcon_driver = {
273	.driver = {
274	.name = "mrfld_bcove_pwrsrc",
275	},
276	.probe = mrfld_extcon_probe,
277	.remove = mrfld_extcon_remove,
278	.id_table = mrfld_extcon_id_table,
279	};
280	module_platform_driver(mrfld_extcon_driver);
281
282	MODULE_AUTHOR("Andy Shevchenko <andriy.shevchenko@linux.intel.com>");
283	MODULE_DESCRIPTION("extcon driver for Intel Merrifield Basin Cove PMIC");
284	MODULE_LICENSE("GPL v2");