Merge tag 'media/v4.16-2' of git://git.kernel.org/pub/scm/linux/kernel/git/mchehab...
[linux-2.6-microblaze.git] / drivers / phy / tegra / xusb-tegra210.c
1 /*
2  * Copyright (c) 2014, NVIDIA CORPORATION.  All rights reserved.
3  * Copyright (C) 2015 Google, Inc.
4  *
5  * This program is free software; you can redistribute it and/or modify it
6  * under the terms and conditions of the GNU General Public License,
7  * version 2, as published by the Free Software Foundation.
8  *
9  * This program is distributed in the hope it will be useful, but WITHOUT
10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
12  * more details.
13  */
14
15 #include <linux/clk.h>
16 #include <linux/clk/tegra.h>
17 #include <linux/delay.h>
18 #include <linux/io.h>
19 #include <linux/mailbox_client.h>
20 #include <linux/module.h>
21 #include <linux/of.h>
22 #include <linux/phy/phy.h>
23 #include <linux/platform_device.h>
24 #include <linux/regulator/consumer.h>
25 #include <linux/reset.h>
26 #include <linux/slab.h>
27
28 #include <soc/tegra/fuse.h>
29
30 #include "xusb.h"
31
32 #define FUSE_SKU_CALIB_HS_CURR_LEVEL_PADX_SHIFT(x) \
33                                         ((x) ? (11 + ((x) - 1) * 6) : 0)
34 #define FUSE_SKU_CALIB_HS_CURR_LEVEL_PAD_MASK 0x3f
35 #define FUSE_SKU_CALIB_HS_TERM_RANGE_ADJ_SHIFT 7
36 #define FUSE_SKU_CALIB_HS_TERM_RANGE_ADJ_MASK 0xf
37
38 #define FUSE_USB_CALIB_EXT_RPD_CTRL_SHIFT 0
39 #define FUSE_USB_CALIB_EXT_RPD_CTRL_MASK 0x1f
40
41 #define XUSB_PADCTL_USB2_PAD_MUX 0x004
42 #define XUSB_PADCTL_USB2_PAD_MUX_HSIC_PAD_TRK_SHIFT 16
43 #define XUSB_PADCTL_USB2_PAD_MUX_HSIC_PAD_TRK_MASK 0x3
44 #define XUSB_PADCTL_USB2_PAD_MUX_HSIC_PAD_TRK_XUSB 0x1
45 #define XUSB_PADCTL_USB2_PAD_MUX_USB2_BIAS_PAD_SHIFT 18
46 #define XUSB_PADCTL_USB2_PAD_MUX_USB2_BIAS_PAD_MASK 0x3
47 #define XUSB_PADCTL_USB2_PAD_MUX_USB2_BIAS_PAD_XUSB 0x1
48
49 #define XUSB_PADCTL_USB2_PORT_CAP 0x008
50 #define XUSB_PADCTL_USB2_PORT_CAP_PORTX_CAP_HOST(x) (0x1 << ((x) * 4))
51 #define XUSB_PADCTL_USB2_PORT_CAP_PORTX_CAP_MASK(x) (0x3 << ((x) * 4))
52
53 #define XUSB_PADCTL_SS_PORT_MAP 0x014
54 #define XUSB_PADCTL_SS_PORT_MAP_PORTX_INTERNAL(x) (1 << (((x) * 5) + 4))
55 #define XUSB_PADCTL_SS_PORT_MAP_PORTX_MAP_SHIFT(x) ((x) * 5)
56 #define XUSB_PADCTL_SS_PORT_MAP_PORTX_MAP_MASK(x) (0x7 << ((x) * 5))
57 #define XUSB_PADCTL_SS_PORT_MAP_PORTX_MAP(x, v) (((v) & 0x7) << ((x) * 5))
58
59 #define XUSB_PADCTL_ELPG_PROGRAM1 0x024
60 #define XUSB_PADCTL_ELPG_PROGRAM1_AUX_MUX_LP0_VCORE_DOWN (1 << 31)
61 #define XUSB_PADCTL_ELPG_PROGRAM1_AUX_MUX_LP0_CLAMP_EN_EARLY (1 << 30)
62 #define XUSB_PADCTL_ELPG_PROGRAM1_AUX_MUX_LP0_CLAMP_EN (1 << 29)
63 #define XUSB_PADCTL_ELPG_PROGRAM1_SSPX_ELPG_VCORE_DOWN(x) (1 << (2 + (x) * 3))
64 #define XUSB_PADCTL_ELPG_PROGRAM1_SSPX_ELPG_CLAMP_EN_EARLY(x) \
65                                                         (1 << (1 + (x) * 3))
66 #define XUSB_PADCTL_ELPG_PROGRAM1_SSPX_ELPG_CLAMP_EN(x) (1 << ((x) * 3))
67
68 #define XUSB_PADCTL_USB3_PAD_MUX 0x028
69 #define XUSB_PADCTL_USB3_PAD_MUX_PCIE_IDDQ_DISABLE(x) (1 << (1 + (x)))
70 #define XUSB_PADCTL_USB3_PAD_MUX_SATA_IDDQ_DISABLE(x) (1 << (8 + (x)))
71
72 #define XUSB_PADCTL_USB2_BATTERY_CHRG_OTGPADX_CTL1(x) (0x084 + (x) * 0x40)
73 #define XUSB_PADCTL_USB2_BATTERY_CHRG_OTGPAD_CTL1_VREG_LEV_SHIFT 7
74 #define XUSB_PADCTL_USB2_BATTERY_CHRG_OTGPAD_CTL1_VREG_LEV_MASK 0x3
75 #define XUSB_PADCTL_USB2_BATTERY_CHRG_OTGPAD_CTL1_VREG_FIX18 (1 << 6)
76
77 #define XUSB_PADCTL_USB2_OTG_PADX_CTL0(x) (0x088 + (x) * 0x40)
78 #define XUSB_PADCTL_USB2_OTG_PAD_CTL0_PD_ZI (1 << 29)
79 #define XUSB_PADCTL_USB2_OTG_PAD_CTL0_PD2 (1 << 27)
80 #define XUSB_PADCTL_USB2_OTG_PAD_CTL0_PD (1 << 26)
81 #define XUSB_PADCTL_USB2_OTG_PAD_CTL0_HS_CURR_LEVEL_SHIFT 0
82 #define XUSB_PADCTL_USB2_OTG_PAD_CTL0_HS_CURR_LEVEL_MASK 0x3f
83
84 #define XUSB_PADCTL_USB2_OTG_PADX_CTL1(x) (0x08c + (x) * 0x40)
85 #define XUSB_PADCTL_USB2_OTG_PAD_CTL1_RPD_CTRL_SHIFT 26
86 #define XUSB_PADCTL_USB2_OTG_PAD_CTL1_RPD_CTRL_MASK 0x1f
87 #define XUSB_PADCTL_USB2_OTG_PAD_CTL1_TERM_RANGE_ADJ_SHIFT 3
88 #define XUSB_PADCTL_USB2_OTG_PAD_CTL1_TERM_RANGE_ADJ_MASK 0xf
89 #define XUSB_PADCTL_USB2_OTG_PAD_CTL1_PD_DR (1 << 2)
90 #define XUSB_PADCTL_USB2_OTG_PAD_CTL1_PD_DISC_OVRD (1 << 1)
91 #define XUSB_PADCTL_USB2_OTG_PAD_CTL1_PD_CHRP_OVRD (1 << 0)
92
93 #define XUSB_PADCTL_USB2_BIAS_PAD_CTL0 0x284
94 #define XUSB_PADCTL_USB2_BIAS_PAD_CTL0_PD (1 << 11)
95 #define XUSB_PADCTL_USB2_BIAS_PAD_CTL0_HS_DISCON_LEVEL_SHIFT 3
96 #define XUSB_PADCTL_USB2_BIAS_PAD_CTL0_HS_DISCON_LEVEL_MASK 0x7
97 #define XUSB_PADCTL_USB2_BIAS_PAD_CTL0_HS_DISCON_LEVEL_VAL 0x7
98 #define XUSB_PADCTL_USB2_BIAS_PAD_CTL0_HS_SQUELCH_LEVEL_SHIFT 0
99 #define XUSB_PADCTL_USB2_BIAS_PAD_CTL0_HS_SQUELCH_LEVEL_MASK 0x7
100 #define XUSB_PADCTL_USB2_BIAS_PAD_CTL0_HS_SQUELCH_LEVEL_VAL 0x2
101
102 #define XUSB_PADCTL_USB2_BIAS_PAD_CTL1 0x288
103 #define XUSB_PADCTL_USB2_BIAS_PAD_CTL1_PD_TRK (1 << 26)
104 #define XUSB_PADCTL_USB2_BIAS_PAD_CTL1_TRK_DONE_RESET_TIMER_SHIFT 19
105 #define XUSB_PADCTL_USB2_BIAS_PAD_CTL1_TRK_DONE_RESET_TIMER_MASK 0x7f
106 #define XUSB_PADCTL_USB2_BIAS_PAD_CTL1_TRK_DONE_RESET_TIMER_VAL 0x0a
107 #define XUSB_PADCTL_USB2_BIAS_PAD_CTL1_TRK_START_TIMER_SHIFT 12
108 #define XUSB_PADCTL_USB2_BIAS_PAD_CTL1_TRK_START_TIMER_MASK 0x7f
109 #define XUSB_PADCTL_USB2_BIAS_PAD_CTL1_TRK_START_TIMER_VAL 0x1e
110
111 #define XUSB_PADCTL_HSIC_PADX_CTL0(x) (0x300 + (x) * 0x20)
112 #define XUSB_PADCTL_HSIC_PAD_CTL0_RPU_STROBE (1 << 18)
113 #define XUSB_PADCTL_HSIC_PAD_CTL0_RPU_DATA1 (1 << 17)
114 #define XUSB_PADCTL_HSIC_PAD_CTL0_RPU_DATA0 (1 << 16)
115 #define XUSB_PADCTL_HSIC_PAD_CTL0_RPD_STROBE (1 << 15)
116 #define XUSB_PADCTL_HSIC_PAD_CTL0_RPD_DATA1 (1 << 14)
117 #define XUSB_PADCTL_HSIC_PAD_CTL0_RPD_DATA0 (1 << 13)
118 #define XUSB_PADCTL_HSIC_PAD_CTL0_PD_ZI_STROBE (1 << 9)
119 #define XUSB_PADCTL_HSIC_PAD_CTL0_PD_ZI_DATA1 (1 << 8)
120 #define XUSB_PADCTL_HSIC_PAD_CTL0_PD_ZI_DATA0 (1 << 7)
121 #define XUSB_PADCTL_HSIC_PAD_CTL0_PD_RX_STROBE (1 << 6)
122 #define XUSB_PADCTL_HSIC_PAD_CTL0_PD_RX_DATA1 (1 << 5)
123 #define XUSB_PADCTL_HSIC_PAD_CTL0_PD_RX_DATA0 (1 << 4)
124 #define XUSB_PADCTL_HSIC_PAD_CTL0_PD_TX_STROBE (1 << 3)
125 #define XUSB_PADCTL_HSIC_PAD_CTL0_PD_TX_DATA1 (1 << 2)
126 #define XUSB_PADCTL_HSIC_PAD_CTL0_PD_TX_DATA0 (1 << 1)
127
128 #define XUSB_PADCTL_HSIC_PADX_CTL1(x) (0x304 + (x) * 0x20)
129 #define XUSB_PADCTL_HSIC_PAD_CTL1_TX_RTUNEP_SHIFT 0
130 #define XUSB_PADCTL_HSIC_PAD_CTL1_TX_RTUNEP_MASK 0xf
131
132 #define XUSB_PADCTL_HSIC_PADX_CTL2(x) (0x308 + (x) * 0x20)
133 #define XUSB_PADCTL_HSIC_PAD_CTL2_RX_STROBE_TRIM_SHIFT 8
134 #define XUSB_PADCTL_HSIC_PAD_CTL2_RX_STROBE_TRIM_MASK 0xf
135 #define XUSB_PADCTL_HSIC_PAD_CTL2_RX_DATA_TRIM_SHIFT 0
136 #define XUSB_PADCTL_HSIC_PAD_CTL2_RX_DATA_TRIM_MASK 0xff
137
138 #define XUSB_PADCTL_HSIC_PAD_TRK_CTL 0x340
139 #define XUSB_PADCTL_HSIC_PAD_TRK_CTL_PD_TRK (1 << 19)
140 #define XUSB_PADCTL_HSIC_PAD_TRK_CTL_TRK_DONE_RESET_TIMER_SHIFT 12
141 #define XUSB_PADCTL_HSIC_PAD_TRK_CTL_TRK_DONE_RESET_TIMER_MASK 0x7f
142 #define XUSB_PADCTL_HSIC_PAD_TRK_CTL_TRK_DONE_RESET_TIMER_VAL 0x0a
143 #define XUSB_PADCTL_HSIC_PAD_TRK_CTL_TRK_START_TIMER_SHIFT 5
144 #define XUSB_PADCTL_HSIC_PAD_TRK_CTL_TRK_START_TIMER_MASK 0x7f
145 #define XUSB_PADCTL_HSIC_PAD_TRK_CTL_TRK_START_TIMER_VAL 0x1e
146
147 #define XUSB_PADCTL_HSIC_STRB_TRIM_CONTROL 0x344
148
149 #define XUSB_PADCTL_UPHY_PLL_P0_CTL1 0x360
150 #define XUSB_PADCTL_UPHY_PLL_CTL1_FREQ_NDIV_SHIFT 20
151 #define XUSB_PADCTL_UPHY_PLL_CTL1_FREQ_NDIV_MASK 0xff
152 #define XUSB_PADCTL_UPHY_PLL_CTL1_FREQ_NDIV_USB_VAL 0x19
153 #define XUSB_PADCTL_UPHY_PLL_CTL1_FREQ_NDIV_SATA_VAL 0x1e
154 #define XUSB_PADCTL_UPHY_PLL_CTL1_FREQ_MDIV_SHIFT 16
155 #define XUSB_PADCTL_UPHY_PLL_CTL1_FREQ_MDIV_MASK 0x3
156 #define XUSB_PADCTL_UPHY_PLL_CTL1_LOCKDET_STATUS (1 << 15)
157 #define XUSB_PADCTL_UPHY_PLL_CTL1_PWR_OVRD (1 << 4)
158 #define XUSB_PADCTL_UPHY_PLL_CTL1_ENABLE (1 << 3)
159 #define XUSB_PADCTL_UPHY_PLL_CTL1_SLEEP_SHIFT 1
160 #define XUSB_PADCTL_UPHY_PLL_CTL1_SLEEP_MASK 0x3
161 #define XUSB_PADCTL_UPHY_PLL_CTL1_IDDQ (1 << 0)
162
163 #define XUSB_PADCTL_UPHY_PLL_P0_CTL2 0x364
164 #define XUSB_PADCTL_UPHY_PLL_CTL2_CAL_CTRL_SHIFT 4
165 #define XUSB_PADCTL_UPHY_PLL_CTL2_CAL_CTRL_MASK 0xffffff
166 #define XUSB_PADCTL_UPHY_PLL_CTL2_CAL_CTRL_VAL 0x136
167 #define XUSB_PADCTL_UPHY_PLL_CTL2_CAL_OVRD (1 << 2)
168 #define XUSB_PADCTL_UPHY_PLL_CTL2_CAL_DONE (1 << 1)
169 #define XUSB_PADCTL_UPHY_PLL_CTL2_CAL_EN (1 << 0)
170
171 #define XUSB_PADCTL_UPHY_PLL_P0_CTL4 0x36c
172 #define XUSB_PADCTL_UPHY_PLL_CTL4_TXCLKREF_EN (1 << 15)
173 #define XUSB_PADCTL_UPHY_PLL_CTL4_TXCLKREF_SEL_SHIFT 12
174 #define XUSB_PADCTL_UPHY_PLL_CTL4_TXCLKREF_SEL_MASK 0x3
175 #define XUSB_PADCTL_UPHY_PLL_CTL4_TXCLKREF_SEL_USB_VAL 0x2
176 #define XUSB_PADCTL_UPHY_PLL_CTL4_TXCLKREF_SEL_SATA_VAL 0x0
177 #define XUSB_PADCTL_UPHY_PLL_CTL4_REFCLKBUF_EN (1 << 8)
178 #define XUSB_PADCTL_UPHY_PLL_CTL4_REFCLK_SEL_SHIFT 4
179 #define XUSB_PADCTL_UPHY_PLL_CTL4_REFCLK_SEL_MASK 0xf
180
181 #define XUSB_PADCTL_UPHY_PLL_P0_CTL5 0x370
182 #define XUSB_PADCTL_UPHY_PLL_CTL5_DCO_CTRL_SHIFT 16
183 #define XUSB_PADCTL_UPHY_PLL_CTL5_DCO_CTRL_MASK 0xff
184 #define XUSB_PADCTL_UPHY_PLL_CTL5_DCO_CTRL_VAL 0x2a
185
186 #define XUSB_PADCTL_UPHY_PLL_P0_CTL8 0x37c
187 #define XUSB_PADCTL_UPHY_PLL_CTL8_RCAL_DONE (1 << 31)
188 #define XUSB_PADCTL_UPHY_PLL_CTL8_RCAL_OVRD (1 << 15)
189 #define XUSB_PADCTL_UPHY_PLL_CTL8_RCAL_CLK_EN (1 << 13)
190 #define XUSB_PADCTL_UPHY_PLL_CTL8_RCAL_EN (1 << 12)
191
192 #define XUSB_PADCTL_UPHY_MISC_PAD_PX_CTL1(x) (0x460 + (x) * 0x40)
193 #define XUSB_PADCTL_UPHY_MISC_PAD_CTL1_AUX_RX_IDLE_MODE_SHIFT 20
194 #define XUSB_PADCTL_UPHY_MISC_PAD_CTL1_AUX_RX_IDLE_MODE_MASK 0x3
195 #define XUSB_PADCTL_UPHY_MISC_PAD_CTL1_AUX_RX_IDLE_MODE_VAL 0x1
196 #define XUSB_PADCTL_UPHY_MISC_PAD_CTL1_AUX_RX_TERM_EN BIT(18)
197 #define XUSB_PADCTL_UPHY_MISC_PAD_CTL1_AUX_RX_MODE_OVRD BIT(13)
198
199 #define XUSB_PADCTL_UPHY_PLL_S0_CTL1 0x860
200
201 #define XUSB_PADCTL_UPHY_PLL_S0_CTL2 0x864
202
203 #define XUSB_PADCTL_UPHY_PLL_S0_CTL4 0x86c
204
205 #define XUSB_PADCTL_UPHY_PLL_S0_CTL5 0x870
206
207 #define XUSB_PADCTL_UPHY_PLL_S0_CTL8 0x87c
208
209 #define XUSB_PADCTL_UPHY_MISC_PAD_S0_CTL1 0x960
210
211 #define XUSB_PADCTL_UPHY_USB3_PADX_ECTL1(x) (0xa60 + (x) * 0x40)
212 #define XUSB_PADCTL_UPHY_USB3_PAD_ECTL1_TX_TERM_CTRL_SHIFT 16
213 #define XUSB_PADCTL_UPHY_USB3_PAD_ECTL1_TX_TERM_CTRL_MASK 0x3
214 #define XUSB_PADCTL_UPHY_USB3_PAD_ECTL1_TX_TERM_CTRL_VAL 0x2
215
216 #define XUSB_PADCTL_UPHY_USB3_PADX_ECTL2(x) (0xa64 + (x) * 0x40)
217 #define XUSB_PADCTL_UPHY_USB3_PAD_ECTL2_RX_CTLE_SHIFT 0
218 #define XUSB_PADCTL_UPHY_USB3_PAD_ECTL2_RX_CTLE_MASK 0xffff
219 #define XUSB_PADCTL_UPHY_USB3_PAD_ECTL2_RX_CTLE_VAL 0x00fc
220
221 #define XUSB_PADCTL_UPHY_USB3_PADX_ECTL3(x) (0xa68 + (x) * 0x40)
222 #define XUSB_PADCTL_UPHY_USB3_PAD_ECTL3_RX_DFE_VAL 0xc0077f1f
223
224 #define XUSB_PADCTL_UPHY_USB3_PADX_ECTL4(x) (0xa6c + (x) * 0x40)
225 #define XUSB_PADCTL_UPHY_USB3_PAD_ECTL4_RX_CDR_CTRL_SHIFT 16
226 #define XUSB_PADCTL_UPHY_USB3_PAD_ECTL4_RX_CDR_CTRL_MASK 0xffff
227 #define XUSB_PADCTL_UPHY_USB3_PAD_ECTL4_RX_CDR_CTRL_VAL 0x01c7
228
229 #define XUSB_PADCTL_UPHY_USB3_PADX_ECTL6(x) (0xa74 + (x) * 0x40)
230 #define XUSB_PADCTL_UPHY_USB3_PAD_ECTL6_RX_EQ_CTRL_H_VAL 0xfcf01368
231
232 struct tegra210_xusb_fuse_calibration {
233         u32 hs_curr_level[4];
234         u32 hs_term_range_adj;
235         u32 rpd_ctrl;
236 };
237
238 struct tegra210_xusb_padctl {
239         struct tegra_xusb_padctl base;
240
241         struct tegra210_xusb_fuse_calibration fuse;
242 };
243
244 static inline struct tegra210_xusb_padctl *
245 to_tegra210_xusb_padctl(struct tegra_xusb_padctl *padctl)
246 {
247         return container_of(padctl, struct tegra210_xusb_padctl, base);
248 }
249
250 /* must be called under padctl->lock */
251 static int tegra210_pex_uphy_enable(struct tegra_xusb_padctl *padctl)
252 {
253         struct tegra_xusb_pcie_pad *pcie = to_pcie_pad(padctl->pcie);
254         unsigned long timeout;
255         u32 value;
256         int err;
257
258         if (pcie->enable > 0) {
259                 pcie->enable++;
260                 return 0;
261         }
262
263         err = clk_prepare_enable(pcie->pll);
264         if (err < 0)
265                 return err;
266
267         err = reset_control_deassert(pcie->rst);
268         if (err < 0)
269                 goto disable;
270
271         value = padctl_readl(padctl, XUSB_PADCTL_UPHY_PLL_P0_CTL2);
272         value &= ~(XUSB_PADCTL_UPHY_PLL_CTL2_CAL_CTRL_MASK <<
273                    XUSB_PADCTL_UPHY_PLL_CTL2_CAL_CTRL_SHIFT);
274         value |= XUSB_PADCTL_UPHY_PLL_CTL2_CAL_CTRL_VAL <<
275                  XUSB_PADCTL_UPHY_PLL_CTL2_CAL_CTRL_SHIFT;
276         padctl_writel(padctl, value, XUSB_PADCTL_UPHY_PLL_P0_CTL2);
277
278         value = padctl_readl(padctl, XUSB_PADCTL_UPHY_PLL_P0_CTL5);
279         value &= ~(XUSB_PADCTL_UPHY_PLL_CTL5_DCO_CTRL_MASK <<
280                    XUSB_PADCTL_UPHY_PLL_CTL5_DCO_CTRL_SHIFT);
281         value |= XUSB_PADCTL_UPHY_PLL_CTL5_DCO_CTRL_VAL <<
282                  XUSB_PADCTL_UPHY_PLL_CTL5_DCO_CTRL_SHIFT;
283         padctl_writel(padctl, value, XUSB_PADCTL_UPHY_PLL_P0_CTL5);
284
285         value = padctl_readl(padctl, XUSB_PADCTL_UPHY_PLL_P0_CTL1);
286         value |= XUSB_PADCTL_UPHY_PLL_CTL1_PWR_OVRD;
287         padctl_writel(padctl, value, XUSB_PADCTL_UPHY_PLL_P0_CTL1);
288
289         value = padctl_readl(padctl, XUSB_PADCTL_UPHY_PLL_P0_CTL2);
290         value |= XUSB_PADCTL_UPHY_PLL_CTL2_CAL_OVRD;
291         padctl_writel(padctl, value, XUSB_PADCTL_UPHY_PLL_P0_CTL2);
292
293         value = padctl_readl(padctl, XUSB_PADCTL_UPHY_PLL_P0_CTL8);
294         value |= XUSB_PADCTL_UPHY_PLL_CTL8_RCAL_OVRD;
295         padctl_writel(padctl, value, XUSB_PADCTL_UPHY_PLL_P0_CTL8);
296
297         value = padctl_readl(padctl, XUSB_PADCTL_UPHY_PLL_P0_CTL4);
298         value &= ~((XUSB_PADCTL_UPHY_PLL_CTL4_TXCLKREF_SEL_MASK <<
299                     XUSB_PADCTL_UPHY_PLL_CTL4_TXCLKREF_SEL_SHIFT) |
300                    (XUSB_PADCTL_UPHY_PLL_CTL4_REFCLK_SEL_MASK <<
301                     XUSB_PADCTL_UPHY_PLL_CTL4_REFCLK_SEL_SHIFT));
302         value |= (XUSB_PADCTL_UPHY_PLL_CTL4_TXCLKREF_SEL_USB_VAL <<
303                   XUSB_PADCTL_UPHY_PLL_CTL4_TXCLKREF_SEL_SHIFT) |
304                  XUSB_PADCTL_UPHY_PLL_CTL4_TXCLKREF_EN;
305         padctl_writel(padctl, value, XUSB_PADCTL_UPHY_PLL_P0_CTL4);
306
307         value = padctl_readl(padctl, XUSB_PADCTL_UPHY_PLL_P0_CTL1);
308         value &= ~((XUSB_PADCTL_UPHY_PLL_CTL1_FREQ_MDIV_MASK <<
309                     XUSB_PADCTL_UPHY_PLL_CTL1_FREQ_MDIV_SHIFT) |
310                    (XUSB_PADCTL_UPHY_PLL_CTL1_FREQ_NDIV_MASK <<
311                     XUSB_PADCTL_UPHY_PLL_CTL1_FREQ_NDIV_SHIFT));
312         value |= XUSB_PADCTL_UPHY_PLL_CTL1_FREQ_NDIV_USB_VAL <<
313                  XUSB_PADCTL_UPHY_PLL_CTL1_FREQ_NDIV_SHIFT;
314         padctl_writel(padctl, value, XUSB_PADCTL_UPHY_PLL_P0_CTL1);
315
316         value = padctl_readl(padctl, XUSB_PADCTL_UPHY_PLL_P0_CTL1);
317         value &= ~XUSB_PADCTL_UPHY_PLL_CTL1_IDDQ;
318         padctl_writel(padctl, value, XUSB_PADCTL_UPHY_PLL_P0_CTL1);
319
320         value = padctl_readl(padctl, XUSB_PADCTL_UPHY_PLL_P0_CTL1);
321         value &= ~(XUSB_PADCTL_UPHY_PLL_CTL1_SLEEP_MASK <<
322                    XUSB_PADCTL_UPHY_PLL_CTL1_SLEEP_SHIFT);
323         padctl_writel(padctl, value, XUSB_PADCTL_UPHY_PLL_P0_CTL1);
324
325         usleep_range(10, 20);
326
327         value = padctl_readl(padctl, XUSB_PADCTL_UPHY_PLL_P0_CTL4);
328         value |= XUSB_PADCTL_UPHY_PLL_CTL4_REFCLKBUF_EN;
329         padctl_writel(padctl, value, XUSB_PADCTL_UPHY_PLL_P0_CTL4);
330
331         value = padctl_readl(padctl, XUSB_PADCTL_UPHY_PLL_P0_CTL2);
332         value |= XUSB_PADCTL_UPHY_PLL_CTL2_CAL_EN;
333         padctl_writel(padctl, value, XUSB_PADCTL_UPHY_PLL_P0_CTL2);
334
335         timeout = jiffies + msecs_to_jiffies(100);
336
337         while (time_before(jiffies, timeout)) {
338                 value = padctl_readl(padctl, XUSB_PADCTL_UPHY_PLL_P0_CTL2);
339                 if (value & XUSB_PADCTL_UPHY_PLL_CTL2_CAL_DONE)
340                         break;
341
342                 usleep_range(10, 20);
343         }
344
345         if (time_after_eq(jiffies, timeout)) {
346                 err = -ETIMEDOUT;
347                 goto reset;
348         }
349
350         value = padctl_readl(padctl, XUSB_PADCTL_UPHY_PLL_P0_CTL2);
351         value &= ~XUSB_PADCTL_UPHY_PLL_CTL2_CAL_EN;
352         padctl_writel(padctl, value, XUSB_PADCTL_UPHY_PLL_P0_CTL2);
353
354         timeout = jiffies + msecs_to_jiffies(100);
355
356         while (time_before(jiffies, timeout)) {
357                 value = padctl_readl(padctl, XUSB_PADCTL_UPHY_PLL_P0_CTL2);
358                 if (!(value & XUSB_PADCTL_UPHY_PLL_CTL2_CAL_DONE))
359                         break;
360
361                 usleep_range(10, 20);
362         }
363
364         if (time_after_eq(jiffies, timeout)) {
365                 err = -ETIMEDOUT;
366                 goto reset;
367         }
368
369         value = padctl_readl(padctl, XUSB_PADCTL_UPHY_PLL_P0_CTL1);
370         value |= XUSB_PADCTL_UPHY_PLL_CTL1_ENABLE;
371         padctl_writel(padctl, value, XUSB_PADCTL_UPHY_PLL_P0_CTL1);
372
373         timeout = jiffies + msecs_to_jiffies(100);
374
375         while (time_before(jiffies, timeout)) {
376                 value = padctl_readl(padctl, XUSB_PADCTL_UPHY_PLL_P0_CTL1);
377                 if (value & XUSB_PADCTL_UPHY_PLL_CTL1_LOCKDET_STATUS)
378                         break;
379
380                 usleep_range(10, 20);
381         }
382
383         if (time_after_eq(jiffies, timeout)) {
384                 err = -ETIMEDOUT;
385                 goto reset;
386         }
387
388         value = padctl_readl(padctl, XUSB_PADCTL_UPHY_PLL_P0_CTL8);
389         value |= XUSB_PADCTL_UPHY_PLL_CTL8_RCAL_EN |
390                  XUSB_PADCTL_UPHY_PLL_CTL8_RCAL_CLK_EN;
391         padctl_writel(padctl, value, XUSB_PADCTL_UPHY_PLL_P0_CTL8);
392
393         timeout = jiffies + msecs_to_jiffies(100);
394
395         while (time_before(jiffies, timeout)) {
396                 value = padctl_readl(padctl, XUSB_PADCTL_UPHY_PLL_P0_CTL8);
397                 if (value & XUSB_PADCTL_UPHY_PLL_CTL8_RCAL_DONE)
398                         break;
399
400                 usleep_range(10, 20);
401         }
402
403         if (time_after_eq(jiffies, timeout)) {
404                 err = -ETIMEDOUT;
405                 goto reset;
406         }
407
408         value = padctl_readl(padctl, XUSB_PADCTL_UPHY_PLL_P0_CTL8);
409         value &= ~XUSB_PADCTL_UPHY_PLL_CTL8_RCAL_EN;
410         padctl_writel(padctl, value, XUSB_PADCTL_UPHY_PLL_P0_CTL8);
411
412         timeout = jiffies + msecs_to_jiffies(100);
413
414         while (time_before(jiffies, timeout)) {
415                 value = padctl_readl(padctl, XUSB_PADCTL_UPHY_PLL_P0_CTL8);
416                 if (!(value & XUSB_PADCTL_UPHY_PLL_CTL8_RCAL_DONE))
417                         break;
418
419                 usleep_range(10, 20);
420         }
421
422         if (time_after_eq(jiffies, timeout)) {
423                 err = -ETIMEDOUT;
424                 goto reset;
425         }
426
427         value = padctl_readl(padctl, XUSB_PADCTL_UPHY_PLL_P0_CTL8);
428         value &= ~XUSB_PADCTL_UPHY_PLL_CTL8_RCAL_CLK_EN;
429         padctl_writel(padctl, value, XUSB_PADCTL_UPHY_PLL_P0_CTL8);
430
431         tegra210_xusb_pll_hw_control_enable();
432
433         value = padctl_readl(padctl, XUSB_PADCTL_UPHY_PLL_P0_CTL1);
434         value &= ~XUSB_PADCTL_UPHY_PLL_CTL1_PWR_OVRD;
435         padctl_writel(padctl, value, XUSB_PADCTL_UPHY_PLL_P0_CTL1);
436
437         value = padctl_readl(padctl, XUSB_PADCTL_UPHY_PLL_P0_CTL2);
438         value &= ~XUSB_PADCTL_UPHY_PLL_CTL2_CAL_OVRD;
439         padctl_writel(padctl, value, XUSB_PADCTL_UPHY_PLL_P0_CTL2);
440
441         value = padctl_readl(padctl, XUSB_PADCTL_UPHY_PLL_P0_CTL8);
442         value &= ~XUSB_PADCTL_UPHY_PLL_CTL8_RCAL_OVRD;
443         padctl_writel(padctl, value, XUSB_PADCTL_UPHY_PLL_P0_CTL8);
444
445         usleep_range(10, 20);
446
447         tegra210_xusb_pll_hw_sequence_start();
448
449         pcie->enable++;
450
451         return 0;
452
453 reset:
454         reset_control_assert(pcie->rst);
455 disable:
456         clk_disable_unprepare(pcie->pll);
457         return err;
458 }
459
460 static void tegra210_pex_uphy_disable(struct tegra_xusb_padctl *padctl)
461 {
462         struct tegra_xusb_pcie_pad *pcie = to_pcie_pad(padctl->pcie);
463
464         mutex_lock(&padctl->lock);
465
466         if (WARN_ON(pcie->enable == 0))
467                 goto unlock;
468
469         if (--pcie->enable > 0)
470                 goto unlock;
471
472         reset_control_assert(pcie->rst);
473         clk_disable_unprepare(pcie->pll);
474
475 unlock:
476         mutex_unlock(&padctl->lock);
477 }
478
479 /* must be called under padctl->lock */
480 static int tegra210_sata_uphy_enable(struct tegra_xusb_padctl *padctl, bool usb)
481 {
482         struct tegra_xusb_sata_pad *sata = to_sata_pad(padctl->sata);
483         unsigned long timeout;
484         u32 value;
485         int err;
486
487         if (sata->enable > 0) {
488                 sata->enable++;
489                 return 0;
490         }
491
492         err = clk_prepare_enable(sata->pll);
493         if (err < 0)
494                 return err;
495
496         err = reset_control_deassert(sata->rst);
497         if (err < 0)
498                 goto disable;
499
500         value = padctl_readl(padctl, XUSB_PADCTL_UPHY_PLL_S0_CTL2);
501         value &= ~(XUSB_PADCTL_UPHY_PLL_CTL2_CAL_CTRL_MASK <<
502                    XUSB_PADCTL_UPHY_PLL_CTL2_CAL_CTRL_SHIFT);
503         value |= XUSB_PADCTL_UPHY_PLL_CTL2_CAL_CTRL_VAL <<
504                  XUSB_PADCTL_UPHY_PLL_CTL2_CAL_CTRL_SHIFT;
505         padctl_writel(padctl, value, XUSB_PADCTL_UPHY_PLL_S0_CTL2);
506
507         value = padctl_readl(padctl, XUSB_PADCTL_UPHY_PLL_S0_CTL5);
508         value &= ~(XUSB_PADCTL_UPHY_PLL_CTL5_DCO_CTRL_MASK <<
509                    XUSB_PADCTL_UPHY_PLL_CTL5_DCO_CTRL_SHIFT);
510         value |= XUSB_PADCTL_UPHY_PLL_CTL5_DCO_CTRL_VAL <<
511                  XUSB_PADCTL_UPHY_PLL_CTL5_DCO_CTRL_SHIFT;
512         padctl_writel(padctl, value, XUSB_PADCTL_UPHY_PLL_S0_CTL5);
513
514         value = padctl_readl(padctl, XUSB_PADCTL_UPHY_PLL_S0_CTL1);
515         value |= XUSB_PADCTL_UPHY_PLL_CTL1_PWR_OVRD;
516         padctl_writel(padctl, value, XUSB_PADCTL_UPHY_PLL_S0_CTL1);
517
518         value = padctl_readl(padctl, XUSB_PADCTL_UPHY_PLL_S0_CTL2);
519         value |= XUSB_PADCTL_UPHY_PLL_CTL2_CAL_OVRD;
520         padctl_writel(padctl, value, XUSB_PADCTL_UPHY_PLL_S0_CTL2);
521
522         value = padctl_readl(padctl, XUSB_PADCTL_UPHY_PLL_S0_CTL8);
523         value |= XUSB_PADCTL_UPHY_PLL_CTL8_RCAL_OVRD;
524         padctl_writel(padctl, value, XUSB_PADCTL_UPHY_PLL_S0_CTL8);
525
526         value = padctl_readl(padctl, XUSB_PADCTL_UPHY_PLL_S0_CTL4);
527         value &= ~((XUSB_PADCTL_UPHY_PLL_CTL4_TXCLKREF_SEL_MASK <<
528                     XUSB_PADCTL_UPHY_PLL_CTL4_TXCLKREF_SEL_SHIFT) |
529                    (XUSB_PADCTL_UPHY_PLL_CTL4_REFCLK_SEL_MASK <<
530                     XUSB_PADCTL_UPHY_PLL_CTL4_REFCLK_SEL_SHIFT));
531         value |= XUSB_PADCTL_UPHY_PLL_CTL4_TXCLKREF_EN;
532
533         if (usb)
534                 value |= (XUSB_PADCTL_UPHY_PLL_CTL4_TXCLKREF_SEL_USB_VAL <<
535                           XUSB_PADCTL_UPHY_PLL_CTL4_TXCLKREF_SEL_SHIFT);
536         else
537                 value |= (XUSB_PADCTL_UPHY_PLL_CTL4_TXCLKREF_SEL_SATA_VAL <<
538                           XUSB_PADCTL_UPHY_PLL_CTL4_TXCLKREF_SEL_SHIFT);
539
540         /* XXX PLL0_XDIGCLK_EN */
541         /*
542         value &= ~(1 << 19);
543         padctl_writel(padctl, value, XUSB_PADCTL_UPHY_PLL_S0_CTL4);
544         */
545
546         value = padctl_readl(padctl, XUSB_PADCTL_UPHY_PLL_S0_CTL1);
547         value &= ~((XUSB_PADCTL_UPHY_PLL_CTL1_FREQ_MDIV_MASK <<
548                     XUSB_PADCTL_UPHY_PLL_CTL1_FREQ_MDIV_SHIFT) |
549                    (XUSB_PADCTL_UPHY_PLL_CTL1_FREQ_NDIV_MASK <<
550                     XUSB_PADCTL_UPHY_PLL_CTL1_FREQ_NDIV_SHIFT));
551
552         if (usb)
553                 value |= XUSB_PADCTL_UPHY_PLL_CTL1_FREQ_NDIV_USB_VAL <<
554                          XUSB_PADCTL_UPHY_PLL_CTL1_FREQ_NDIV_SHIFT;
555         else
556                 value |= XUSB_PADCTL_UPHY_PLL_CTL1_FREQ_NDIV_SATA_VAL <<
557                          XUSB_PADCTL_UPHY_PLL_CTL1_FREQ_NDIV_SHIFT;
558
559         padctl_writel(padctl, value, XUSB_PADCTL_UPHY_PLL_S0_CTL1);
560
561         value = padctl_readl(padctl, XUSB_PADCTL_UPHY_PLL_S0_CTL1);
562         value &= ~XUSB_PADCTL_UPHY_PLL_CTL1_IDDQ;
563         padctl_writel(padctl, value, XUSB_PADCTL_UPHY_PLL_S0_CTL1);
564
565         value = padctl_readl(padctl, XUSB_PADCTL_UPHY_PLL_S0_CTL1);
566         value &= ~(XUSB_PADCTL_UPHY_PLL_CTL1_SLEEP_MASK <<
567                    XUSB_PADCTL_UPHY_PLL_CTL1_SLEEP_SHIFT);
568         padctl_writel(padctl, value, XUSB_PADCTL_UPHY_PLL_S0_CTL1);
569
570         usleep_range(10, 20);
571
572         value = padctl_readl(padctl, XUSB_PADCTL_UPHY_PLL_S0_CTL4);
573         value |= XUSB_PADCTL_UPHY_PLL_CTL4_REFCLKBUF_EN;
574         padctl_writel(padctl, value, XUSB_PADCTL_UPHY_PLL_S0_CTL4);
575
576         value = padctl_readl(padctl, XUSB_PADCTL_UPHY_PLL_S0_CTL2);
577         value |= XUSB_PADCTL_UPHY_PLL_CTL2_CAL_EN;
578         padctl_writel(padctl, value, XUSB_PADCTL_UPHY_PLL_S0_CTL2);
579
580         timeout = jiffies + msecs_to_jiffies(100);
581
582         while (time_before(jiffies, timeout)) {
583                 value = padctl_readl(padctl, XUSB_PADCTL_UPHY_PLL_S0_CTL2);
584                 if (value & XUSB_PADCTL_UPHY_PLL_CTL2_CAL_DONE)
585                         break;
586
587                 usleep_range(10, 20);
588         }
589
590         if (time_after_eq(jiffies, timeout)) {
591                 err = -ETIMEDOUT;
592                 goto reset;
593         }
594
595         value = padctl_readl(padctl, XUSB_PADCTL_UPHY_PLL_S0_CTL2);
596         value &= ~XUSB_PADCTL_UPHY_PLL_CTL2_CAL_EN;
597         padctl_writel(padctl, value, XUSB_PADCTL_UPHY_PLL_S0_CTL2);
598
599         timeout = jiffies + msecs_to_jiffies(100);
600
601         while (time_before(jiffies, timeout)) {
602                 value = padctl_readl(padctl, XUSB_PADCTL_UPHY_PLL_S0_CTL2);
603                 if (!(value & XUSB_PADCTL_UPHY_PLL_CTL2_CAL_DONE))
604                         break;
605
606                 usleep_range(10, 20);
607         }
608
609         if (time_after_eq(jiffies, timeout)) {
610                 err = -ETIMEDOUT;
611                 goto reset;
612         }
613
614         value = padctl_readl(padctl, XUSB_PADCTL_UPHY_PLL_S0_CTL1);
615         value |= XUSB_PADCTL_UPHY_PLL_CTL1_ENABLE;
616         padctl_writel(padctl, value, XUSB_PADCTL_UPHY_PLL_S0_CTL1);
617
618         timeout = jiffies + msecs_to_jiffies(100);
619
620         while (time_before(jiffies, timeout)) {
621                 value = padctl_readl(padctl, XUSB_PADCTL_UPHY_PLL_S0_CTL1);
622                 if (value & XUSB_PADCTL_UPHY_PLL_CTL1_LOCKDET_STATUS)
623                         break;
624
625                 usleep_range(10, 20);
626         }
627
628         if (time_after_eq(jiffies, timeout)) {
629                 err = -ETIMEDOUT;
630                 goto reset;
631         }
632
633         value = padctl_readl(padctl, XUSB_PADCTL_UPHY_PLL_S0_CTL8);
634         value |= XUSB_PADCTL_UPHY_PLL_CTL8_RCAL_EN |
635                  XUSB_PADCTL_UPHY_PLL_CTL8_RCAL_CLK_EN;
636         padctl_writel(padctl, value, XUSB_PADCTL_UPHY_PLL_S0_CTL8);
637
638         timeout = jiffies + msecs_to_jiffies(100);
639
640         while (time_before(jiffies, timeout)) {
641                 value = padctl_readl(padctl, XUSB_PADCTL_UPHY_PLL_S0_CTL8);
642                 if (value & XUSB_PADCTL_UPHY_PLL_CTL8_RCAL_DONE)
643                         break;
644
645                 usleep_range(10, 20);
646         }
647
648         if (time_after_eq(jiffies, timeout)) {
649                 err = -ETIMEDOUT;
650                 goto reset;
651         }
652
653         value = padctl_readl(padctl, XUSB_PADCTL_UPHY_PLL_S0_CTL8);
654         value &= ~XUSB_PADCTL_UPHY_PLL_CTL8_RCAL_EN;
655         padctl_writel(padctl, value, XUSB_PADCTL_UPHY_PLL_S0_CTL8);
656
657         timeout = jiffies + msecs_to_jiffies(100);
658
659         while (time_before(jiffies, timeout)) {
660                 value = padctl_readl(padctl, XUSB_PADCTL_UPHY_PLL_S0_CTL8);
661                 if (!(value & XUSB_PADCTL_UPHY_PLL_CTL8_RCAL_DONE))
662                         break;
663
664                 usleep_range(10, 20);
665         }
666
667         if (time_after_eq(jiffies, timeout)) {
668                 err = -ETIMEDOUT;
669                 goto reset;
670         }
671
672         value = padctl_readl(padctl, XUSB_PADCTL_UPHY_PLL_S0_CTL8);
673         value &= ~XUSB_PADCTL_UPHY_PLL_CTL8_RCAL_CLK_EN;
674         padctl_writel(padctl, value, XUSB_PADCTL_UPHY_PLL_S0_CTL8);
675
676         tegra210_sata_pll_hw_control_enable();
677
678         value = padctl_readl(padctl, XUSB_PADCTL_UPHY_PLL_S0_CTL1);
679         value &= ~XUSB_PADCTL_UPHY_PLL_CTL1_PWR_OVRD;
680         padctl_writel(padctl, value, XUSB_PADCTL_UPHY_PLL_S0_CTL1);
681
682         value = padctl_readl(padctl, XUSB_PADCTL_UPHY_PLL_S0_CTL2);
683         value &= ~XUSB_PADCTL_UPHY_PLL_CTL2_CAL_OVRD;
684         padctl_writel(padctl, value, XUSB_PADCTL_UPHY_PLL_S0_CTL2);
685
686         value = padctl_readl(padctl, XUSB_PADCTL_UPHY_PLL_S0_CTL8);
687         value &= ~XUSB_PADCTL_UPHY_PLL_CTL8_RCAL_OVRD;
688         padctl_writel(padctl, value, XUSB_PADCTL_UPHY_PLL_S0_CTL8);
689
690         usleep_range(10, 20);
691
692         tegra210_sata_pll_hw_sequence_start();
693
694         sata->enable++;
695
696         return 0;
697
698 reset:
699         reset_control_assert(sata->rst);
700 disable:
701         clk_disable_unprepare(sata->pll);
702         return err;
703 }
704
705 static void tegra210_sata_uphy_disable(struct tegra_xusb_padctl *padctl)
706 {
707         struct tegra_xusb_sata_pad *sata = to_sata_pad(padctl->sata);
708
709         mutex_lock(&padctl->lock);
710
711         if (WARN_ON(sata->enable == 0))
712                 goto unlock;
713
714         if (--sata->enable > 0)
715                 goto unlock;
716
717         reset_control_assert(sata->rst);
718         clk_disable_unprepare(sata->pll);
719
720 unlock:
721         mutex_unlock(&padctl->lock);
722 }
723
724 static int tegra210_xusb_padctl_enable(struct tegra_xusb_padctl *padctl)
725 {
726         u32 value;
727
728         mutex_lock(&padctl->lock);
729
730         if (padctl->enable++ > 0)
731                 goto out;
732
733         value = padctl_readl(padctl, XUSB_PADCTL_ELPG_PROGRAM1);
734         value &= ~XUSB_PADCTL_ELPG_PROGRAM1_AUX_MUX_LP0_CLAMP_EN;
735         padctl_writel(padctl, value, XUSB_PADCTL_ELPG_PROGRAM1);
736
737         usleep_range(100, 200);
738
739         value = padctl_readl(padctl, XUSB_PADCTL_ELPG_PROGRAM1);
740         value &= ~XUSB_PADCTL_ELPG_PROGRAM1_AUX_MUX_LP0_CLAMP_EN_EARLY;
741         padctl_writel(padctl, value, XUSB_PADCTL_ELPG_PROGRAM1);
742
743         usleep_range(100, 200);
744
745         value = padctl_readl(padctl, XUSB_PADCTL_ELPG_PROGRAM1);
746         value &= ~XUSB_PADCTL_ELPG_PROGRAM1_AUX_MUX_LP0_VCORE_DOWN;
747         padctl_writel(padctl, value, XUSB_PADCTL_ELPG_PROGRAM1);
748
749 out:
750         mutex_unlock(&padctl->lock);
751         return 0;
752 }
753
754 static int tegra210_xusb_padctl_disable(struct tegra_xusb_padctl *padctl)
755 {
756         u32 value;
757
758         mutex_lock(&padctl->lock);
759
760         if (WARN_ON(padctl->enable == 0))
761                 goto out;
762
763         if (--padctl->enable > 0)
764                 goto out;
765
766         value = padctl_readl(padctl, XUSB_PADCTL_ELPG_PROGRAM1);
767         value |= XUSB_PADCTL_ELPG_PROGRAM1_AUX_MUX_LP0_VCORE_DOWN;
768         padctl_writel(padctl, value, XUSB_PADCTL_ELPG_PROGRAM1);
769
770         usleep_range(100, 200);
771
772         value = padctl_readl(padctl, XUSB_PADCTL_ELPG_PROGRAM1);
773         value |= XUSB_PADCTL_ELPG_PROGRAM1_AUX_MUX_LP0_CLAMP_EN_EARLY;
774         padctl_writel(padctl, value, XUSB_PADCTL_ELPG_PROGRAM1);
775
776         usleep_range(100, 200);
777
778         value = padctl_readl(padctl, XUSB_PADCTL_ELPG_PROGRAM1);
779         value |= XUSB_PADCTL_ELPG_PROGRAM1_AUX_MUX_LP0_CLAMP_EN;
780         padctl_writel(padctl, value, XUSB_PADCTL_ELPG_PROGRAM1);
781
782 out:
783         mutex_unlock(&padctl->lock);
784         return 0;
785 }
786
787 static int tegra210_hsic_set_idle(struct tegra_xusb_padctl *padctl,
788                                   unsigned int index, bool idle)
789 {
790         u32 value;
791
792         value = padctl_readl(padctl, XUSB_PADCTL_HSIC_PADX_CTL0(index));
793
794         value &= ~(XUSB_PADCTL_HSIC_PAD_CTL0_RPU_DATA0 |
795                    XUSB_PADCTL_HSIC_PAD_CTL0_RPU_DATA1 |
796                    XUSB_PADCTL_HSIC_PAD_CTL0_RPD_STROBE);
797
798         if (idle)
799                 value |= XUSB_PADCTL_HSIC_PAD_CTL0_RPD_DATA0 |
800                          XUSB_PADCTL_HSIC_PAD_CTL0_RPD_DATA1 |
801                          XUSB_PADCTL_HSIC_PAD_CTL0_RPU_STROBE;
802         else
803                 value &= ~(XUSB_PADCTL_HSIC_PAD_CTL0_RPD_DATA0 |
804                            XUSB_PADCTL_HSIC_PAD_CTL0_RPD_DATA1 |
805                            XUSB_PADCTL_HSIC_PAD_CTL0_RPU_STROBE);
806
807         padctl_writel(padctl, value, XUSB_PADCTL_HSIC_PADX_CTL0(index));
808
809         return 0;
810 }
811
812 static int tegra210_usb3_set_lfps_detect(struct tegra_xusb_padctl *padctl,
813                                          unsigned int index, bool enable)
814 {
815         struct tegra_xusb_port *port;
816         struct tegra_xusb_lane *lane;
817         u32 value, offset;
818
819         port = tegra_xusb_find_port(padctl, "usb3", index);
820         if (!port)
821                 return -ENODEV;
822
823         lane = port->lane;
824
825         if (lane->pad == padctl->pcie)
826                 offset = XUSB_PADCTL_UPHY_MISC_PAD_PX_CTL1(lane->index);
827         else
828                 offset = XUSB_PADCTL_UPHY_MISC_PAD_S0_CTL1;
829
830         value = padctl_readl(padctl, offset);
831
832         value &= ~((XUSB_PADCTL_UPHY_MISC_PAD_CTL1_AUX_RX_IDLE_MODE_MASK <<
833                     XUSB_PADCTL_UPHY_MISC_PAD_CTL1_AUX_RX_IDLE_MODE_SHIFT) |
834                    XUSB_PADCTL_UPHY_MISC_PAD_CTL1_AUX_RX_TERM_EN |
835                    XUSB_PADCTL_UPHY_MISC_PAD_CTL1_AUX_RX_MODE_OVRD);
836
837         if (!enable) {
838                 value |= (XUSB_PADCTL_UPHY_MISC_PAD_CTL1_AUX_RX_IDLE_MODE_VAL <<
839                           XUSB_PADCTL_UPHY_MISC_PAD_CTL1_AUX_RX_IDLE_MODE_SHIFT) |
840                          XUSB_PADCTL_UPHY_MISC_PAD_CTL1_AUX_RX_TERM_EN |
841                          XUSB_PADCTL_UPHY_MISC_PAD_CTL1_AUX_RX_MODE_OVRD;
842         }
843
844         padctl_writel(padctl, value, offset);
845
846         return 0;
847 }
848
849 #define TEGRA210_LANE(_name, _offset, _shift, _mask, _type)             \
850         {                                                               \
851                 .name = _name,                                          \
852                 .offset = _offset,                                      \
853                 .shift = _shift,                                        \
854                 .mask = _mask,                                          \
855                 .num_funcs = ARRAY_SIZE(tegra210_##_type##_functions),  \
856                 .funcs = tegra210_##_type##_functions,                  \
857         }
858
859 static const char *tegra210_usb2_functions[] = {
860         "snps",
861         "xusb",
862         "uart"
863 };
864
865 static const struct tegra_xusb_lane_soc tegra210_usb2_lanes[] = {
866         TEGRA210_LANE("usb2-0", 0x004,  0, 0x3, usb2),
867         TEGRA210_LANE("usb2-1", 0x004,  2, 0x3, usb2),
868         TEGRA210_LANE("usb2-2", 0x004,  4, 0x3, usb2),
869         TEGRA210_LANE("usb2-3", 0x004,  6, 0x3, usb2),
870 };
871
872 static struct tegra_xusb_lane *
873 tegra210_usb2_lane_probe(struct tegra_xusb_pad *pad, struct device_node *np,
874                          unsigned int index)
875 {
876         struct tegra_xusb_usb2_lane *usb2;
877         int err;
878
879         usb2 = kzalloc(sizeof(*usb2), GFP_KERNEL);
880         if (!usb2)
881                 return ERR_PTR(-ENOMEM);
882
883         INIT_LIST_HEAD(&usb2->base.list);
884         usb2->base.soc = &pad->soc->lanes[index];
885         usb2->base.index = index;
886         usb2->base.pad = pad;
887         usb2->base.np = np;
888
889         err = tegra_xusb_lane_parse_dt(&usb2->base, np);
890         if (err < 0) {
891                 kfree(usb2);
892                 return ERR_PTR(err);
893         }
894
895         return &usb2->base;
896 }
897
898 static void tegra210_usb2_lane_remove(struct tegra_xusb_lane *lane)
899 {
900         struct tegra_xusb_usb2_lane *usb2 = to_usb2_lane(lane);
901
902         kfree(usb2);
903 }
904
905 static const struct tegra_xusb_lane_ops tegra210_usb2_lane_ops = {
906         .probe = tegra210_usb2_lane_probe,
907         .remove = tegra210_usb2_lane_remove,
908 };
909
910 static int tegra210_usb2_phy_init(struct phy *phy)
911 {
912         struct tegra_xusb_lane *lane = phy_get_drvdata(phy);
913         struct tegra_xusb_padctl *padctl = lane->pad->padctl;
914         u32 value;
915
916         value = padctl_readl(padctl, XUSB_PADCTL_USB2_PAD_MUX);
917         value &= ~(XUSB_PADCTL_USB2_PAD_MUX_USB2_BIAS_PAD_MASK <<
918                    XUSB_PADCTL_USB2_PAD_MUX_USB2_BIAS_PAD_SHIFT);
919         value |= XUSB_PADCTL_USB2_PAD_MUX_USB2_BIAS_PAD_XUSB <<
920                  XUSB_PADCTL_USB2_PAD_MUX_USB2_BIAS_PAD_SHIFT;
921         padctl_writel(padctl, value, XUSB_PADCTL_USB2_PAD_MUX);
922
923         return tegra210_xusb_padctl_enable(padctl);
924 }
925
926 static int tegra210_usb2_phy_exit(struct phy *phy)
927 {
928         struct tegra_xusb_lane *lane = phy_get_drvdata(phy);
929
930         return tegra210_xusb_padctl_disable(lane->pad->padctl);
931 }
932
933 static int tegra210_usb2_phy_power_on(struct phy *phy)
934 {
935         struct tegra_xusb_lane *lane = phy_get_drvdata(phy);
936         struct tegra_xusb_usb2_lane *usb2 = to_usb2_lane(lane);
937         struct tegra_xusb_usb2_pad *pad = to_usb2_pad(lane->pad);
938         struct tegra_xusb_padctl *padctl = lane->pad->padctl;
939         struct tegra210_xusb_padctl *priv;
940         struct tegra_xusb_usb2_port *port;
941         unsigned int index = lane->index;
942         u32 value;
943         int err;
944
945         port = tegra_xusb_find_usb2_port(padctl, index);
946         if (!port) {
947                 dev_err(&phy->dev, "no port found for USB2 lane %u\n", index);
948                 return -ENODEV;
949         }
950
951         priv = to_tegra210_xusb_padctl(padctl);
952
953         value = padctl_readl(padctl, XUSB_PADCTL_USB2_BIAS_PAD_CTL0);
954         value &= ~((XUSB_PADCTL_USB2_BIAS_PAD_CTL0_HS_SQUELCH_LEVEL_MASK <<
955                     XUSB_PADCTL_USB2_BIAS_PAD_CTL0_HS_SQUELCH_LEVEL_SHIFT) |
956                    (XUSB_PADCTL_USB2_BIAS_PAD_CTL0_HS_DISCON_LEVEL_MASK <<
957                     XUSB_PADCTL_USB2_BIAS_PAD_CTL0_HS_DISCON_LEVEL_SHIFT));
958         value |= (XUSB_PADCTL_USB2_BIAS_PAD_CTL0_HS_DISCON_LEVEL_VAL <<
959                   XUSB_PADCTL_USB2_BIAS_PAD_CTL0_HS_DISCON_LEVEL_SHIFT);
960
961         if (tegra_sku_info.revision < TEGRA_REVISION_A02)
962                 value |=
963                         (XUSB_PADCTL_USB2_BIAS_PAD_CTL0_HS_SQUELCH_LEVEL_VAL <<
964                         XUSB_PADCTL_USB2_BIAS_PAD_CTL0_HS_SQUELCH_LEVEL_SHIFT);
965
966         padctl_writel(padctl, value, XUSB_PADCTL_USB2_BIAS_PAD_CTL0);
967
968         value = padctl_readl(padctl, XUSB_PADCTL_USB2_PORT_CAP);
969         value &= ~XUSB_PADCTL_USB2_PORT_CAP_PORTX_CAP_MASK(index);
970         value |= XUSB_PADCTL_USB2_PORT_CAP_PORTX_CAP_HOST(index);
971         padctl_writel(padctl, value, XUSB_PADCTL_USB2_PORT_CAP);
972
973         value = padctl_readl(padctl, XUSB_PADCTL_USB2_OTG_PADX_CTL0(index));
974         value &= ~((XUSB_PADCTL_USB2_OTG_PAD_CTL0_HS_CURR_LEVEL_MASK <<
975                     XUSB_PADCTL_USB2_OTG_PAD_CTL0_HS_CURR_LEVEL_SHIFT) |
976                    XUSB_PADCTL_USB2_OTG_PAD_CTL0_PD |
977                    XUSB_PADCTL_USB2_OTG_PAD_CTL0_PD2 |
978                    XUSB_PADCTL_USB2_OTG_PAD_CTL0_PD_ZI);
979         value |= (priv->fuse.hs_curr_level[index] +
980                   usb2->hs_curr_level_offset) <<
981                  XUSB_PADCTL_USB2_OTG_PAD_CTL0_HS_CURR_LEVEL_SHIFT;
982         padctl_writel(padctl, value, XUSB_PADCTL_USB2_OTG_PADX_CTL0(index));
983
984         value = padctl_readl(padctl, XUSB_PADCTL_USB2_OTG_PADX_CTL1(index));
985         value &= ~((XUSB_PADCTL_USB2_OTG_PAD_CTL1_TERM_RANGE_ADJ_MASK <<
986                     XUSB_PADCTL_USB2_OTG_PAD_CTL1_TERM_RANGE_ADJ_SHIFT) |
987                    (XUSB_PADCTL_USB2_OTG_PAD_CTL1_RPD_CTRL_MASK <<
988                     XUSB_PADCTL_USB2_OTG_PAD_CTL1_RPD_CTRL_SHIFT) |
989                    XUSB_PADCTL_USB2_OTG_PAD_CTL1_PD_DR |
990                    XUSB_PADCTL_USB2_OTG_PAD_CTL1_PD_CHRP_OVRD |
991                    XUSB_PADCTL_USB2_OTG_PAD_CTL1_PD_DISC_OVRD);
992         value |= (priv->fuse.hs_term_range_adj <<
993                   XUSB_PADCTL_USB2_OTG_PAD_CTL1_TERM_RANGE_ADJ_SHIFT) |
994                  (priv->fuse.rpd_ctrl <<
995                   XUSB_PADCTL_USB2_OTG_PAD_CTL1_RPD_CTRL_SHIFT);
996         padctl_writel(padctl, value, XUSB_PADCTL_USB2_OTG_PADX_CTL1(index));
997
998         value = padctl_readl(padctl,
999                              XUSB_PADCTL_USB2_BATTERY_CHRG_OTGPADX_CTL1(index));
1000         value &= ~(XUSB_PADCTL_USB2_BATTERY_CHRG_OTGPAD_CTL1_VREG_LEV_MASK <<
1001                    XUSB_PADCTL_USB2_BATTERY_CHRG_OTGPAD_CTL1_VREG_LEV_SHIFT);
1002         value |= XUSB_PADCTL_USB2_BATTERY_CHRG_OTGPAD_CTL1_VREG_FIX18;
1003         padctl_writel(padctl, value,
1004                       XUSB_PADCTL_USB2_BATTERY_CHRG_OTGPADX_CTL1(index));
1005
1006         err = regulator_enable(port->supply);
1007         if (err)
1008                 return err;
1009
1010         mutex_lock(&padctl->lock);
1011
1012         if (pad->enable > 0) {
1013                 pad->enable++;
1014                 mutex_unlock(&padctl->lock);
1015                 return 0;
1016         }
1017
1018         err = clk_prepare_enable(pad->clk);
1019         if (err)
1020                 goto disable_regulator;
1021
1022         value = padctl_readl(padctl, XUSB_PADCTL_USB2_BIAS_PAD_CTL1);
1023         value &= ~((XUSB_PADCTL_USB2_BIAS_PAD_CTL1_TRK_START_TIMER_MASK <<
1024                     XUSB_PADCTL_USB2_BIAS_PAD_CTL1_TRK_START_TIMER_SHIFT) |
1025                    (XUSB_PADCTL_USB2_BIAS_PAD_CTL1_TRK_DONE_RESET_TIMER_MASK <<
1026                     XUSB_PADCTL_USB2_BIAS_PAD_CTL1_TRK_DONE_RESET_TIMER_SHIFT));
1027         value |= (XUSB_PADCTL_USB2_BIAS_PAD_CTL1_TRK_START_TIMER_VAL <<
1028                   XUSB_PADCTL_USB2_BIAS_PAD_CTL1_TRK_START_TIMER_SHIFT) |
1029                  (XUSB_PADCTL_USB2_BIAS_PAD_CTL1_TRK_DONE_RESET_TIMER_VAL <<
1030                   XUSB_PADCTL_USB2_BIAS_PAD_CTL1_TRK_DONE_RESET_TIMER_SHIFT);
1031         padctl_writel(padctl, value, XUSB_PADCTL_USB2_BIAS_PAD_CTL1);
1032
1033         value = padctl_readl(padctl, XUSB_PADCTL_USB2_BIAS_PAD_CTL0);
1034         value &= ~XUSB_PADCTL_USB2_BIAS_PAD_CTL0_PD;
1035         padctl_writel(padctl, value, XUSB_PADCTL_USB2_BIAS_PAD_CTL0);
1036
1037         udelay(1);
1038
1039         value = padctl_readl(padctl, XUSB_PADCTL_USB2_BIAS_PAD_CTL1);
1040         value &= ~XUSB_PADCTL_USB2_BIAS_PAD_CTL1_PD_TRK;
1041         padctl_writel(padctl, value, XUSB_PADCTL_USB2_BIAS_PAD_CTL1);
1042
1043         udelay(50);
1044
1045         clk_disable_unprepare(pad->clk);
1046
1047         pad->enable++;
1048         mutex_unlock(&padctl->lock);
1049
1050         return 0;
1051
1052 disable_regulator:
1053         regulator_disable(port->supply);
1054         mutex_unlock(&padctl->lock);
1055         return err;
1056 }
1057
1058 static int tegra210_usb2_phy_power_off(struct phy *phy)
1059 {
1060         struct tegra_xusb_lane *lane = phy_get_drvdata(phy);
1061         struct tegra_xusb_usb2_pad *pad = to_usb2_pad(lane->pad);
1062         struct tegra_xusb_padctl *padctl = lane->pad->padctl;
1063         struct tegra_xusb_usb2_port *port;
1064         u32 value;
1065
1066         port = tegra_xusb_find_usb2_port(padctl, lane->index);
1067         if (!port) {
1068                 dev_err(&phy->dev, "no port found for USB2 lane %u\n",
1069                         lane->index);
1070                 return -ENODEV;
1071         }
1072
1073         mutex_lock(&padctl->lock);
1074
1075         if (WARN_ON(pad->enable == 0))
1076                 goto out;
1077
1078         if (--pad->enable > 0)
1079                 goto out;
1080
1081         value = padctl_readl(padctl, XUSB_PADCTL_USB2_BIAS_PAD_CTL0);
1082         value |= XUSB_PADCTL_USB2_BIAS_PAD_CTL0_PD;
1083         padctl_writel(padctl, value, XUSB_PADCTL_USB2_BIAS_PAD_CTL0);
1084
1085 out:
1086         regulator_disable(port->supply);
1087         mutex_unlock(&padctl->lock);
1088         return 0;
1089 }
1090
1091 static const struct phy_ops tegra210_usb2_phy_ops = {
1092         .init = tegra210_usb2_phy_init,
1093         .exit = tegra210_usb2_phy_exit,
1094         .power_on = tegra210_usb2_phy_power_on,
1095         .power_off = tegra210_usb2_phy_power_off,
1096         .owner = THIS_MODULE,
1097 };
1098
1099 static struct tegra_xusb_pad *
1100 tegra210_usb2_pad_probe(struct tegra_xusb_padctl *padctl,
1101                         const struct tegra_xusb_pad_soc *soc,
1102                         struct device_node *np)
1103 {
1104         struct tegra_xusb_usb2_pad *usb2;
1105         struct tegra_xusb_pad *pad;
1106         int err;
1107
1108         usb2 = kzalloc(sizeof(*usb2), GFP_KERNEL);
1109         if (!usb2)
1110                 return ERR_PTR(-ENOMEM);
1111
1112         pad = &usb2->base;
1113         pad->ops = &tegra210_usb2_lane_ops;
1114         pad->soc = soc;
1115
1116         err = tegra_xusb_pad_init(pad, padctl, np);
1117         if (err < 0) {
1118                 kfree(usb2);
1119                 goto out;
1120         }
1121
1122         usb2->clk = devm_clk_get(&pad->dev, "trk");
1123         if (IS_ERR(usb2->clk)) {
1124                 err = PTR_ERR(usb2->clk);
1125                 dev_err(&pad->dev, "failed to get trk clock: %d\n", err);
1126                 goto unregister;
1127         }
1128
1129         err = tegra_xusb_pad_register(pad, &tegra210_usb2_phy_ops);
1130         if (err < 0)
1131                 goto unregister;
1132
1133         dev_set_drvdata(&pad->dev, pad);
1134
1135         return pad;
1136
1137 unregister:
1138         device_unregister(&pad->dev);
1139 out:
1140         return ERR_PTR(err);
1141 }
1142
1143 static void tegra210_usb2_pad_remove(struct tegra_xusb_pad *pad)
1144 {
1145         struct tegra_xusb_usb2_pad *usb2 = to_usb2_pad(pad);
1146
1147         kfree(usb2);
1148 }
1149
1150 static const struct tegra_xusb_pad_ops tegra210_usb2_ops = {
1151         .probe = tegra210_usb2_pad_probe,
1152         .remove = tegra210_usb2_pad_remove,
1153 };
1154
1155 static const struct tegra_xusb_pad_soc tegra210_usb2_pad = {
1156         .name = "usb2",
1157         .num_lanes = ARRAY_SIZE(tegra210_usb2_lanes),
1158         .lanes = tegra210_usb2_lanes,
1159         .ops = &tegra210_usb2_ops,
1160 };
1161
1162 static const char *tegra210_hsic_functions[] = {
1163         "snps",
1164         "xusb",
1165 };
1166
1167 static const struct tegra_xusb_lane_soc tegra210_hsic_lanes[] = {
1168         TEGRA210_LANE("hsic-0", 0x004, 14, 0x1, hsic),
1169 };
1170
1171 static struct tegra_xusb_lane *
1172 tegra210_hsic_lane_probe(struct tegra_xusb_pad *pad, struct device_node *np,
1173                          unsigned int index)
1174 {
1175         struct tegra_xusb_hsic_lane *hsic;
1176         int err;
1177
1178         hsic = kzalloc(sizeof(*hsic), GFP_KERNEL);
1179         if (!hsic)
1180                 return ERR_PTR(-ENOMEM);
1181
1182         INIT_LIST_HEAD(&hsic->base.list);
1183         hsic->base.soc = &pad->soc->lanes[index];
1184         hsic->base.index = index;
1185         hsic->base.pad = pad;
1186         hsic->base.np = np;
1187
1188         err = tegra_xusb_lane_parse_dt(&hsic->base, np);
1189         if (err < 0) {
1190                 kfree(hsic);
1191                 return ERR_PTR(err);
1192         }
1193
1194         return &hsic->base;
1195 }
1196
1197 static void tegra210_hsic_lane_remove(struct tegra_xusb_lane *lane)
1198 {
1199         struct tegra_xusb_hsic_lane *hsic = to_hsic_lane(lane);
1200
1201         kfree(hsic);
1202 }
1203
1204 static const struct tegra_xusb_lane_ops tegra210_hsic_lane_ops = {
1205         .probe = tegra210_hsic_lane_probe,
1206         .remove = tegra210_hsic_lane_remove,
1207 };
1208
1209 static int tegra210_hsic_phy_init(struct phy *phy)
1210 {
1211         struct tegra_xusb_lane *lane = phy_get_drvdata(phy);
1212         struct tegra_xusb_padctl *padctl = lane->pad->padctl;
1213         u32 value;
1214
1215         value = padctl_readl(padctl, XUSB_PADCTL_USB2_PAD_MUX);
1216         value &= ~(XUSB_PADCTL_USB2_PAD_MUX_HSIC_PAD_TRK_MASK <<
1217                    XUSB_PADCTL_USB2_PAD_MUX_HSIC_PAD_TRK_SHIFT);
1218         value |= XUSB_PADCTL_USB2_PAD_MUX_HSIC_PAD_TRK_XUSB <<
1219                  XUSB_PADCTL_USB2_PAD_MUX_HSIC_PAD_TRK_SHIFT;
1220         padctl_writel(padctl, value, XUSB_PADCTL_USB2_PAD_MUX);
1221
1222         return tegra210_xusb_padctl_enable(padctl);
1223 }
1224
1225 static int tegra210_hsic_phy_exit(struct phy *phy)
1226 {
1227         struct tegra_xusb_lane *lane = phy_get_drvdata(phy);
1228
1229         return tegra210_xusb_padctl_disable(lane->pad->padctl);
1230 }
1231
1232 static int tegra210_hsic_phy_power_on(struct phy *phy)
1233 {
1234         struct tegra_xusb_lane *lane = phy_get_drvdata(phy);
1235         struct tegra_xusb_hsic_lane *hsic = to_hsic_lane(lane);
1236         struct tegra_xusb_hsic_pad *pad = to_hsic_pad(lane->pad);
1237         struct tegra_xusb_padctl *padctl = lane->pad->padctl;
1238         struct tegra210_xusb_padctl *priv;
1239         unsigned int index = lane->index;
1240         u32 value;
1241         int err;
1242
1243         priv = to_tegra210_xusb_padctl(padctl);
1244
1245         err = regulator_enable(pad->supply);
1246         if (err)
1247                 return err;
1248
1249         padctl_writel(padctl, hsic->strobe_trim,
1250                       XUSB_PADCTL_HSIC_STRB_TRIM_CONTROL);
1251
1252         value = padctl_readl(padctl, XUSB_PADCTL_HSIC_PADX_CTL1(index));
1253         value &= ~(XUSB_PADCTL_HSIC_PAD_CTL1_TX_RTUNEP_MASK <<
1254                    XUSB_PADCTL_HSIC_PAD_CTL1_TX_RTUNEP_SHIFT);
1255         value |= (hsic->tx_rtune_p <<
1256                   XUSB_PADCTL_HSIC_PAD_CTL1_TX_RTUNEP_SHIFT);
1257         padctl_writel(padctl, value, XUSB_PADCTL_HSIC_PADX_CTL1(index));
1258
1259         value = padctl_readl(padctl, XUSB_PADCTL_HSIC_PADX_CTL2(index));
1260         value &= ~((XUSB_PADCTL_HSIC_PAD_CTL2_RX_STROBE_TRIM_MASK <<
1261                     XUSB_PADCTL_HSIC_PAD_CTL2_RX_STROBE_TRIM_SHIFT) |
1262                    (XUSB_PADCTL_HSIC_PAD_CTL2_RX_DATA_TRIM_MASK <<
1263                     XUSB_PADCTL_HSIC_PAD_CTL2_RX_DATA_TRIM_SHIFT));
1264         value |= (hsic->rx_strobe_trim <<
1265                   XUSB_PADCTL_HSIC_PAD_CTL2_RX_STROBE_TRIM_SHIFT) |
1266                  (hsic->rx_data_trim <<
1267                   XUSB_PADCTL_HSIC_PAD_CTL2_RX_DATA_TRIM_SHIFT);
1268         padctl_writel(padctl, value, XUSB_PADCTL_HSIC_PADX_CTL2(index));
1269
1270         value = padctl_readl(padctl, XUSB_PADCTL_HSIC_PADX_CTL0(index));
1271         value &= ~(XUSB_PADCTL_HSIC_PAD_CTL0_RPU_DATA0 |
1272                    XUSB_PADCTL_HSIC_PAD_CTL0_RPU_DATA1 |
1273                    XUSB_PADCTL_HSIC_PAD_CTL0_RPU_STROBE |
1274                    XUSB_PADCTL_HSIC_PAD_CTL0_PD_RX_DATA0 |
1275                    XUSB_PADCTL_HSIC_PAD_CTL0_PD_RX_DATA1 |
1276                    XUSB_PADCTL_HSIC_PAD_CTL0_PD_RX_STROBE |
1277                    XUSB_PADCTL_HSIC_PAD_CTL0_PD_ZI_DATA0 |
1278                    XUSB_PADCTL_HSIC_PAD_CTL0_PD_ZI_DATA1 |
1279                    XUSB_PADCTL_HSIC_PAD_CTL0_PD_ZI_STROBE |
1280                    XUSB_PADCTL_HSIC_PAD_CTL0_PD_TX_DATA0 |
1281                    XUSB_PADCTL_HSIC_PAD_CTL0_PD_TX_DATA1 |
1282                    XUSB_PADCTL_HSIC_PAD_CTL0_PD_TX_STROBE);
1283         value |= XUSB_PADCTL_HSIC_PAD_CTL0_RPD_DATA0 |
1284                  XUSB_PADCTL_HSIC_PAD_CTL0_RPD_DATA1 |
1285                  XUSB_PADCTL_HSIC_PAD_CTL0_RPD_STROBE;
1286         padctl_writel(padctl, value, XUSB_PADCTL_HSIC_PADX_CTL0(index));
1287
1288         err = clk_prepare_enable(pad->clk);
1289         if (err)
1290                 goto disable;
1291
1292         value = padctl_readl(padctl, XUSB_PADCTL_HSIC_PAD_TRK_CTL);
1293         value &= ~((XUSB_PADCTL_HSIC_PAD_TRK_CTL_TRK_START_TIMER_MASK <<
1294                     XUSB_PADCTL_HSIC_PAD_TRK_CTL_TRK_START_TIMER_SHIFT) |
1295                    (XUSB_PADCTL_HSIC_PAD_TRK_CTL_TRK_DONE_RESET_TIMER_MASK <<
1296                     XUSB_PADCTL_HSIC_PAD_TRK_CTL_TRK_DONE_RESET_TIMER_SHIFT));
1297         value |= (XUSB_PADCTL_HSIC_PAD_TRK_CTL_TRK_START_TIMER_VAL <<
1298                   XUSB_PADCTL_HSIC_PAD_TRK_CTL_TRK_START_TIMER_SHIFT) |
1299                  (XUSB_PADCTL_HSIC_PAD_TRK_CTL_TRK_DONE_RESET_TIMER_VAL <<
1300                   XUSB_PADCTL_HSIC_PAD_TRK_CTL_TRK_DONE_RESET_TIMER_SHIFT);
1301         padctl_writel(padctl, value, XUSB_PADCTL_HSIC_PAD_TRK_CTL);
1302
1303         udelay(1);
1304
1305         value = padctl_readl(padctl, XUSB_PADCTL_HSIC_PAD_TRK_CTL);
1306         value &= ~XUSB_PADCTL_HSIC_PAD_TRK_CTL_PD_TRK;
1307         padctl_writel(padctl, value, XUSB_PADCTL_HSIC_PAD_TRK_CTL);
1308
1309         udelay(50);
1310
1311         clk_disable_unprepare(pad->clk);
1312
1313         return 0;
1314
1315 disable:
1316         regulator_disable(pad->supply);
1317         return err;
1318 }
1319
1320 static int tegra210_hsic_phy_power_off(struct phy *phy)
1321 {
1322         struct tegra_xusb_lane *lane = phy_get_drvdata(phy);
1323         struct tegra_xusb_hsic_pad *pad = to_hsic_pad(lane->pad);
1324         struct tegra_xusb_padctl *padctl = lane->pad->padctl;
1325         unsigned int index = lane->index;
1326         u32 value;
1327
1328         value = padctl_readl(padctl, XUSB_PADCTL_HSIC_PADX_CTL0(index));
1329         value |= XUSB_PADCTL_HSIC_PAD_CTL0_PD_RX_DATA0 |
1330                  XUSB_PADCTL_HSIC_PAD_CTL0_PD_RX_DATA1 |
1331                  XUSB_PADCTL_HSIC_PAD_CTL0_PD_RX_STROBE |
1332                  XUSB_PADCTL_HSIC_PAD_CTL0_PD_ZI_DATA0 |
1333                  XUSB_PADCTL_HSIC_PAD_CTL0_PD_ZI_DATA1 |
1334                  XUSB_PADCTL_HSIC_PAD_CTL0_PD_ZI_STROBE |
1335                  XUSB_PADCTL_HSIC_PAD_CTL0_PD_TX_DATA0 |
1336                  XUSB_PADCTL_HSIC_PAD_CTL0_PD_TX_DATA1 |
1337                  XUSB_PADCTL_HSIC_PAD_CTL0_PD_TX_STROBE;
1338         padctl_writel(padctl, value, XUSB_PADCTL_HSIC_PADX_CTL1(index));
1339
1340         regulator_disable(pad->supply);
1341
1342         return 0;
1343 }
1344
1345 static const struct phy_ops tegra210_hsic_phy_ops = {
1346         .init = tegra210_hsic_phy_init,
1347         .exit = tegra210_hsic_phy_exit,
1348         .power_on = tegra210_hsic_phy_power_on,
1349         .power_off = tegra210_hsic_phy_power_off,
1350         .owner = THIS_MODULE,
1351 };
1352
1353 static struct tegra_xusb_pad *
1354 tegra210_hsic_pad_probe(struct tegra_xusb_padctl *padctl,
1355                         const struct tegra_xusb_pad_soc *soc,
1356                         struct device_node *np)
1357 {
1358         struct tegra_xusb_hsic_pad *hsic;
1359         struct tegra_xusb_pad *pad;
1360         int err;
1361
1362         hsic = kzalloc(sizeof(*hsic), GFP_KERNEL);
1363         if (!hsic)
1364                 return ERR_PTR(-ENOMEM);
1365
1366         pad = &hsic->base;
1367         pad->ops = &tegra210_hsic_lane_ops;
1368         pad->soc = soc;
1369
1370         err = tegra_xusb_pad_init(pad, padctl, np);
1371         if (err < 0) {
1372                 kfree(hsic);
1373                 goto out;
1374         }
1375
1376         hsic->clk = devm_clk_get(&pad->dev, "trk");
1377         if (IS_ERR(hsic->clk)) {
1378                 err = PTR_ERR(hsic->clk);
1379                 dev_err(&pad->dev, "failed to get trk clock: %d\n", err);
1380                 goto unregister;
1381         }
1382
1383         err = tegra_xusb_pad_register(pad, &tegra210_hsic_phy_ops);
1384         if (err < 0)
1385                 goto unregister;
1386
1387         dev_set_drvdata(&pad->dev, pad);
1388
1389         return pad;
1390
1391 unregister:
1392         device_unregister(&pad->dev);
1393 out:
1394         return ERR_PTR(err);
1395 }
1396
1397 static void tegra210_hsic_pad_remove(struct tegra_xusb_pad *pad)
1398 {
1399         struct tegra_xusb_hsic_pad *hsic = to_hsic_pad(pad);
1400
1401         kfree(hsic);
1402 }
1403
1404 static const struct tegra_xusb_pad_ops tegra210_hsic_ops = {
1405         .probe = tegra210_hsic_pad_probe,
1406         .remove = tegra210_hsic_pad_remove,
1407 };
1408
1409 static const struct tegra_xusb_pad_soc tegra210_hsic_pad = {
1410         .name = "hsic",
1411         .num_lanes = ARRAY_SIZE(tegra210_hsic_lanes),
1412         .lanes = tegra210_hsic_lanes,
1413         .ops = &tegra210_hsic_ops,
1414 };
1415
1416 static const char *tegra210_pcie_functions[] = {
1417         "pcie-x1",
1418         "usb3-ss",
1419         "sata",
1420         "pcie-x4",
1421 };
1422
1423 static const struct tegra_xusb_lane_soc tegra210_pcie_lanes[] = {
1424         TEGRA210_LANE("pcie-0", 0x028, 12, 0x3, pcie),
1425         TEGRA210_LANE("pcie-1", 0x028, 14, 0x3, pcie),
1426         TEGRA210_LANE("pcie-2", 0x028, 16, 0x3, pcie),
1427         TEGRA210_LANE("pcie-3", 0x028, 18, 0x3, pcie),
1428         TEGRA210_LANE("pcie-4", 0x028, 20, 0x3, pcie),
1429         TEGRA210_LANE("pcie-5", 0x028, 22, 0x3, pcie),
1430         TEGRA210_LANE("pcie-6", 0x028, 24, 0x3, pcie),
1431 };
1432
1433 static struct tegra_xusb_lane *
1434 tegra210_pcie_lane_probe(struct tegra_xusb_pad *pad, struct device_node *np,
1435                          unsigned int index)
1436 {
1437         struct tegra_xusb_pcie_lane *pcie;
1438         int err;
1439
1440         pcie = kzalloc(sizeof(*pcie), GFP_KERNEL);
1441         if (!pcie)
1442                 return ERR_PTR(-ENOMEM);
1443
1444         INIT_LIST_HEAD(&pcie->base.list);
1445         pcie->base.soc = &pad->soc->lanes[index];
1446         pcie->base.index = index;
1447         pcie->base.pad = pad;
1448         pcie->base.np = np;
1449
1450         err = tegra_xusb_lane_parse_dt(&pcie->base, np);
1451         if (err < 0) {
1452                 kfree(pcie);
1453                 return ERR_PTR(err);
1454         }
1455
1456         return &pcie->base;
1457 }
1458
1459 static void tegra210_pcie_lane_remove(struct tegra_xusb_lane *lane)
1460 {
1461         struct tegra_xusb_pcie_lane *pcie = to_pcie_lane(lane);
1462
1463         kfree(pcie);
1464 }
1465
1466 static const struct tegra_xusb_lane_ops tegra210_pcie_lane_ops = {
1467         .probe = tegra210_pcie_lane_probe,
1468         .remove = tegra210_pcie_lane_remove,
1469 };
1470
1471 static int tegra210_pcie_phy_init(struct phy *phy)
1472 {
1473         struct tegra_xusb_lane *lane = phy_get_drvdata(phy);
1474
1475         return tegra210_xusb_padctl_enable(lane->pad->padctl);
1476 }
1477
1478 static int tegra210_pcie_phy_exit(struct phy *phy)
1479 {
1480         struct tegra_xusb_lane *lane = phy_get_drvdata(phy);
1481
1482         return tegra210_xusb_padctl_disable(lane->pad->padctl);
1483 }
1484
1485 static int tegra210_pcie_phy_power_on(struct phy *phy)
1486 {
1487         struct tegra_xusb_lane *lane = phy_get_drvdata(phy);
1488         struct tegra_xusb_padctl *padctl = lane->pad->padctl;
1489         u32 value;
1490         int err;
1491
1492         mutex_lock(&padctl->lock);
1493
1494         err = tegra210_pex_uphy_enable(padctl);
1495         if (err < 0)
1496                 goto unlock;
1497
1498         value = padctl_readl(padctl, XUSB_PADCTL_USB3_PAD_MUX);
1499         value |= XUSB_PADCTL_USB3_PAD_MUX_PCIE_IDDQ_DISABLE(lane->index);
1500         padctl_writel(padctl, value, XUSB_PADCTL_USB3_PAD_MUX);
1501
1502 unlock:
1503         mutex_unlock(&padctl->lock);
1504         return err;
1505 }
1506
1507 static int tegra210_pcie_phy_power_off(struct phy *phy)
1508 {
1509         struct tegra_xusb_lane *lane = phy_get_drvdata(phy);
1510         struct tegra_xusb_padctl *padctl = lane->pad->padctl;
1511         u32 value;
1512
1513         value = padctl_readl(padctl, XUSB_PADCTL_USB3_PAD_MUX);
1514         value &= ~XUSB_PADCTL_USB3_PAD_MUX_PCIE_IDDQ_DISABLE(lane->index);
1515         padctl_writel(padctl, value, XUSB_PADCTL_USB3_PAD_MUX);
1516
1517         tegra210_pex_uphy_disable(padctl);
1518
1519         return 0;
1520 }
1521
1522 static const struct phy_ops tegra210_pcie_phy_ops = {
1523         .init = tegra210_pcie_phy_init,
1524         .exit = tegra210_pcie_phy_exit,
1525         .power_on = tegra210_pcie_phy_power_on,
1526         .power_off = tegra210_pcie_phy_power_off,
1527         .owner = THIS_MODULE,
1528 };
1529
1530 static struct tegra_xusb_pad *
1531 tegra210_pcie_pad_probe(struct tegra_xusb_padctl *padctl,
1532                         const struct tegra_xusb_pad_soc *soc,
1533                         struct device_node *np)
1534 {
1535         struct tegra_xusb_pcie_pad *pcie;
1536         struct tegra_xusb_pad *pad;
1537         int err;
1538
1539         pcie = kzalloc(sizeof(*pcie), GFP_KERNEL);
1540         if (!pcie)
1541                 return ERR_PTR(-ENOMEM);
1542
1543         pad = &pcie->base;
1544         pad->ops = &tegra210_pcie_lane_ops;
1545         pad->soc = soc;
1546
1547         err = tegra_xusb_pad_init(pad, padctl, np);
1548         if (err < 0) {
1549                 kfree(pcie);
1550                 goto out;
1551         }
1552
1553         pcie->pll = devm_clk_get(&pad->dev, "pll");
1554         if (IS_ERR(pcie->pll)) {
1555                 err = PTR_ERR(pcie->pll);
1556                 dev_err(&pad->dev, "failed to get PLL: %d\n", err);
1557                 goto unregister;
1558         }
1559
1560         pcie->rst = devm_reset_control_get(&pad->dev, "phy");
1561         if (IS_ERR(pcie->rst)) {
1562                 err = PTR_ERR(pcie->rst);
1563                 dev_err(&pad->dev, "failed to get PCIe pad reset: %d\n", err);
1564                 goto unregister;
1565         }
1566
1567         err = tegra_xusb_pad_register(pad, &tegra210_pcie_phy_ops);
1568         if (err < 0)
1569                 goto unregister;
1570
1571         dev_set_drvdata(&pad->dev, pad);
1572
1573         return pad;
1574
1575 unregister:
1576         device_unregister(&pad->dev);
1577 out:
1578         return ERR_PTR(err);
1579 }
1580
1581 static void tegra210_pcie_pad_remove(struct tegra_xusb_pad *pad)
1582 {
1583         struct tegra_xusb_pcie_pad *pcie = to_pcie_pad(pad);
1584
1585         kfree(pcie);
1586 }
1587
1588 static const struct tegra_xusb_pad_ops tegra210_pcie_ops = {
1589         .probe = tegra210_pcie_pad_probe,
1590         .remove = tegra210_pcie_pad_remove,
1591 };
1592
1593 static const struct tegra_xusb_pad_soc tegra210_pcie_pad = {
1594         .name = "pcie",
1595         .num_lanes = ARRAY_SIZE(tegra210_pcie_lanes),
1596         .lanes = tegra210_pcie_lanes,
1597         .ops = &tegra210_pcie_ops,
1598 };
1599
1600 static const struct tegra_xusb_lane_soc tegra210_sata_lanes[] = {
1601         TEGRA210_LANE("sata-0", 0x028, 30, 0x3, pcie),
1602 };
1603
1604 static struct tegra_xusb_lane *
1605 tegra210_sata_lane_probe(struct tegra_xusb_pad *pad, struct device_node *np,
1606                          unsigned int index)
1607 {
1608         struct tegra_xusb_sata_lane *sata;
1609         int err;
1610
1611         sata = kzalloc(sizeof(*sata), GFP_KERNEL);
1612         if (!sata)
1613                 return ERR_PTR(-ENOMEM);
1614
1615         INIT_LIST_HEAD(&sata->base.list);
1616         sata->base.soc = &pad->soc->lanes[index];
1617         sata->base.index = index;
1618         sata->base.pad = pad;
1619         sata->base.np = np;
1620
1621         err = tegra_xusb_lane_parse_dt(&sata->base, np);
1622         if (err < 0) {
1623                 kfree(sata);
1624                 return ERR_PTR(err);
1625         }
1626
1627         return &sata->base;
1628 }
1629
1630 static void tegra210_sata_lane_remove(struct tegra_xusb_lane *lane)
1631 {
1632         struct tegra_xusb_sata_lane *sata = to_sata_lane(lane);
1633
1634         kfree(sata);
1635 }
1636
1637 static const struct tegra_xusb_lane_ops tegra210_sata_lane_ops = {
1638         .probe = tegra210_sata_lane_probe,
1639         .remove = tegra210_sata_lane_remove,
1640 };
1641
1642 static int tegra210_sata_phy_init(struct phy *phy)
1643 {
1644         struct tegra_xusb_lane *lane = phy_get_drvdata(phy);
1645
1646         return tegra210_xusb_padctl_enable(lane->pad->padctl);
1647 }
1648
1649 static int tegra210_sata_phy_exit(struct phy *phy)
1650 {
1651         struct tegra_xusb_lane *lane = phy_get_drvdata(phy);
1652
1653         return tegra210_xusb_padctl_disable(lane->pad->padctl);
1654 }
1655
1656 static int tegra210_sata_phy_power_on(struct phy *phy)
1657 {
1658         struct tegra_xusb_lane *lane = phy_get_drvdata(phy);
1659         struct tegra_xusb_padctl *padctl = lane->pad->padctl;
1660         u32 value;
1661         int err;
1662
1663         mutex_lock(&padctl->lock);
1664
1665         err = tegra210_sata_uphy_enable(padctl, false);
1666         if (err < 0)
1667                 goto unlock;
1668
1669         value = padctl_readl(padctl, XUSB_PADCTL_USB3_PAD_MUX);
1670         value |= XUSB_PADCTL_USB3_PAD_MUX_SATA_IDDQ_DISABLE(lane->index);
1671         padctl_writel(padctl, value, XUSB_PADCTL_USB3_PAD_MUX);
1672
1673 unlock:
1674         mutex_unlock(&padctl->lock);
1675         return err;
1676 }
1677
1678 static int tegra210_sata_phy_power_off(struct phy *phy)
1679 {
1680         struct tegra_xusb_lane *lane = phy_get_drvdata(phy);
1681         struct tegra_xusb_padctl *padctl = lane->pad->padctl;
1682         u32 value;
1683
1684         value = padctl_readl(padctl, XUSB_PADCTL_USB3_PAD_MUX);
1685         value &= ~XUSB_PADCTL_USB3_PAD_MUX_SATA_IDDQ_DISABLE(lane->index);
1686         padctl_writel(padctl, value, XUSB_PADCTL_USB3_PAD_MUX);
1687
1688         tegra210_sata_uphy_disable(lane->pad->padctl);
1689
1690         return 0;
1691 }
1692
1693 static const struct phy_ops tegra210_sata_phy_ops = {
1694         .init = tegra210_sata_phy_init,
1695         .exit = tegra210_sata_phy_exit,
1696         .power_on = tegra210_sata_phy_power_on,
1697         .power_off = tegra210_sata_phy_power_off,
1698         .owner = THIS_MODULE,
1699 };
1700
1701 static struct tegra_xusb_pad *
1702 tegra210_sata_pad_probe(struct tegra_xusb_padctl *padctl,
1703                         const struct tegra_xusb_pad_soc *soc,
1704                         struct device_node *np)
1705 {
1706         struct tegra_xusb_sata_pad *sata;
1707         struct tegra_xusb_pad *pad;
1708         int err;
1709
1710         sata = kzalloc(sizeof(*sata), GFP_KERNEL);
1711         if (!sata)
1712                 return ERR_PTR(-ENOMEM);
1713
1714         pad = &sata->base;
1715         pad->ops = &tegra210_sata_lane_ops;
1716         pad->soc = soc;
1717
1718         err = tegra_xusb_pad_init(pad, padctl, np);
1719         if (err < 0) {
1720                 kfree(sata);
1721                 goto out;
1722         }
1723
1724         sata->rst = devm_reset_control_get(&pad->dev, "phy");
1725         if (IS_ERR(sata->rst)) {
1726                 err = PTR_ERR(sata->rst);
1727                 dev_err(&pad->dev, "failed to get SATA pad reset: %d\n", err);
1728                 goto unregister;
1729         }
1730
1731         err = tegra_xusb_pad_register(pad, &tegra210_sata_phy_ops);
1732         if (err < 0)
1733                 goto unregister;
1734
1735         dev_set_drvdata(&pad->dev, pad);
1736
1737         return pad;
1738
1739 unregister:
1740         device_unregister(&pad->dev);
1741 out:
1742         return ERR_PTR(err);
1743 }
1744
1745 static void tegra210_sata_pad_remove(struct tegra_xusb_pad *pad)
1746 {
1747         struct tegra_xusb_sata_pad *sata = to_sata_pad(pad);
1748
1749         kfree(sata);
1750 }
1751
1752 static const struct tegra_xusb_pad_ops tegra210_sata_ops = {
1753         .probe = tegra210_sata_pad_probe,
1754         .remove = tegra210_sata_pad_remove,
1755 };
1756
1757 static const struct tegra_xusb_pad_soc tegra210_sata_pad = {
1758         .name = "sata",
1759         .num_lanes = ARRAY_SIZE(tegra210_sata_lanes),
1760         .lanes = tegra210_sata_lanes,
1761         .ops = &tegra210_sata_ops,
1762 };
1763
1764 static const struct tegra_xusb_pad_soc * const tegra210_pads[] = {
1765         &tegra210_usb2_pad,
1766         &tegra210_hsic_pad,
1767         &tegra210_pcie_pad,
1768         &tegra210_sata_pad,
1769 };
1770
1771 static int tegra210_usb2_port_enable(struct tegra_xusb_port *port)
1772 {
1773         return 0;
1774 }
1775
1776 static void tegra210_usb2_port_disable(struct tegra_xusb_port *port)
1777 {
1778 }
1779
1780 static struct tegra_xusb_lane *
1781 tegra210_usb2_port_map(struct tegra_xusb_port *port)
1782 {
1783         return tegra_xusb_find_lane(port->padctl, "usb2", port->index);
1784 }
1785
1786 static const struct tegra_xusb_port_ops tegra210_usb2_port_ops = {
1787         .enable = tegra210_usb2_port_enable,
1788         .disable = tegra210_usb2_port_disable,
1789         .map = tegra210_usb2_port_map,
1790 };
1791
1792 static int tegra210_hsic_port_enable(struct tegra_xusb_port *port)
1793 {
1794         return 0;
1795 }
1796
1797 static void tegra210_hsic_port_disable(struct tegra_xusb_port *port)
1798 {
1799 }
1800
1801 static struct tegra_xusb_lane *
1802 tegra210_hsic_port_map(struct tegra_xusb_port *port)
1803 {
1804         return tegra_xusb_find_lane(port->padctl, "hsic", port->index);
1805 }
1806
1807 static const struct tegra_xusb_port_ops tegra210_hsic_port_ops = {
1808         .enable = tegra210_hsic_port_enable,
1809         .disable = tegra210_hsic_port_disable,
1810         .map = tegra210_hsic_port_map,
1811 };
1812
1813 static int tegra210_usb3_port_enable(struct tegra_xusb_port *port)
1814 {
1815         struct tegra_xusb_usb3_port *usb3 = to_usb3_port(port);
1816         struct tegra_xusb_padctl *padctl = port->padctl;
1817         struct tegra_xusb_lane *lane = usb3->base.lane;
1818         unsigned int index = port->index;
1819         u32 value;
1820         int err;
1821
1822         value = padctl_readl(padctl, XUSB_PADCTL_SS_PORT_MAP);
1823
1824         if (!usb3->internal)
1825                 value &= ~XUSB_PADCTL_SS_PORT_MAP_PORTX_INTERNAL(index);
1826         else
1827                 value |= XUSB_PADCTL_SS_PORT_MAP_PORTX_INTERNAL(index);
1828
1829         value &= ~XUSB_PADCTL_SS_PORT_MAP_PORTX_MAP_MASK(index);
1830         value |= XUSB_PADCTL_SS_PORT_MAP_PORTX_MAP(index, usb3->port);
1831         padctl_writel(padctl, value, XUSB_PADCTL_SS_PORT_MAP);
1832
1833         /*
1834          * TODO: move this code into the PCIe/SATA PHY ->power_on() callbacks
1835          * and conditionalize based on mux function? This seems to work, but
1836          * might not be the exact proper sequence.
1837          */
1838         err = regulator_enable(usb3->supply);
1839         if (err < 0)
1840                 return err;
1841
1842         value = padctl_readl(padctl, XUSB_PADCTL_UPHY_USB3_PADX_ECTL1(index));
1843         value &= ~(XUSB_PADCTL_UPHY_USB3_PAD_ECTL1_TX_TERM_CTRL_MASK <<
1844                    XUSB_PADCTL_UPHY_USB3_PAD_ECTL1_TX_TERM_CTRL_SHIFT);
1845         value |= XUSB_PADCTL_UPHY_USB3_PAD_ECTL1_TX_TERM_CTRL_VAL <<
1846                  XUSB_PADCTL_UPHY_USB3_PAD_ECTL1_TX_TERM_CTRL_SHIFT;
1847         padctl_writel(padctl, value, XUSB_PADCTL_UPHY_USB3_PADX_ECTL1(index));
1848
1849         value = padctl_readl(padctl, XUSB_PADCTL_UPHY_USB3_PADX_ECTL2(index));
1850         value &= ~(XUSB_PADCTL_UPHY_USB3_PAD_ECTL2_RX_CTLE_MASK <<
1851                    XUSB_PADCTL_UPHY_USB3_PAD_ECTL2_RX_CTLE_SHIFT);
1852         value |= XUSB_PADCTL_UPHY_USB3_PAD_ECTL2_RX_CTLE_VAL <<
1853                  XUSB_PADCTL_UPHY_USB3_PAD_ECTL2_RX_CTLE_SHIFT;
1854         padctl_writel(padctl, value, XUSB_PADCTL_UPHY_USB3_PADX_ECTL2(index));
1855
1856         padctl_writel(padctl, XUSB_PADCTL_UPHY_USB3_PAD_ECTL3_RX_DFE_VAL,
1857                       XUSB_PADCTL_UPHY_USB3_PADX_ECTL3(index));
1858
1859         value = padctl_readl(padctl, XUSB_PADCTL_UPHY_USB3_PADX_ECTL4(index));
1860         value &= ~(XUSB_PADCTL_UPHY_USB3_PAD_ECTL4_RX_CDR_CTRL_MASK <<
1861                    XUSB_PADCTL_UPHY_USB3_PAD_ECTL4_RX_CDR_CTRL_SHIFT);
1862         value |= XUSB_PADCTL_UPHY_USB3_PAD_ECTL4_RX_CDR_CTRL_VAL <<
1863                  XUSB_PADCTL_UPHY_USB3_PAD_ECTL4_RX_CDR_CTRL_SHIFT;
1864         padctl_writel(padctl, value, XUSB_PADCTL_UPHY_USB3_PADX_ECTL4(index));
1865
1866         padctl_writel(padctl, XUSB_PADCTL_UPHY_USB3_PAD_ECTL6_RX_EQ_CTRL_H_VAL,
1867                       XUSB_PADCTL_UPHY_USB3_PADX_ECTL6(index));
1868
1869         if (lane->pad == padctl->sata)
1870                 err = tegra210_sata_uphy_enable(padctl, true);
1871         else
1872                 err = tegra210_pex_uphy_enable(padctl);
1873
1874         if (err) {
1875                 dev_err(&port->dev, "%s: failed to enable UPHY: %d\n",
1876                         __func__, err);
1877                 return err;
1878         }
1879
1880         value = padctl_readl(padctl, XUSB_PADCTL_ELPG_PROGRAM1);
1881         value &= ~XUSB_PADCTL_ELPG_PROGRAM1_SSPX_ELPG_VCORE_DOWN(index);
1882         padctl_writel(padctl, value, XUSB_PADCTL_ELPG_PROGRAM1);
1883
1884         usleep_range(100, 200);
1885
1886         value = padctl_readl(padctl, XUSB_PADCTL_ELPG_PROGRAM1);
1887         value &= ~XUSB_PADCTL_ELPG_PROGRAM1_SSPX_ELPG_CLAMP_EN_EARLY(index);
1888         padctl_writel(padctl, value, XUSB_PADCTL_ELPG_PROGRAM1);
1889
1890         usleep_range(100, 200);
1891
1892         value = padctl_readl(padctl, XUSB_PADCTL_ELPG_PROGRAM1);
1893         value &= ~XUSB_PADCTL_ELPG_PROGRAM1_SSPX_ELPG_CLAMP_EN(index);
1894         padctl_writel(padctl, value, XUSB_PADCTL_ELPG_PROGRAM1);
1895
1896         return 0;
1897 }
1898
1899 static void tegra210_usb3_port_disable(struct tegra_xusb_port *port)
1900 {
1901         struct tegra_xusb_usb3_port *usb3 = to_usb3_port(port);
1902         struct tegra_xusb_padctl *padctl = port->padctl;
1903         struct tegra_xusb_lane *lane = port->lane;
1904         unsigned int index = port->index;
1905         u32 value;
1906
1907         value = padctl_readl(padctl, XUSB_PADCTL_ELPG_PROGRAM1);
1908         value |= XUSB_PADCTL_ELPG_PROGRAM1_SSPX_ELPG_CLAMP_EN_EARLY(index);
1909         padctl_writel(padctl, value, XUSB_PADCTL_ELPG_PROGRAM1);
1910
1911         usleep_range(100, 200);
1912
1913         value = padctl_readl(padctl, XUSB_PADCTL_ELPG_PROGRAM1);
1914         value |= XUSB_PADCTL_ELPG_PROGRAM1_SSPX_ELPG_CLAMP_EN(index);
1915         padctl_writel(padctl, value, XUSB_PADCTL_ELPG_PROGRAM1);
1916
1917         usleep_range(250, 350);
1918
1919         value = padctl_readl(padctl, XUSB_PADCTL_ELPG_PROGRAM1);
1920         value |= XUSB_PADCTL_ELPG_PROGRAM1_SSPX_ELPG_VCORE_DOWN(index);
1921         padctl_writel(padctl, value, XUSB_PADCTL_ELPG_PROGRAM1);
1922
1923         if (lane->pad == padctl->sata)
1924                 tegra210_sata_uphy_disable(padctl);
1925         else
1926                 tegra210_pex_uphy_disable(padctl);
1927
1928         regulator_disable(usb3->supply);
1929
1930         value = padctl_readl(padctl, XUSB_PADCTL_SS_PORT_MAP);
1931         value &= ~XUSB_PADCTL_SS_PORT_MAP_PORTX_MAP_MASK(index);
1932         value |= XUSB_PADCTL_SS_PORT_MAP_PORTX_MAP(index, 0x7);
1933         padctl_writel(padctl, value, XUSB_PADCTL_SS_PORT_MAP);
1934 }
1935
1936 static const struct tegra_xusb_lane_map tegra210_usb3_map[] = {
1937         { 0, "pcie", 6 },
1938         { 1, "pcie", 5 },
1939         { 2, "pcie", 0 },
1940         { 2, "pcie", 3 },
1941         { 3, "pcie", 4 },
1942         { 3, "pcie", 4 },
1943         { 0, NULL,   0 }
1944 };
1945
1946 static struct tegra_xusb_lane *
1947 tegra210_usb3_port_map(struct tegra_xusb_port *port)
1948 {
1949         return tegra_xusb_port_find_lane(port, tegra210_usb3_map, "usb3-ss");
1950 }
1951
1952 static const struct tegra_xusb_port_ops tegra210_usb3_port_ops = {
1953         .enable = tegra210_usb3_port_enable,
1954         .disable = tegra210_usb3_port_disable,
1955         .map = tegra210_usb3_port_map,
1956 };
1957
1958 static int
1959 tegra210_xusb_read_fuse_calibration(struct tegra210_xusb_fuse_calibration *fuse)
1960 {
1961         unsigned int i;
1962         u32 value;
1963         int err;
1964
1965         err = tegra_fuse_readl(TEGRA_FUSE_SKU_CALIB_0, &value);
1966         if (err < 0)
1967                 return err;
1968
1969         for (i = 0; i < ARRAY_SIZE(fuse->hs_curr_level); i++) {
1970                 fuse->hs_curr_level[i] =
1971                         (value >> FUSE_SKU_CALIB_HS_CURR_LEVEL_PADX_SHIFT(i)) &
1972                         FUSE_SKU_CALIB_HS_CURR_LEVEL_PAD_MASK;
1973         }
1974
1975         fuse->hs_term_range_adj =
1976                 (value >> FUSE_SKU_CALIB_HS_TERM_RANGE_ADJ_SHIFT) &
1977                 FUSE_SKU_CALIB_HS_TERM_RANGE_ADJ_MASK;
1978
1979         err = tegra_fuse_readl(TEGRA_FUSE_USB_CALIB_EXT_0, &value);
1980         if (err < 0)
1981                 return err;
1982
1983         fuse->rpd_ctrl =
1984                 (value >> FUSE_USB_CALIB_EXT_RPD_CTRL_SHIFT) &
1985                 FUSE_USB_CALIB_EXT_RPD_CTRL_MASK;
1986
1987         return 0;
1988 }
1989
1990 static struct tegra_xusb_padctl *
1991 tegra210_xusb_padctl_probe(struct device *dev,
1992                            const struct tegra_xusb_padctl_soc *soc)
1993 {
1994         struct tegra210_xusb_padctl *padctl;
1995         int err;
1996
1997         padctl = devm_kzalloc(dev, sizeof(*padctl), GFP_KERNEL);
1998         if (!padctl)
1999                 return ERR_PTR(-ENOMEM);
2000
2001         padctl->base.dev = dev;
2002         padctl->base.soc = soc;
2003
2004         err = tegra210_xusb_read_fuse_calibration(&padctl->fuse);
2005         if (err < 0)
2006                 return ERR_PTR(err);
2007
2008         return &padctl->base;
2009 }
2010
2011 static void tegra210_xusb_padctl_remove(struct tegra_xusb_padctl *padctl)
2012 {
2013 }
2014
2015 static const struct tegra_xusb_padctl_ops tegra210_xusb_padctl_ops = {
2016         .probe = tegra210_xusb_padctl_probe,
2017         .remove = tegra210_xusb_padctl_remove,
2018         .usb3_set_lfps_detect = tegra210_usb3_set_lfps_detect,
2019         .hsic_set_idle = tegra210_hsic_set_idle,
2020 };
2021
2022 const struct tegra_xusb_padctl_soc tegra210_xusb_padctl_soc = {
2023         .num_pads = ARRAY_SIZE(tegra210_pads),
2024         .pads = tegra210_pads,
2025         .ports = {
2026                 .usb2 = {
2027                         .ops = &tegra210_usb2_port_ops,
2028                         .count = 4,
2029                 },
2030                 .hsic = {
2031                         .ops = &tegra210_hsic_port_ops,
2032                         .count = 1,
2033                 },
2034                 .usb3 = {
2035                         .ops = &tegra210_usb3_port_ops,
2036                         .count = 4,
2037                 },
2038         },
2039         .ops = &tegra210_xusb_padctl_ops,
2040 };
2041 EXPORT_SYMBOL_GPL(tegra210_xusb_padctl_soc);
2042
2043 MODULE_AUTHOR("Andrew Bresticker <abrestic@chromium.org>");
2044 MODULE_DESCRIPTION("NVIDIA Tegra 210 XUSB Pad Controller driver");
2045 MODULE_LICENSE("GPL v2");