Commit | Line | Data |
---|---|---|
d2912cb1 | 1 | // SPDX-License-Identifier: GPL-2.0-only |
e2427b09 SB |
2 | /** |
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, |
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, |
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); |
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"); |