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