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"); |