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

/**
 * Copyright (C) 2016 Linaro Ltd
 *
 * 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.
 */
#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/reset.h>
#include <linux/extcon.h>
#include <linux/notifier.h>

#include "ulpi_phy.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)
{
	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;
		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_cable_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)
{
	int ret;
	struct qcom_usb_hs_phy *uphy = phy_get_drvdata(phy);

	if (uphy->vbus_edev) {
		ret = extcon_unregister_notifier(uphy->vbus_edev, EXTCON_USB,
						 &uphy->vbus_notify);
		if (ret)
			return ret;
	}

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