[linux-block.git] / drivers / phy / qualcomm / phy-qcom-usb-hs.c

// SPDX-License-Identifier: GPL-2.0-only
/**
 * Copyright (C) 2016 Linaro Ltd
 */
#include <linux/module.h>
#include <linux/ulpi/driver.h>
#include <linux/ulpi/regs.h>
#include <linux/clk.h>
#include <linux/regulator/consumer.h>
#include <linux/of_device.h>
#include <linux/phy/phy.h>
#include <linux/reset.h>
#include <linux/extcon.h>
#include <linux/notifier.h>

#define ULPI_PWR_CLK_MNG_REG		0x88
# define ULPI_PWR_OTG_COMP_DISABLE	BIT(0)

#define ULPI_MISC_A			0x96
# define ULPI_MISC_A_VBUSVLDEXTSEL	BIT(1)
# define ULPI_MISC_A_VBUSVLDEXT		BIT(0)


struct ulpi_seq {
	u8 addr;
	u8 val;
};

struct qcom_usb_hs_phy {
	struct ulpi *ulpi;
	struct phy *phy;
	struct clk *ref_clk;
	struct clk *sleep_clk;
	struct regulator *v1p8;
	struct regulator *v3p3;
	struct reset_control *reset;
	struct ulpi_seq *init_seq;
	struct extcon_dev *vbus_edev;
	struct notifier_block vbus_notify;
};

static int qcom_usb_hs_phy_set_mode(struct phy *phy,
				    enum phy_mode mode, int submode)
{
	struct qcom_usb_hs_phy *uphy = phy_get_drvdata(phy);
	u8 addr;
	int ret;

	if (!uphy->vbus_edev) {
		u8 val = 0;

		switch (mode) {
		case PHY_MODE_USB_OTG:
		case PHY_MODE_USB_HOST:
			val |= ULPI_INT_IDGRD;
			fallthrough;
		case PHY_MODE_USB_DEVICE:
			val |= ULPI_INT_SESS_VALID;
		default:
			break;
		}

		ret = ulpi_write(uphy->ulpi, ULPI_USB_INT_EN_RISE, val);
		if (ret)
			return ret;
		ret = ulpi_write(uphy->ulpi, ULPI_USB_INT_EN_FALL, val);
	} else {
		switch (mode) {
		case PHY_MODE_USB_OTG:
		case PHY_MODE_USB_DEVICE:
			addr = ULPI_SET(ULPI_MISC_A);
			break;
		case PHY_MODE_USB_HOST:
			addr = ULPI_CLR(ULPI_MISC_A);
			break;
		default:
			return -EINVAL;
		}

		ret = ulpi_write(uphy->ulpi, ULPI_SET(ULPI_PWR_CLK_MNG_REG),
				 ULPI_PWR_OTG_COMP_DISABLE);
		if (ret)
			return ret;
		ret = ulpi_write(uphy->ulpi, addr, ULPI_MISC_A_VBUSVLDEXTSEL);
	}

	return ret;
}

static int
qcom_usb_hs_phy_vbus_notifier(struct notifier_block *nb, unsigned long event,
			      void *ptr)
{
	struct qcom_usb_hs_phy *uphy;
	u8 addr;

	uphy = container_of(nb, struct qcom_usb_hs_phy, vbus_notify);

	if (event)
		addr = ULPI_SET(ULPI_MISC_A);
	else
		addr = ULPI_CLR(ULPI_MISC_A);

	return ulpi_write(uphy->ulpi, addr, ULPI_MISC_A_VBUSVLDEXT);
}

static int qcom_usb_hs_phy_power_on(struct phy *phy)
{
	struct qcom_usb_hs_phy *uphy = phy_get_drvdata(phy);
	struct ulpi *ulpi = uphy->ulpi;
	const struct ulpi_seq *seq;
	int ret, state;

	ret = clk_prepare_enable(uphy->ref_clk);
	if (ret)
		return ret;

	ret = clk_prepare_enable(uphy->sleep_clk);
	if (ret)
		goto err_sleep;

	ret = regulator_set_load(uphy->v1p8, 50000);
	if (ret < 0)
		goto err_1p8;

	ret = regulator_enable(uphy->v1p8);
	if (ret)
		goto err_1p8;

	ret = regulator_set_voltage_triplet(uphy->v3p3, 3050000, 3300000,
					    3300000);
	if (ret)
		goto err_3p3;

	ret = regulator_set_load(uphy->v3p3, 50000);
	if (ret < 0)
		goto err_3p3;

	ret = regulator_enable(uphy->v3p3);
	if (ret)
		goto err_3p3;

	for (seq = uphy->init_seq; seq->addr; seq++) {
		ret = ulpi_write(ulpi, ULPI_EXT_VENDOR_SPECIFIC + seq->addr,
				 seq->val);
		if (ret)
			goto err_ulpi;
	}

	if (uphy->reset) {
		ret = reset_control_reset(uphy->reset);
		if (ret)
			goto err_ulpi;
	}

	if (uphy->vbus_edev) {
		state = extcon_get_state(uphy->vbus_edev, EXTCON_USB);
		/* setup initial state */
		qcom_usb_hs_phy_vbus_notifier(&uphy->vbus_notify, state,
					      uphy->vbus_edev);
		ret = extcon_register_notifier(uphy->vbus_edev, EXTCON_USB,
					       &uphy->vbus_notify);
		if (ret)
			goto err_ulpi;
	}

	return 0;
err_ulpi:
	regulator_disable(uphy->v3p3);
err_3p3:
	regulator_disable(uphy->v1p8);
err_1p8:
	clk_disable_unprepare(uphy->sleep_clk);
err_sleep:
	clk_disable_unprepare(uphy->ref_clk);
	return ret;
}

static int qcom_usb_hs_phy_power_off(struct phy *phy)
{
	struct qcom_usb_hs_phy *uphy = phy_get_drvdata(phy);

	if (uphy->vbus_edev)
		extcon_unregister_notifier(uphy->vbus_edev, EXTCON_USB,
					   &uphy->vbus_notify);
	regulator_disable(uphy->v3p3);
	regulator_disable(uphy->v1p8);
	clk_disable_unprepare(uphy->sleep_clk);
	clk_disable_unprepare(uphy->ref_clk);

	return 0;
}

static const struct phy_ops qcom_usb_hs_phy_ops = {
	.power_on = qcom_usb_hs_phy_power_on,
	.power_off = qcom_usb_hs_phy_power_off,
	.set_mode = qcom_usb_hs_phy_set_mode,
	.owner = THIS_MODULE,
};

static int qcom_usb_hs_phy_probe(struct ulpi *ulpi)
{
	struct qcom_usb_hs_phy *uphy;
	struct phy_provider *p;
	struct clk *clk;
	struct regulator *reg;
	struct reset_control *reset;
	int size;
	int ret;

	uphy = devm_kzalloc(&ulpi->dev, sizeof(*uphy), GFP_KERNEL);
	if (!uphy)
		return -ENOMEM;
	ulpi_set_drvdata(ulpi, uphy);
	uphy->ulpi = ulpi;

	size = of_property_count_u8_elems(ulpi->dev.of_node, "qcom,init-seq");
	if (size < 0)
		size = 0;
	uphy->init_seq = devm_kmalloc_array(&ulpi->dev, (size / 2) + 1,
					   sizeof(*uphy->init_seq), GFP_KERNEL);
	if (!uphy->init_seq)
		return -ENOMEM;
	ret = of_property_read_u8_array(ulpi->dev.of_node, "qcom,init-seq",
					(u8 *)uphy->init_seq, size);
	if (ret && size)
		return ret;
	/* NUL terminate */
	uphy->init_seq[size / 2].addr = uphy->init_seq[size / 2].val = 0;

	uphy->ref_clk = clk = devm_clk_get(&ulpi->dev, "ref");
	if (IS_ERR(clk))
		return PTR_ERR(clk);

	uphy->sleep_clk = clk = devm_clk_get(&ulpi->dev, "sleep");
	if (IS_ERR(clk))
		return PTR_ERR(clk);

	uphy->v1p8 = reg = devm_regulator_get(&ulpi->dev, "v1p8");
	if (IS_ERR(reg))
		return PTR_ERR(reg);

	uphy->v3p3 = reg = devm_regulator_get(&ulpi->dev, "v3p3");
	if (IS_ERR(reg))
		return PTR_ERR(reg);

	uphy->reset = reset = devm_reset_control_get(&ulpi->dev, "por");
	if (IS_ERR(reset)) {
		if (PTR_ERR(reset) == -EPROBE_DEFER)
			return PTR_ERR(reset);
		uphy->reset = NULL;
	}

	uphy->phy = devm_phy_create(&ulpi->dev, ulpi->dev.of_node,
				    &qcom_usb_hs_phy_ops);
	if (IS_ERR(uphy->phy))
		return PTR_ERR(uphy->phy);

	uphy->vbus_edev = extcon_get_edev_by_phandle(&ulpi->dev, 0);
	if (IS_ERR(uphy->vbus_edev)) {
		if (PTR_ERR(uphy->vbus_edev) != -ENODEV)
			return PTR_ERR(uphy->vbus_edev);
		uphy->vbus_edev = NULL;
	}

	uphy->vbus_notify.notifier_call = qcom_usb_hs_phy_vbus_notifier;
	phy_set_drvdata(uphy->phy, uphy);

	p = devm_of_phy_provider_register(&ulpi->dev, of_phy_simple_xlate);
	return PTR_ERR_OR_ZERO(p);
}

static const struct of_device_id qcom_usb_hs_phy_match[] = {
	{ .compatible = "qcom,usb-hs-phy", },
	{ }
};
MODULE_DEVICE_TABLE(of, qcom_usb_hs_phy_match);

static struct ulpi_driver qcom_usb_hs_phy_driver = {
	.probe = qcom_usb_hs_phy_probe,
	.driver = {
		.name = "qcom_usb_hs_phy",
		.of_match_table = qcom_usb_hs_phy_match,
	},
};
module_ulpi_driver(qcom_usb_hs_phy_driver);

MODULE_DESCRIPTION("Qualcomm USB HS phy");
MODULE_LICENSE("GPL v2");
Commit	Line	Data
d2912cb1	1	// SPDX-License-Identifier: GPL-2.0-only
e2427b09 SB	2	/**
e2427b09 SB	3	* Copyright (C) 2016 Linaro Ltd
e2427b09 SB	4	*/
	5	#include <linux/module.h>
	6	#include <linux/ulpi/driver.h>
	7	#include <linux/ulpi/regs.h>
	8	#include <linux/clk.h>
	9	#include <linux/regulator/consumer.h>
	10	#include <linux/of_device.h>
706a3b69	11	#include <linux/phy/phy.h>
e2427b09 SB	12	#include <linux/reset.h>
	13	#include <linux/extcon.h>
	14	#include <linux/notifier.h>
	15
e2427b09 SB	16	#define ULPI_PWR_CLK_MNG_REG 0x88
	17	# define ULPI_PWR_OTG_COMP_DISABLE BIT(0)
	18
	19	#define ULPI_MISC_A 0x96
	20	# define ULPI_MISC_A_VBUSVLDEXTSEL BIT(1)
	21	# define ULPI_MISC_A_VBUSVLDEXT BIT(0)
	22
	23
	24	struct ulpi_seq {
	25	u8 addr;
	26	u8 val;
	27	};
	28
	29	struct qcom_usb_hs_phy {
	30	struct ulpi *ulpi;
	31	struct phy *phy;
	32	struct clk *ref_clk;
	33	struct clk *sleep_clk;
	34	struct regulator *v1p8;
	35	struct regulator *v3p3;
	36	struct reset_control *reset;
	37	struct ulpi_seq *init_seq;
	38	struct extcon_dev *vbus_edev;
	39	struct notifier_block vbus_notify;
	40	};
	41
79a5a18a GS	42	static int qcom_usb_hs_phy_set_mode(struct phy *phy,
79a5a18a GS	43	enum phy_mode mode, int submode)
e2427b09 SB	44	{
	45	struct qcom_usb_hs_phy *uphy = phy_get_drvdata(phy);
	46	u8 addr;
	47	int ret;
	48
	49	if (!uphy->vbus_edev) {
	50	u8 val = 0;
	51
	52	switch (mode) {
	53	case PHY_MODE_USB_OTG:
	54	case PHY_MODE_USB_HOST:
	55	val \|= ULPI_INT_IDGRD;
df561f66	56	fallthrough;
e2427b09 SB	57	case PHY_MODE_USB_DEVICE:
	58	val \|= ULPI_INT_SESS_VALID;
	59	default:
	60	break;
	61	}
	62
	63	ret = ulpi_write(uphy->ulpi, ULPI_USB_INT_EN_RISE, val);
	64	if (ret)
	65	return ret;
	66	ret = ulpi_write(uphy->ulpi, ULPI_USB_INT_EN_FALL, val);
	67	} else {
	68	switch (mode) {
	69	case PHY_MODE_USB_OTG:
	70	case PHY_MODE_USB_DEVICE:
	71	addr = ULPI_SET(ULPI_MISC_A);
	72	break;
	73	case PHY_MODE_USB_HOST:
	74	addr = ULPI_CLR(ULPI_MISC_A);
	75	break;
	76	default:
	77	return -EINVAL;
	78	}
	79
	80	ret = ulpi_write(uphy->ulpi, ULPI_SET(ULPI_PWR_CLK_MNG_REG),
	81	ULPI_PWR_OTG_COMP_DISABLE);
	82	if (ret)
	83	return ret;
	84	ret = ulpi_write(uphy->ulpi, addr, ULPI_MISC_A_VBUSVLDEXTSEL);
	85	}
	86
	87	return ret;
	88	}
	89
	90	static int
	91	qcom_usb_hs_phy_vbus_notifier(struct notifier_block *nb, unsigned long event,
	92	void *ptr)
	93	{
	94	struct qcom_usb_hs_phy *uphy;
	95	u8 addr;
	96
	97	uphy = container_of(nb, struct qcom_usb_hs_phy, vbus_notify);
	98
	99	if (event)
	100	addr = ULPI_SET(ULPI_MISC_A);
	101	else
	102	addr = ULPI_CLR(ULPI_MISC_A);
	103
	104	return ulpi_write(uphy->ulpi, addr, ULPI_MISC_A_VBUSVLDEXT);
	105	}
	106
	107	static int qcom_usb_hs_phy_power_on(struct phy *phy)
	108	{
	109	struct qcom_usb_hs_phy *uphy = phy_get_drvdata(phy);
	110	struct ulpi *ulpi = uphy->ulpi;
	111	const struct ulpi_seq *seq;
	112	int ret, state;
	113
	114	ret = clk_prepare_enable(uphy->ref_clk);
	115	if (ret)
	116	return ret;
	117
	118	ret = clk_prepare_enable(uphy->sleep_clk);
	119	if (ret)
	120	goto err_sleep;
121
122	ret = regulator_set_load(uphy->v1p8, 50000);
123	if (ret < 0)
124	goto err_1p8;
125
126	ret = regulator_enable(uphy->v1p8);
127	if (ret)
128	goto err_1p8;
129
130	ret = regulator_set_voltage_triplet(uphy->v3p3, 3050000, 3300000,
131	3300000);
132	if (ret)
133	goto err_3p3;
134
135	ret = regulator_set_load(uphy->v3p3, 50000);
136	if (ret < 0)
137	goto err_3p3;
138
139	ret = regulator_enable(uphy->v3p3);
140	if (ret)
141	goto err_3p3;
142
143	for (seq = uphy->init_seq; seq->addr; seq++) {
144	ret = ulpi_write(ulpi, ULPI_EXT_VENDOR_SPECIFIC + seq->addr,
145	seq->val);
146	if (ret)
147	goto err_ulpi;
148	}
149
150	if (uphy->reset) {
151	ret = reset_control_reset(uphy->reset);
152	if (ret)
153	goto err_ulpi;
154	}
155
156	if (uphy->vbus_edev) {
f0b5c2c9	157	state = extcon_get_state(uphy->vbus_edev, EXTCON_USB);
e2427b09 SB	158	/* setup initial state */
	159	qcom_usb_hs_phy_vbus_notifier(&uphy->vbus_notify, state,
	160	uphy->vbus_edev);
64f86b99 SG	161	ret = extcon_register_notifier(uphy->vbus_edev, EXTCON_USB,
64f86b99 SG	162	&uphy->vbus_notify);
e2427b09 SB	163	if (ret)
	164	goto err_ulpi;
	165	}
	166
	167	return 0;
	168	err_ulpi:
	169	regulator_disable(uphy->v3p3);
	170	err_3p3:
	171	regulator_disable(uphy->v1p8);
	172	err_1p8:
	173	clk_disable_unprepare(uphy->sleep_clk);
	174	err_sleep:
	175	clk_disable_unprepare(uphy->ref_clk);
	176	return ret;
	177	}
	178
	179	static int qcom_usb_hs_phy_power_off(struct phy *phy)
	180	{
e2427b09 SB	181	struct qcom_usb_hs_phy *uphy = phy_get_drvdata(phy);
e2427b09 SB	182
64f86b99 SG	183	if (uphy->vbus_edev)
	184	extcon_unregister_notifier(uphy->vbus_edev, EXTCON_USB,
	185	&uphy->vbus_notify);
e2427b09 SB	186	regulator_disable(uphy->v3p3);
	187	regulator_disable(uphy->v1p8);
	188	clk_disable_unprepare(uphy->sleep_clk);
	189	clk_disable_unprepare(uphy->ref_clk);
	190
	191	return 0;
	192	}
	193
	194	static const struct phy_ops qcom_usb_hs_phy_ops = {
	195	.power_on = qcom_usb_hs_phy_power_on,
	196	.power_off = qcom_usb_hs_phy_power_off,
	197	.set_mode = qcom_usb_hs_phy_set_mode,
	198	.owner = THIS_MODULE,
	199	};
	200
	201	static int qcom_usb_hs_phy_probe(struct ulpi *ulpi)
	202	{
	203	struct qcom_usb_hs_phy *uphy;
	204	struct phy_provider *p;
	205	struct clk *clk;
	206	struct regulator *reg;
	207	struct reset_control *reset;
	208	int size;
	209	int ret;
	210
	211	uphy = devm_kzalloc(&ulpi->dev, sizeof(*uphy), GFP_KERNEL);
	212	if (!uphy)
	213	return -ENOMEM;
	214	ulpi_set_drvdata(ulpi, uphy);
	215	uphy->ulpi = ulpi;
	216
	217	size = of_property_count_u8_elems(ulpi->dev.of_node, "qcom,init-seq");
	218	if (size < 0)
	219	size = 0;
	220	uphy->init_seq = devm_kmalloc_array(&ulpi->dev, (size / 2) + 1,
	221	sizeof(*uphy->init_seq), GFP_KERNEL);
	222	if (!uphy->init_seq)
	223	return -ENOMEM;
	224	ret = of_property_read_u8_array(ulpi->dev.of_node, "qcom,init-seq",
	225	(u8 *)uphy->init_seq, size);
	226	if (ret && size)
	227	return ret;
	228	/* NUL terminate */
	229	uphy->init_seq[size / 2].addr = uphy->init_seq[size / 2].val = 0;
	230
	231	uphy->ref_clk = clk = devm_clk_get(&ulpi->dev, "ref");
	232	if (IS_ERR(clk))
	233	return PTR_ERR(clk);
	234
	235	uphy->sleep_clk = clk = devm_clk_get(&ulpi->dev, "sleep");
	236	if (IS_ERR(clk))
	237	return PTR_ERR(clk);
	238
	239	uphy->v1p8 = reg = devm_regulator_get(&ulpi->dev, "v1p8");
	240	if (IS_ERR(reg))
	241	return PTR_ERR(reg);
	242
	243	uphy->v3p3 = reg = devm_regulator_get(&ulpi->dev, "v3p3");
	244	if (IS_ERR(reg))
	245	return PTR_ERR(reg);
	246
	247	uphy->reset = reset = devm_reset_control_get(&ulpi->dev, "por");
	248	if (IS_ERR(reset)) {
	249	if (PTR_ERR(reset) == -EPROBE_DEFER)
250	return PTR_ERR(reset);
251	uphy->reset = NULL;
252	}
253
254	uphy->phy = devm_phy_create(&ulpi->dev, ulpi->dev.of_node,
255	&qcom_usb_hs_phy_ops);
256	if (IS_ERR(uphy->phy))
257	return PTR_ERR(uphy->phy);
258
259	uphy->vbus_edev = extcon_get_edev_by_phandle(&ulpi->dev, 0);
260	if (IS_ERR(uphy->vbus_edev)) {
261	if (PTR_ERR(uphy->vbus_edev) != -ENODEV)
262	return PTR_ERR(uphy->vbus_edev);
263	uphy->vbus_edev = NULL;
264	}
265
266	uphy->vbus_notify.notifier_call = qcom_usb_hs_phy_vbus_notifier;
267	phy_set_drvdata(uphy->phy, uphy);
268
269	p = devm_of_phy_provider_register(&ulpi->dev, of_phy_simple_xlate);
270	return PTR_ERR_OR_ZERO(p);
271	}
272
273	static const struct of_device_id qcom_usb_hs_phy_match[] = {
274	{ .compatible = "qcom,usb-hs-phy", },
275	{ }
276	};
277	MODULE_DEVICE_TABLE(of, qcom_usb_hs_phy_match);
278
279	static struct ulpi_driver qcom_usb_hs_phy_driver = {
280	.probe = qcom_usb_hs_phy_probe,
281	.driver = {
282	.name = "qcom_usb_hs_phy",
283	.of_match_table = qcom_usb_hs_phy_match,
284	},
285	};
286	module_ulpi_driver(qcom_usb_hs_phy_driver);
287
288	MODULE_DESCRIPTION("Qualcomm USB HS phy");
289	MODULE_LICENSE("GPL v2");