]> git.karo-electronics.de Git - karo-tx-uboot.git/blob - arch/arm/cpu/armv7/sunxi/usb_phy.c
sunxi: musb: Stop treating not having a vbus-det gpio as an error
[karo-tx-uboot.git] / arch / arm / cpu / armv7 / sunxi / usb_phy.c
1 /*
2  * Sunxi usb-phy code
3  *
4  * Copyright (C) 2015 Hans de Goede <hdegoede@redhat.com>
5  * Copyright (C) 2014 Roman Byshko <rbyshko@gmail.com>
6  *
7  * Based on code from
8  * Allwinner Technology Co., Ltd. <www.allwinnertech.com>
9  *
10  * SPDX-License-Identifier:     GPL-2.0+
11  */
12
13 #include <common.h>
14 #include <asm/arch/clock.h>
15 #include <asm/arch/cpu.h>
16 #include <asm/arch/usb_phy.h>
17 #include <asm/gpio.h>
18 #include <asm/io.h>
19 #include <errno.h>
20 #ifdef CONFIG_AXP152_POWER
21 #include <axp152.h>
22 #endif
23 #ifdef CONFIG_AXP209_POWER
24 #include <axp209.h>
25 #endif
26 #ifdef CONFIG_AXP221_POWER
27 #include <axp221.h>
28 #endif
29
30 #define SUNXI_USB_PMU_IRQ_ENABLE        0x800
31 #ifdef CONFIG_MACH_SUN8I_A33
32 #define SUNXI_USB_CSR                   0x410
33 #else
34 #define SUNXI_USB_CSR                   0x404
35 #endif
36 #define SUNXI_USB_PASSBY_EN             1
37
38 #define SUNXI_EHCI_AHB_ICHR8_EN         (1 << 10)
39 #define SUNXI_EHCI_AHB_INCR4_BURST_EN   (1 << 9)
40 #define SUNXI_EHCI_AHB_INCRX_ALIGN_EN   (1 << 8)
41 #define SUNXI_EHCI_ULPI_BYPASS_EN       (1 << 0)
42
43 static struct sunxi_usb_phy {
44         int usb_rst_mask;
45         int gpio_vbus;
46         int gpio_vbus_det;
47         int gpio_id_det;
48         int id;
49         int init_count;
50         int power_on_count;
51 } sunxi_usb_phy[] = {
52         {
53                 .usb_rst_mask = CCM_USB_CTRL_PHY0_RST | CCM_USB_CTRL_PHY0_CLK,
54                 .id = 0,
55         },
56         {
57                 .usb_rst_mask = CCM_USB_CTRL_PHY1_RST | CCM_USB_CTRL_PHY1_CLK,
58                 .id = 1,
59         },
60 #if CONFIG_SUNXI_USB_PHYS >= 3
61         {
62                 .usb_rst_mask = CCM_USB_CTRL_PHY2_RST | CCM_USB_CTRL_PHY2_CLK,
63                 .id = 2,
64         }
65 #endif
66 };
67
68 static int get_vbus_gpio(int index)
69 {
70         switch (index) {
71         case 0: return sunxi_name_to_gpio(CONFIG_USB0_VBUS_PIN);
72         case 1: return sunxi_name_to_gpio(CONFIG_USB1_VBUS_PIN);
73         case 2: return sunxi_name_to_gpio(CONFIG_USB2_VBUS_PIN);
74         }
75         return -EINVAL;
76 }
77
78 static int get_vbus_detect_gpio(int index)
79 {
80         switch (index) {
81         case 0: return sunxi_name_to_gpio(CONFIG_USB0_VBUS_DET);
82         }
83         return -EINVAL;
84 }
85
86 static int get_id_detect_gpio(int index)
87 {
88         switch (index) {
89         case 0: return sunxi_name_to_gpio(CONFIG_USB0_ID_DET);
90         }
91         return -EINVAL;
92 }
93
94 static void usb_phy_write(struct sunxi_usb_phy *phy, int addr,
95                           int data, int len)
96 {
97         int j = 0, usbc_bit = 0;
98         void *dest = (void *)SUNXI_USB0_BASE + SUNXI_USB_CSR;
99
100 #ifdef CONFIG_MACH_SUN8I_A33
101         /* CSR needs to be explicitly initialized to 0 on A33 */
102         writel(0, dest);
103 #endif
104
105         usbc_bit = 1 << (phy->id * 2);
106         for (j = 0; j < len; j++) {
107                 /* set the bit address to be written */
108                 clrbits_le32(dest, 0xff << 8);
109                 setbits_le32(dest, (addr + j) << 8);
110
111                 clrbits_le32(dest, usbc_bit);
112                 /* set data bit */
113                 if (data & 0x1)
114                         setbits_le32(dest, 1 << 7);
115                 else
116                         clrbits_le32(dest, 1 << 7);
117
118                 setbits_le32(dest, usbc_bit);
119
120                 clrbits_le32(dest, usbc_bit);
121
122                 data >>= 1;
123         }
124 }
125
126 static void sunxi_usb_phy_config(struct sunxi_usb_phy *phy)
127 {
128         /* The following comments are machine
129          * translated from Chinese, you have been warned!
130          */
131
132         /* Regulation 45 ohms */
133         if (phy->id == 0)
134                 usb_phy_write(phy, 0x0c, 0x01, 1);
135
136         /* adjust PHY's magnitude and rate */
137         usb_phy_write(phy, 0x20, 0x14, 5);
138
139         /* threshold adjustment disconnect */
140 #if defined CONFIG_MACH_SUN5I || defined CONFIG_MACH_SUN7I
141         usb_phy_write(phy, 0x2a, 2, 2);
142 #else
143         usb_phy_write(phy, 0x2a, 3, 2);
144 #endif
145
146         return;
147 }
148
149 static void sunxi_usb_phy_passby(int index, int enable)
150 {
151         unsigned long bits = 0;
152         void *addr;
153
154         if (index == 1)
155                 addr = (void *)SUNXI_USB1_BASE + SUNXI_USB_PMU_IRQ_ENABLE;
156         else
157                 addr = (void *)SUNXI_USB2_BASE + SUNXI_USB_PMU_IRQ_ENABLE;
158
159         bits = SUNXI_EHCI_AHB_ICHR8_EN |
160                 SUNXI_EHCI_AHB_INCR4_BURST_EN |
161                 SUNXI_EHCI_AHB_INCRX_ALIGN_EN |
162                 SUNXI_EHCI_ULPI_BYPASS_EN;
163
164         if (enable)
165                 setbits_le32(addr, bits);
166         else
167                 clrbits_le32(addr, bits);
168
169         return;
170 }
171
172 void sunxi_usb_phy_enable_squelch_detect(int index, int enable)
173 {
174         struct sunxi_usb_phy *phy = &sunxi_usb_phy[index];
175
176         usb_phy_write(phy, 0x3c, enable ? 0 : 2, 2);
177 }
178
179 void sunxi_usb_phy_init(int index)
180 {
181         struct sunxi_usb_phy *phy = &sunxi_usb_phy[index];
182         struct sunxi_ccm_reg *ccm = (struct sunxi_ccm_reg *)SUNXI_CCM_BASE;
183
184         phy->init_count++;
185         if (phy->init_count != 1)
186                 return;
187
188         setbits_le32(&ccm->usb_clk_cfg, phy->usb_rst_mask);
189
190         sunxi_usb_phy_config(phy);
191
192         if (phy->id != 0)
193                 sunxi_usb_phy_passby(index, SUNXI_USB_PASSBY_EN);
194 }
195
196 void sunxi_usb_phy_exit(int index)
197 {
198         struct sunxi_usb_phy *phy = &sunxi_usb_phy[index];
199         struct sunxi_ccm_reg *ccm = (struct sunxi_ccm_reg *)SUNXI_CCM_BASE;
200
201         phy->init_count--;
202         if (phy->init_count != 0)
203                 return;
204
205         if (phy->id != 0)
206                 sunxi_usb_phy_passby(index, !SUNXI_USB_PASSBY_EN);
207
208         clrbits_le32(&ccm->usb_clk_cfg, phy->usb_rst_mask);
209 }
210
211 void sunxi_usb_phy_power_on(int index)
212 {
213         struct sunxi_usb_phy *phy = &sunxi_usb_phy[index];
214
215         phy->power_on_count++;
216         if (phy->power_on_count != 1)
217                 return;
218
219         if (phy->gpio_vbus >= 0)
220                 gpio_set_value(phy->gpio_vbus, 1);
221 }
222
223 void sunxi_usb_phy_power_off(int index)
224 {
225         struct sunxi_usb_phy *phy = &sunxi_usb_phy[index];
226
227         phy->power_on_count--;
228         if (phy->power_on_count != 0)
229                 return;
230
231         if (phy->gpio_vbus >= 0)
232                 gpio_set_value(phy->gpio_vbus, 0);
233 }
234
235 int sunxi_usb_phy_vbus_detect(int index)
236 {
237         struct sunxi_usb_phy *phy = &sunxi_usb_phy[index];
238         int err, retries = 3;
239
240         if (phy->gpio_vbus_det < 0)
241                 return phy->gpio_vbus_det;
242
243         err = gpio_get_value(phy->gpio_vbus_det);
244         /*
245          * Vbus may have been provided by the board and just been turned of
246          * some milliseconds ago on reset, what we're measuring then is a
247          * residual charge on Vbus, sleep a bit and try again.
248          */
249         while (err > 0 && retries--) {
250                 mdelay(100);
251                 err = gpio_get_value(phy->gpio_vbus_det);
252         }
253
254         return err;
255 }
256
257 int sunxi_usb_phy_id_detect(int index)
258 {
259         struct sunxi_usb_phy *phy = &sunxi_usb_phy[index];
260
261         if (phy->gpio_id_det < 0)
262                 return phy->gpio_id_det;
263
264         return gpio_get_value(phy->gpio_id_det);
265 }
266
267 int sunxi_usb_phy_probe(void)
268 {
269         struct sunxi_ccm_reg *ccm = (struct sunxi_ccm_reg *)SUNXI_CCM_BASE;
270         struct sunxi_usb_phy *phy;
271         int i, ret = 0;
272
273         for (i = 0; i < CONFIG_SUNXI_USB_PHYS; i++) {
274                 phy = &sunxi_usb_phy[i];
275
276                 phy->gpio_vbus = get_vbus_gpio(i);
277                 if (phy->gpio_vbus >= 0) {
278                         ret = gpio_request(phy->gpio_vbus, "usb_vbus");
279                         if (ret)
280                                 return ret;
281                         ret = gpio_direction_output(phy->gpio_vbus, 0);
282                         if (ret)
283                                 return ret;
284                 }
285
286                 phy->gpio_vbus_det = get_vbus_detect_gpio(i);
287                 if (phy->gpio_vbus_det >= 0) {
288                         ret = gpio_request(phy->gpio_vbus_det, "usb_vbus_det");
289                         if (ret)
290                                 return ret;
291                         ret = gpio_direction_input(phy->gpio_vbus_det);
292                         if (ret)
293                                 return ret;
294                 }
295
296                 phy->gpio_id_det = get_id_detect_gpio(i);
297                 if (phy->gpio_id_det >= 0) {
298                         ret = gpio_request(phy->gpio_id_det, "usb_id_det");
299                         if (ret)
300                                 return ret;
301                         ret = gpio_direction_input(phy->gpio_id_det);
302                         if (ret)
303                                 return ret;
304                         sunxi_gpio_set_pull(phy->gpio_id_det,
305                                             SUNXI_GPIO_PULL_UP);
306                 }
307         }
308
309         setbits_le32(&ccm->usb_clk_cfg, CCM_USB_CTRL_PHYGATE);
310
311         return 0;
312 }
313
314 int sunxi_usb_phy_remove(void)
315 {
316         struct sunxi_ccm_reg *ccm = (struct sunxi_ccm_reg *)SUNXI_CCM_BASE;
317         struct sunxi_usb_phy *phy;
318         int i;
319
320         clrbits_le32(&ccm->usb_clk_cfg, CCM_USB_CTRL_PHYGATE);
321
322         for (i = 0; i < CONFIG_SUNXI_USB_PHYS; i++) {
323                 phy = &sunxi_usb_phy[i];
324
325                 if (phy->gpio_vbus >= 0)
326                         gpio_free(phy->gpio_vbus);
327
328                 if (phy->gpio_vbus_det >= 0)
329                         gpio_free(phy->gpio_vbus_det);
330
331                 if (phy->gpio_id_det >= 0)
332                         gpio_free(phy->gpio_id_det);
333         }
334
335         return 0;
336 }