1 // SPDX-License-Identifier: GPL-2.0
3 * Copyright (C) 2010 Google, Inc.
4 * Copyright (C) 2013 NVIDIA Corporation
7 * Erik Gilling <konkers@google.com>
8 * Benoit Goby <benoit@android.com>
9 * Venu Byravarasu <vbyravarasu@nvidia.com>
12 #include <linux/resource.h>
13 #include <linux/delay.h>
14 #include <linux/slab.h>
15 #include <linux/err.h>
16 #include <linux/export.h>
17 #include <linux/module.h>
18 #include <linux/platform_device.h>
20 #include <linux/gpio.h>
22 #include <linux/of_device.h>
23 #include <linux/of_gpio.h>
24 #include <linux/usb/otg.h>
25 #include <linux/usb/ulpi.h>
26 #include <linux/usb/of.h>
27 #include <linux/usb/ehci_def.h>
28 #include <linux/usb/tegra_usb_phy.h>
29 #include <linux/regulator/consumer.h>
31 #define ULPI_VIEWPORT 0x170
33 /* PORTSC PTS/PHCD bits, Tegra20 only */
34 #define TEGRA_USB_PORTSC1 0x184
35 #define TEGRA_USB_PORTSC1_PTS(x) (((x) & 0x3) << 30)
36 #define TEGRA_USB_PORTSC1_PHCD (1 << 23)
38 /* HOSTPC1 PTS/PHCD bits, Tegra30 and above */
39 #define TEGRA_USB_HOSTPC1_DEVLC 0x1b4
40 #define TEGRA_USB_HOSTPC1_DEVLC_PTS(x) (((x) & 0x7) << 29)
41 #define TEGRA_USB_HOSTPC1_DEVLC_PHCD (1 << 22)
43 /* Bits of PORTSC1, which will get cleared by writing 1 into them */
44 #define TEGRA_PORTSC1_RWC_BITS (PORT_CSC | PORT_PEC | PORT_OCC)
46 #define USB_SUSP_CTRL 0x400
47 #define USB_WAKE_ON_CNNT_EN_DEV (1 << 3)
48 #define USB_WAKE_ON_DISCON_EN_DEV (1 << 4)
49 #define USB_SUSP_CLR (1 << 5)
50 #define USB_PHY_CLK_VALID (1 << 7)
51 #define UTMIP_RESET (1 << 11)
52 #define UHSIC_RESET (1 << 11)
53 #define UTMIP_PHY_ENABLE (1 << 12)
54 #define ULPI_PHY_ENABLE (1 << 13)
55 #define USB_SUSP_SET (1 << 14)
56 #define USB_WAKEUP_DEBOUNCE_COUNT(x) (((x) & 0x7) << 16)
58 #define USB1_LEGACY_CTRL 0x410
59 #define USB1_NO_LEGACY_MODE (1 << 0)
60 #define USB1_VBUS_SENSE_CTL_MASK (3 << 1)
61 #define USB1_VBUS_SENSE_CTL_VBUS_WAKEUP (0 << 1)
62 #define USB1_VBUS_SENSE_CTL_AB_SESS_VLD_OR_VBUS_WAKEUP \
64 #define USB1_VBUS_SENSE_CTL_AB_SESS_VLD (2 << 1)
65 #define USB1_VBUS_SENSE_CTL_A_SESS_VLD (3 << 1)
67 #define ULPI_TIMING_CTRL_0 0x424
68 #define ULPI_OUTPUT_PINMUX_BYP (1 << 10)
69 #define ULPI_CLKOUT_PINMUX_BYP (1 << 11)
71 #define ULPI_TIMING_CTRL_1 0x428
72 #define ULPI_DATA_TRIMMER_LOAD (1 << 0)
73 #define ULPI_DATA_TRIMMER_SEL(x) (((x) & 0x7) << 1)
74 #define ULPI_STPDIRNXT_TRIMMER_LOAD (1 << 16)
75 #define ULPI_STPDIRNXT_TRIMMER_SEL(x) (((x) & 0x7) << 17)
76 #define ULPI_DIR_TRIMMER_LOAD (1 << 24)
77 #define ULPI_DIR_TRIMMER_SEL(x) (((x) & 0x7) << 25)
79 #define UTMIP_PLL_CFG1 0x804
80 #define UTMIP_XTAL_FREQ_COUNT(x) (((x) & 0xfff) << 0)
81 #define UTMIP_PLLU_ENABLE_DLY_COUNT(x) (((x) & 0x1f) << 27)
83 #define UTMIP_XCVR_CFG0 0x808
84 #define UTMIP_XCVR_SETUP(x) (((x) & 0xf) << 0)
85 #define UTMIP_XCVR_SETUP_MSB(x) ((((x) & 0x70) >> 4) << 22)
86 #define UTMIP_XCVR_LSRSLEW(x) (((x) & 0x3) << 8)
87 #define UTMIP_XCVR_LSFSLEW(x) (((x) & 0x3) << 10)
88 #define UTMIP_FORCE_PD_POWERDOWN (1 << 14)
89 #define UTMIP_FORCE_PD2_POWERDOWN (1 << 16)
90 #define UTMIP_FORCE_PDZI_POWERDOWN (1 << 18)
91 #define UTMIP_XCVR_LSBIAS_SEL (1 << 21)
92 #define UTMIP_XCVR_HSSLEW(x) (((x) & 0x3) << 4)
93 #define UTMIP_XCVR_HSSLEW_MSB(x) ((((x) & 0x1fc) >> 2) << 25)
95 #define UTMIP_BIAS_CFG0 0x80c
96 #define UTMIP_OTGPD (1 << 11)
97 #define UTMIP_BIASPD (1 << 10)
98 #define UTMIP_HSSQUELCH_LEVEL(x) (((x) & 0x3) << 0)
99 #define UTMIP_HSDISCON_LEVEL(x) (((x) & 0x3) << 2)
100 #define UTMIP_HSDISCON_LEVEL_MSB(x) ((((x) & 0x4) >> 2) << 24)
102 #define UTMIP_HSRX_CFG0 0x810
103 #define UTMIP_ELASTIC_LIMIT(x) (((x) & 0x1f) << 10)
104 #define UTMIP_IDLE_WAIT(x) (((x) & 0x1f) << 15)
106 #define UTMIP_HSRX_CFG1 0x814
107 #define UTMIP_HS_SYNC_START_DLY(x) (((x) & 0x1f) << 1)
109 #define UTMIP_TX_CFG0 0x820
110 #define UTMIP_FS_PREABMLE_J (1 << 19)
111 #define UTMIP_HS_DISCON_DISABLE (1 << 8)
113 #define UTMIP_MISC_CFG0 0x824
114 #define UTMIP_DPDM_OBSERVE (1 << 26)
115 #define UTMIP_DPDM_OBSERVE_SEL(x) (((x) & 0xf) << 27)
116 #define UTMIP_DPDM_OBSERVE_SEL_FS_J UTMIP_DPDM_OBSERVE_SEL(0xf)
117 #define UTMIP_DPDM_OBSERVE_SEL_FS_K UTMIP_DPDM_OBSERVE_SEL(0xe)
118 #define UTMIP_DPDM_OBSERVE_SEL_FS_SE1 UTMIP_DPDM_OBSERVE_SEL(0xd)
119 #define UTMIP_DPDM_OBSERVE_SEL_FS_SE0 UTMIP_DPDM_OBSERVE_SEL(0xc)
120 #define UTMIP_SUSPEND_EXIT_ON_EDGE (1 << 22)
122 #define UTMIP_MISC_CFG1 0x828
123 #define UTMIP_PLL_ACTIVE_DLY_COUNT(x) (((x) & 0x1f) << 18)
124 #define UTMIP_PLLU_STABLE_COUNT(x) (((x) & 0xfff) << 6)
126 #define UTMIP_DEBOUNCE_CFG0 0x82c
127 #define UTMIP_BIAS_DEBOUNCE_A(x) (((x) & 0xffff) << 0)
129 #define UTMIP_BAT_CHRG_CFG0 0x830
130 #define UTMIP_PD_CHRG (1 << 0)
132 #define UTMIP_SPARE_CFG0 0x834
133 #define FUSE_SETUP_SEL (1 << 3)
135 #define UTMIP_XCVR_CFG1 0x838
136 #define UTMIP_FORCE_PDDISC_POWERDOWN (1 << 0)
137 #define UTMIP_FORCE_PDCHRP_POWERDOWN (1 << 2)
138 #define UTMIP_FORCE_PDDR_POWERDOWN (1 << 4)
139 #define UTMIP_XCVR_TERM_RANGE_ADJ(x) (((x) & 0xf) << 18)
141 #define UTMIP_BIAS_CFG1 0x83c
142 #define UTMIP_BIAS_PDTRK_COUNT(x) (((x) & 0x1f) << 3)
144 /* For Tegra30 and above only, the address is different in Tegra20 */
145 #define USB_USBMODE 0x1f8
146 #define USB_USBMODE_MASK (3 << 0)
147 #define USB_USBMODE_HOST (3 << 0)
148 #define USB_USBMODE_DEVICE (2 << 0)
150 static DEFINE_SPINLOCK(utmip_pad_lock
);
151 static int utmip_pad_count
;
153 struct tegra_xtal_freq
{
162 static const struct tegra_xtal_freq tegra_freq_table
[] = {
165 .enable_delay
= 0x02,
166 .stable_count
= 0x2F,
167 .active_delay
= 0x04,
168 .xtal_freq_count
= 0x76,
173 .enable_delay
= 0x02,
174 .stable_count
= 0x33,
175 .active_delay
= 0x05,
176 .xtal_freq_count
= 0x7F,
181 .enable_delay
= 0x03,
182 .stable_count
= 0x4B,
183 .active_delay
= 0x06,
184 .xtal_freq_count
= 0xBB,
189 .enable_delay
= 0x04,
190 .stable_count
= 0x66,
191 .active_delay
= 0x09,
192 .xtal_freq_count
= 0xFE,
197 static void set_pts(struct tegra_usb_phy
*phy
, u8 pts_val
)
199 void __iomem
*base
= phy
->regs
;
202 if (phy
->soc_config
->has_hostpc
) {
203 val
= readl(base
+ TEGRA_USB_HOSTPC1_DEVLC
);
204 val
&= ~TEGRA_USB_HOSTPC1_DEVLC_PTS(~0);
205 val
|= TEGRA_USB_HOSTPC1_DEVLC_PTS(pts_val
);
206 writel(val
, base
+ TEGRA_USB_HOSTPC1_DEVLC
);
208 val
= readl(base
+ TEGRA_USB_PORTSC1
) & ~TEGRA_PORTSC1_RWC_BITS
;
209 val
&= ~TEGRA_USB_PORTSC1_PTS(~0);
210 val
|= TEGRA_USB_PORTSC1_PTS(pts_val
);
211 writel(val
, base
+ TEGRA_USB_PORTSC1
);
215 static void set_phcd(struct tegra_usb_phy
*phy
, bool enable
)
217 void __iomem
*base
= phy
->regs
;
220 if (phy
->soc_config
->has_hostpc
) {
221 val
= readl(base
+ TEGRA_USB_HOSTPC1_DEVLC
);
223 val
|= TEGRA_USB_HOSTPC1_DEVLC_PHCD
;
225 val
&= ~TEGRA_USB_HOSTPC1_DEVLC_PHCD
;
226 writel(val
, base
+ TEGRA_USB_HOSTPC1_DEVLC
);
228 val
= readl(base
+ TEGRA_USB_PORTSC1
) & ~PORT_RWC_BITS
;
230 val
|= TEGRA_USB_PORTSC1_PHCD
;
232 val
&= ~TEGRA_USB_PORTSC1_PHCD
;
233 writel(val
, base
+ TEGRA_USB_PORTSC1
);
237 static int utmip_pad_open(struct tegra_usb_phy
*phy
)
239 phy
->pad_clk
= devm_clk_get(phy
->u_phy
.dev
, "utmi-pads");
240 if (IS_ERR(phy
->pad_clk
)) {
241 pr_err("%s: can't get utmip pad clock\n", __func__
);
242 return PTR_ERR(phy
->pad_clk
);
248 static void utmip_pad_power_on(struct tegra_usb_phy
*phy
)
250 unsigned long val
, flags
;
251 void __iomem
*base
= phy
->pad_regs
;
252 struct tegra_utmip_config
*config
= phy
->config
;
254 clk_prepare_enable(phy
->pad_clk
);
256 spin_lock_irqsave(&utmip_pad_lock
, flags
);
258 if (utmip_pad_count
++ == 0) {
259 val
= readl(base
+ UTMIP_BIAS_CFG0
);
260 val
&= ~(UTMIP_OTGPD
| UTMIP_BIASPD
);
262 if (phy
->soc_config
->requires_extra_tuning_parameters
) {
263 val
&= ~(UTMIP_HSSQUELCH_LEVEL(~0) |
264 UTMIP_HSDISCON_LEVEL(~0) |
265 UTMIP_HSDISCON_LEVEL_MSB(~0));
267 val
|= UTMIP_HSSQUELCH_LEVEL(config
->hssquelch_level
);
268 val
|= UTMIP_HSDISCON_LEVEL(config
->hsdiscon_level
);
269 val
|= UTMIP_HSDISCON_LEVEL_MSB(config
->hsdiscon_level
);
271 writel(val
, base
+ UTMIP_BIAS_CFG0
);
274 spin_unlock_irqrestore(&utmip_pad_lock
, flags
);
276 clk_disable_unprepare(phy
->pad_clk
);
279 static int utmip_pad_power_off(struct tegra_usb_phy
*phy
)
281 unsigned long val
, flags
;
282 void __iomem
*base
= phy
->pad_regs
;
284 if (!utmip_pad_count
) {
285 pr_err("%s: utmip pad already powered off\n", __func__
);
289 clk_prepare_enable(phy
->pad_clk
);
291 spin_lock_irqsave(&utmip_pad_lock
, flags
);
293 if (--utmip_pad_count
== 0) {
294 val
= readl(base
+ UTMIP_BIAS_CFG0
);
295 val
|= UTMIP_OTGPD
| UTMIP_BIASPD
;
296 writel(val
, base
+ UTMIP_BIAS_CFG0
);
299 spin_unlock_irqrestore(&utmip_pad_lock
, flags
);
301 clk_disable_unprepare(phy
->pad_clk
);
306 static int utmi_wait_register(void __iomem
*reg
, u32 mask
, u32 result
)
308 unsigned long timeout
= 2000;
310 if ((readl(reg
) & mask
) == result
)
318 static void utmi_phy_clk_disable(struct tegra_usb_phy
*phy
)
321 void __iomem
*base
= phy
->regs
;
324 * The USB driver may have already initiated the phy clock
325 * disable so wait to see if the clock turns off and if not
326 * then proceed with gating the clock.
328 if (utmi_wait_register(base
+ USB_SUSP_CTRL
, USB_PHY_CLK_VALID
, 0) == 0)
331 if (phy
->is_legacy_phy
) {
332 val
= readl(base
+ USB_SUSP_CTRL
);
334 writel(val
, base
+ USB_SUSP_CTRL
);
338 val
= readl(base
+ USB_SUSP_CTRL
);
339 val
&= ~USB_SUSP_SET
;
340 writel(val
, base
+ USB_SUSP_CTRL
);
344 if (utmi_wait_register(base
+ USB_SUSP_CTRL
, USB_PHY_CLK_VALID
, 0) < 0)
345 pr_err("%s: timeout waiting for phy to stabilize\n", __func__
);
348 static void utmi_phy_clk_enable(struct tegra_usb_phy
*phy
)
351 void __iomem
*base
= phy
->regs
;
354 * The USB driver may have already initiated the phy clock
355 * enable so wait to see if the clock turns on and if not
356 * then proceed with ungating the clock.
358 if (utmi_wait_register(base
+ USB_SUSP_CTRL
, USB_PHY_CLK_VALID
,
359 USB_PHY_CLK_VALID
) == 0)
362 if (phy
->is_legacy_phy
) {
363 val
= readl(base
+ USB_SUSP_CTRL
);
365 writel(val
, base
+ USB_SUSP_CTRL
);
369 val
= readl(base
+ USB_SUSP_CTRL
);
370 val
&= ~USB_SUSP_CLR
;
371 writel(val
, base
+ USB_SUSP_CTRL
);
373 set_phcd(phy
, false);
375 if (utmi_wait_register(base
+ USB_SUSP_CTRL
, USB_PHY_CLK_VALID
,
377 pr_err("%s: timeout waiting for phy to stabilize\n", __func__
);
380 static int utmi_phy_power_on(struct tegra_usb_phy
*phy
)
383 void __iomem
*base
= phy
->regs
;
384 struct tegra_utmip_config
*config
= phy
->config
;
386 val
= readl(base
+ USB_SUSP_CTRL
);
388 writel(val
, base
+ USB_SUSP_CTRL
);
390 if (phy
->is_legacy_phy
) {
391 val
= readl(base
+ USB1_LEGACY_CTRL
);
392 val
|= USB1_NO_LEGACY_MODE
;
393 writel(val
, base
+ USB1_LEGACY_CTRL
);
396 val
= readl(base
+ UTMIP_TX_CFG0
);
397 val
|= UTMIP_FS_PREABMLE_J
;
398 writel(val
, base
+ UTMIP_TX_CFG0
);
400 val
= readl(base
+ UTMIP_HSRX_CFG0
);
401 val
&= ~(UTMIP_IDLE_WAIT(~0) | UTMIP_ELASTIC_LIMIT(~0));
402 val
|= UTMIP_IDLE_WAIT(config
->idle_wait_delay
);
403 val
|= UTMIP_ELASTIC_LIMIT(config
->elastic_limit
);
404 writel(val
, base
+ UTMIP_HSRX_CFG0
);
406 val
= readl(base
+ UTMIP_HSRX_CFG1
);
407 val
&= ~UTMIP_HS_SYNC_START_DLY(~0);
408 val
|= UTMIP_HS_SYNC_START_DLY(config
->hssync_start_delay
);
409 writel(val
, base
+ UTMIP_HSRX_CFG1
);
411 val
= readl(base
+ UTMIP_DEBOUNCE_CFG0
);
412 val
&= ~UTMIP_BIAS_DEBOUNCE_A(~0);
413 val
|= UTMIP_BIAS_DEBOUNCE_A(phy
->freq
->debounce
);
414 writel(val
, base
+ UTMIP_DEBOUNCE_CFG0
);
416 val
= readl(base
+ UTMIP_MISC_CFG0
);
417 val
&= ~UTMIP_SUSPEND_EXIT_ON_EDGE
;
418 writel(val
, base
+ UTMIP_MISC_CFG0
);
420 if (!phy
->soc_config
->utmi_pll_config_in_car_module
) {
421 val
= readl(base
+ UTMIP_MISC_CFG1
);
422 val
&= ~(UTMIP_PLL_ACTIVE_DLY_COUNT(~0) |
423 UTMIP_PLLU_STABLE_COUNT(~0));
424 val
|= UTMIP_PLL_ACTIVE_DLY_COUNT(phy
->freq
->active_delay
) |
425 UTMIP_PLLU_STABLE_COUNT(phy
->freq
->stable_count
);
426 writel(val
, base
+ UTMIP_MISC_CFG1
);
428 val
= readl(base
+ UTMIP_PLL_CFG1
);
429 val
&= ~(UTMIP_XTAL_FREQ_COUNT(~0) |
430 UTMIP_PLLU_ENABLE_DLY_COUNT(~0));
431 val
|= UTMIP_XTAL_FREQ_COUNT(phy
->freq
->xtal_freq_count
) |
432 UTMIP_PLLU_ENABLE_DLY_COUNT(phy
->freq
->enable_delay
);
433 writel(val
, base
+ UTMIP_PLL_CFG1
);
436 if (phy
->mode
== USB_DR_MODE_PERIPHERAL
) {
437 val
= readl(base
+ USB_SUSP_CTRL
);
438 val
&= ~(USB_WAKE_ON_CNNT_EN_DEV
| USB_WAKE_ON_DISCON_EN_DEV
);
439 writel(val
, base
+ USB_SUSP_CTRL
);
441 val
= readl(base
+ UTMIP_BAT_CHRG_CFG0
);
442 val
&= ~UTMIP_PD_CHRG
;
443 writel(val
, base
+ UTMIP_BAT_CHRG_CFG0
);
445 val
= readl(base
+ UTMIP_BAT_CHRG_CFG0
);
446 val
|= UTMIP_PD_CHRG
;
447 writel(val
, base
+ UTMIP_BAT_CHRG_CFG0
);
450 utmip_pad_power_on(phy
);
452 val
= readl(base
+ UTMIP_XCVR_CFG0
);
453 val
&= ~(UTMIP_FORCE_PD_POWERDOWN
| UTMIP_FORCE_PD2_POWERDOWN
|
454 UTMIP_FORCE_PDZI_POWERDOWN
| UTMIP_XCVR_LSBIAS_SEL
|
455 UTMIP_XCVR_SETUP(~0) | UTMIP_XCVR_SETUP_MSB(~0) |
456 UTMIP_XCVR_LSFSLEW(~0) | UTMIP_XCVR_LSRSLEW(~0));
458 if (!config
->xcvr_setup_use_fuses
) {
459 val
|= UTMIP_XCVR_SETUP(config
->xcvr_setup
);
460 val
|= UTMIP_XCVR_SETUP_MSB(config
->xcvr_setup
);
462 val
|= UTMIP_XCVR_LSFSLEW(config
->xcvr_lsfslew
);
463 val
|= UTMIP_XCVR_LSRSLEW(config
->xcvr_lsrslew
);
465 if (phy
->soc_config
->requires_extra_tuning_parameters
) {
466 val
&= ~(UTMIP_XCVR_HSSLEW(~0) | UTMIP_XCVR_HSSLEW_MSB(~0));
467 val
|= UTMIP_XCVR_HSSLEW(config
->xcvr_hsslew
);
468 val
|= UTMIP_XCVR_HSSLEW_MSB(config
->xcvr_hsslew
);
470 writel(val
, base
+ UTMIP_XCVR_CFG0
);
472 val
= readl(base
+ UTMIP_XCVR_CFG1
);
473 val
&= ~(UTMIP_FORCE_PDDISC_POWERDOWN
| UTMIP_FORCE_PDCHRP_POWERDOWN
|
474 UTMIP_FORCE_PDDR_POWERDOWN
| UTMIP_XCVR_TERM_RANGE_ADJ(~0));
475 val
|= UTMIP_XCVR_TERM_RANGE_ADJ(config
->term_range_adj
);
476 writel(val
, base
+ UTMIP_XCVR_CFG1
);
478 val
= readl(base
+ UTMIP_BIAS_CFG1
);
479 val
&= ~UTMIP_BIAS_PDTRK_COUNT(~0);
480 val
|= UTMIP_BIAS_PDTRK_COUNT(0x5);
481 writel(val
, base
+ UTMIP_BIAS_CFG1
);
483 val
= readl(base
+ UTMIP_SPARE_CFG0
);
484 if (config
->xcvr_setup_use_fuses
)
485 val
|= FUSE_SETUP_SEL
;
487 val
&= ~FUSE_SETUP_SEL
;
488 writel(val
, base
+ UTMIP_SPARE_CFG0
);
490 if (!phy
->is_legacy_phy
) {
491 val
= readl(base
+ USB_SUSP_CTRL
);
492 val
|= UTMIP_PHY_ENABLE
;
493 writel(val
, base
+ USB_SUSP_CTRL
);
496 val
= readl(base
+ USB_SUSP_CTRL
);
498 writel(val
, base
+ USB_SUSP_CTRL
);
500 if (phy
->is_legacy_phy
) {
501 val
= readl(base
+ USB1_LEGACY_CTRL
);
502 val
&= ~USB1_VBUS_SENSE_CTL_MASK
;
503 val
|= USB1_VBUS_SENSE_CTL_A_SESS_VLD
;
504 writel(val
, base
+ USB1_LEGACY_CTRL
);
506 val
= readl(base
+ USB_SUSP_CTRL
);
507 val
&= ~USB_SUSP_SET
;
508 writel(val
, base
+ USB_SUSP_CTRL
);
511 utmi_phy_clk_enable(phy
);
513 if (phy
->soc_config
->requires_usbmode_setup
) {
514 val
= readl(base
+ USB_USBMODE
);
515 val
&= ~USB_USBMODE_MASK
;
516 if (phy
->mode
== USB_DR_MODE_HOST
)
517 val
|= USB_USBMODE_HOST
;
519 val
|= USB_USBMODE_DEVICE
;
520 writel(val
, base
+ USB_USBMODE
);
523 if (!phy
->is_legacy_phy
)
529 static int utmi_phy_power_off(struct tegra_usb_phy
*phy
)
532 void __iomem
*base
= phy
->regs
;
534 utmi_phy_clk_disable(phy
);
536 if (phy
->mode
== USB_DR_MODE_PERIPHERAL
) {
537 val
= readl(base
+ USB_SUSP_CTRL
);
538 val
&= ~USB_WAKEUP_DEBOUNCE_COUNT(~0);
539 val
|= USB_WAKE_ON_CNNT_EN_DEV
| USB_WAKEUP_DEBOUNCE_COUNT(5);
540 writel(val
, base
+ USB_SUSP_CTRL
);
543 val
= readl(base
+ USB_SUSP_CTRL
);
545 writel(val
, base
+ USB_SUSP_CTRL
);
547 val
= readl(base
+ UTMIP_BAT_CHRG_CFG0
);
548 val
|= UTMIP_PD_CHRG
;
549 writel(val
, base
+ UTMIP_BAT_CHRG_CFG0
);
551 val
= readl(base
+ UTMIP_XCVR_CFG0
);
552 val
|= UTMIP_FORCE_PD_POWERDOWN
| UTMIP_FORCE_PD2_POWERDOWN
|
553 UTMIP_FORCE_PDZI_POWERDOWN
;
554 writel(val
, base
+ UTMIP_XCVR_CFG0
);
556 val
= readl(base
+ UTMIP_XCVR_CFG1
);
557 val
|= UTMIP_FORCE_PDDISC_POWERDOWN
| UTMIP_FORCE_PDCHRP_POWERDOWN
|
558 UTMIP_FORCE_PDDR_POWERDOWN
;
559 writel(val
, base
+ UTMIP_XCVR_CFG1
);
561 return utmip_pad_power_off(phy
);
564 static void utmi_phy_preresume(struct tegra_usb_phy
*phy
)
567 void __iomem
*base
= phy
->regs
;
569 val
= readl(base
+ UTMIP_TX_CFG0
);
570 val
|= UTMIP_HS_DISCON_DISABLE
;
571 writel(val
, base
+ UTMIP_TX_CFG0
);
574 static void utmi_phy_postresume(struct tegra_usb_phy
*phy
)
577 void __iomem
*base
= phy
->regs
;
579 val
= readl(base
+ UTMIP_TX_CFG0
);
580 val
&= ~UTMIP_HS_DISCON_DISABLE
;
581 writel(val
, base
+ UTMIP_TX_CFG0
);
584 static void utmi_phy_restore_start(struct tegra_usb_phy
*phy
,
585 enum tegra_usb_phy_port_speed port_speed
)
588 void __iomem
*base
= phy
->regs
;
590 val
= readl(base
+ UTMIP_MISC_CFG0
);
591 val
&= ~UTMIP_DPDM_OBSERVE_SEL(~0);
592 if (port_speed
== TEGRA_USB_PHY_PORT_SPEED_LOW
)
593 val
|= UTMIP_DPDM_OBSERVE_SEL_FS_K
;
595 val
|= UTMIP_DPDM_OBSERVE_SEL_FS_J
;
596 writel(val
, base
+ UTMIP_MISC_CFG0
);
599 val
= readl(base
+ UTMIP_MISC_CFG0
);
600 val
|= UTMIP_DPDM_OBSERVE
;
601 writel(val
, base
+ UTMIP_MISC_CFG0
);
605 static void utmi_phy_restore_end(struct tegra_usb_phy
*phy
)
608 void __iomem
*base
= phy
->regs
;
610 val
= readl(base
+ UTMIP_MISC_CFG0
);
611 val
&= ~UTMIP_DPDM_OBSERVE
;
612 writel(val
, base
+ UTMIP_MISC_CFG0
);
616 static int ulpi_phy_power_on(struct tegra_usb_phy
*phy
)
620 void __iomem
*base
= phy
->regs
;
622 ret
= gpio_direction_output(phy
->reset_gpio
, 0);
624 dev_err(phy
->u_phy
.dev
, "gpio %d not set to 0\n",
629 ret
= gpio_direction_output(phy
->reset_gpio
, 1);
631 dev_err(phy
->u_phy
.dev
, "gpio %d not set to 1\n",
636 clk_prepare_enable(phy
->clk
);
639 val
= readl(base
+ USB_SUSP_CTRL
);
641 writel(val
, base
+ USB_SUSP_CTRL
);
643 val
= readl(base
+ ULPI_TIMING_CTRL_0
);
644 val
|= ULPI_OUTPUT_PINMUX_BYP
| ULPI_CLKOUT_PINMUX_BYP
;
645 writel(val
, base
+ ULPI_TIMING_CTRL_0
);
647 val
= readl(base
+ USB_SUSP_CTRL
);
648 val
|= ULPI_PHY_ENABLE
;
649 writel(val
, base
+ USB_SUSP_CTRL
);
652 writel(val
, base
+ ULPI_TIMING_CTRL_1
);
654 val
|= ULPI_DATA_TRIMMER_SEL(4);
655 val
|= ULPI_STPDIRNXT_TRIMMER_SEL(4);
656 val
|= ULPI_DIR_TRIMMER_SEL(4);
657 writel(val
, base
+ ULPI_TIMING_CTRL_1
);
660 val
|= ULPI_DATA_TRIMMER_LOAD
;
661 val
|= ULPI_STPDIRNXT_TRIMMER_LOAD
;
662 val
|= ULPI_DIR_TRIMMER_LOAD
;
663 writel(val
, base
+ ULPI_TIMING_CTRL_1
);
665 /* Fix VbusInvalid due to floating VBUS */
666 ret
= usb_phy_io_write(phy
->ulpi
, 0x40, 0x08);
668 pr_err("%s: ulpi write failed\n", __func__
);
672 ret
= usb_phy_io_write(phy
->ulpi
, 0x80, 0x0B);
674 pr_err("%s: ulpi write failed\n", __func__
);
678 val
= readl(base
+ USB_SUSP_CTRL
);
680 writel(val
, base
+ USB_SUSP_CTRL
);
683 val
= readl(base
+ USB_SUSP_CTRL
);
684 val
&= ~USB_SUSP_CLR
;
685 writel(val
, base
+ USB_SUSP_CTRL
);
690 static int ulpi_phy_power_off(struct tegra_usb_phy
*phy
)
692 clk_disable(phy
->clk
);
693 return gpio_direction_output(phy
->reset_gpio
, 0);
696 static void tegra_usb_phy_close(struct tegra_usb_phy
*phy
)
698 if (!IS_ERR(phy
->vbus
))
699 regulator_disable(phy
->vbus
);
701 clk_disable_unprepare(phy
->pll_u
);
704 static int tegra_usb_phy_power_on(struct tegra_usb_phy
*phy
)
706 if (phy
->is_ulpi_phy
)
707 return ulpi_phy_power_on(phy
);
709 return utmi_phy_power_on(phy
);
712 static int tegra_usb_phy_power_off(struct tegra_usb_phy
*phy
)
714 if (phy
->is_ulpi_phy
)
715 return ulpi_phy_power_off(phy
);
717 return utmi_phy_power_off(phy
);
720 static int tegra_usb_phy_suspend(struct usb_phy
*x
, int suspend
)
722 struct tegra_usb_phy
*phy
= container_of(x
, struct tegra_usb_phy
, u_phy
);
724 return tegra_usb_phy_power_off(phy
);
726 return tegra_usb_phy_power_on(phy
);
729 static int ulpi_open(struct tegra_usb_phy
*phy
)
733 phy
->clk
= devm_clk_get(phy
->u_phy
.dev
, "ulpi-link");
734 if (IS_ERR(phy
->clk
)) {
735 pr_err("%s: can't get ulpi clock\n", __func__
);
736 return PTR_ERR(phy
->clk
);
739 err
= devm_gpio_request(phy
->u_phy
.dev
, phy
->reset_gpio
,
742 dev_err(phy
->u_phy
.dev
, "request failed for gpio: %d\n",
747 err
= gpio_direction_output(phy
->reset_gpio
, 0);
749 dev_err(phy
->u_phy
.dev
, "gpio %d direction not set to output\n",
754 phy
->ulpi
= otg_ulpi_create(&ulpi_viewport_access_ops
, 0);
756 dev_err(phy
->u_phy
.dev
, "otg_ulpi_create returned NULL\n");
761 phy
->ulpi
->io_priv
= phy
->regs
+ ULPI_VIEWPORT
;
765 static int tegra_usb_phy_init(struct tegra_usb_phy
*phy
)
767 unsigned long parent_rate
;
771 phy
->pll_u
= devm_clk_get(phy
->u_phy
.dev
, "pll_u");
772 if (IS_ERR(phy
->pll_u
)) {
773 pr_err("Can't get pll_u clock\n");
774 return PTR_ERR(phy
->pll_u
);
777 err
= clk_prepare_enable(phy
->pll_u
);
781 parent_rate
= clk_get_rate(clk_get_parent(phy
->pll_u
));
782 for (i
= 0; i
< ARRAY_SIZE(tegra_freq_table
); i
++) {
783 if (tegra_freq_table
[i
].freq
== parent_rate
) {
784 phy
->freq
= &tegra_freq_table
[i
];
789 pr_err("invalid pll_u parent rate %ld\n", parent_rate
);
794 if (!IS_ERR(phy
->vbus
)) {
795 err
= regulator_enable(phy
->vbus
);
797 dev_err(phy
->u_phy
.dev
,
798 "failed to enable usb vbus regulator: %d\n",
804 if (phy
->is_ulpi_phy
)
805 err
= ulpi_open(phy
);
807 err
= utmip_pad_open(phy
);
814 clk_disable_unprepare(phy
->pll_u
);
818 void tegra_usb_phy_preresume(struct usb_phy
*x
)
820 struct tegra_usb_phy
*phy
= container_of(x
, struct tegra_usb_phy
, u_phy
);
822 if (!phy
->is_ulpi_phy
)
823 utmi_phy_preresume(phy
);
825 EXPORT_SYMBOL_GPL(tegra_usb_phy_preresume
);
827 void tegra_usb_phy_postresume(struct usb_phy
*x
)
829 struct tegra_usb_phy
*phy
= container_of(x
, struct tegra_usb_phy
, u_phy
);
831 if (!phy
->is_ulpi_phy
)
832 utmi_phy_postresume(phy
);
834 EXPORT_SYMBOL_GPL(tegra_usb_phy_postresume
);
836 void tegra_ehci_phy_restore_start(struct usb_phy
*x
,
837 enum tegra_usb_phy_port_speed port_speed
)
839 struct tegra_usb_phy
*phy
= container_of(x
, struct tegra_usb_phy
, u_phy
);
841 if (!phy
->is_ulpi_phy
)
842 utmi_phy_restore_start(phy
, port_speed
);
844 EXPORT_SYMBOL_GPL(tegra_ehci_phy_restore_start
);
846 void tegra_ehci_phy_restore_end(struct usb_phy
*x
)
848 struct tegra_usb_phy
*phy
= container_of(x
, struct tegra_usb_phy
, u_phy
);
850 if (!phy
->is_ulpi_phy
)
851 utmi_phy_restore_end(phy
);
853 EXPORT_SYMBOL_GPL(tegra_ehci_phy_restore_end
);
855 static int read_utmi_param(struct platform_device
*pdev
, const char *param
,
859 int err
= of_property_read_u32(pdev
->dev
.of_node
, param
, &value
);
862 dev_err(&pdev
->dev
, "Failed to read USB UTMI parameter %s: %d\n",
867 static int utmi_phy_probe(struct tegra_usb_phy
*tegra_phy
,
868 struct platform_device
*pdev
)
870 struct resource
*res
;
872 struct tegra_utmip_config
*config
;
874 tegra_phy
->is_ulpi_phy
= false;
876 res
= platform_get_resource(pdev
, IORESOURCE_MEM
, 1);
878 dev_err(&pdev
->dev
, "Failed to get UTMI Pad regs\n");
882 tegra_phy
->pad_regs
= devm_ioremap(&pdev
->dev
, res
->start
,
884 if (!tegra_phy
->pad_regs
) {
885 dev_err(&pdev
->dev
, "Failed to remap UTMI Pad regs\n");
889 tegra_phy
->config
= devm_kzalloc(&pdev
->dev
, sizeof(*config
),
891 if (!tegra_phy
->config
)
894 config
= tegra_phy
->config
;
896 err
= read_utmi_param(pdev
, "nvidia,hssync-start-delay",
897 &config
->hssync_start_delay
);
901 err
= read_utmi_param(pdev
, "nvidia,elastic-limit",
902 &config
->elastic_limit
);
906 err
= read_utmi_param(pdev
, "nvidia,idle-wait-delay",
907 &config
->idle_wait_delay
);
911 err
= read_utmi_param(pdev
, "nvidia,term-range-adj",
912 &config
->term_range_adj
);
916 err
= read_utmi_param(pdev
, "nvidia,xcvr-lsfslew",
917 &config
->xcvr_lsfslew
);
921 err
= read_utmi_param(pdev
, "nvidia,xcvr-lsrslew",
922 &config
->xcvr_lsrslew
);
926 if (tegra_phy
->soc_config
->requires_extra_tuning_parameters
) {
927 err
= read_utmi_param(pdev
, "nvidia,xcvr-hsslew",
928 &config
->xcvr_hsslew
);
932 err
= read_utmi_param(pdev
, "nvidia,hssquelch-level",
933 &config
->hssquelch_level
);
937 err
= read_utmi_param(pdev
, "nvidia,hsdiscon-level",
938 &config
->hsdiscon_level
);
943 config
->xcvr_setup_use_fuses
= of_property_read_bool(
944 pdev
->dev
.of_node
, "nvidia,xcvr-setup-use-fuses");
946 if (!config
->xcvr_setup_use_fuses
) {
947 err
= read_utmi_param(pdev
, "nvidia,xcvr-setup",
948 &config
->xcvr_setup
);
956 static const struct tegra_phy_soc_config tegra20_soc_config
= {
957 .utmi_pll_config_in_car_module
= false,
959 .requires_usbmode_setup
= false,
960 .requires_extra_tuning_parameters
= false,
963 static const struct tegra_phy_soc_config tegra30_soc_config
= {
964 .utmi_pll_config_in_car_module
= true,
966 .requires_usbmode_setup
= true,
967 .requires_extra_tuning_parameters
= true,
970 static const struct of_device_id tegra_usb_phy_id_table
[] = {
971 { .compatible
= "nvidia,tegra30-usb-phy", .data
= &tegra30_soc_config
},
972 { .compatible
= "nvidia,tegra20-usb-phy", .data
= &tegra20_soc_config
},
975 MODULE_DEVICE_TABLE(of
, tegra_usb_phy_id_table
);
977 static int tegra_usb_phy_probe(struct platform_device
*pdev
)
979 const struct of_device_id
*match
;
980 struct resource
*res
;
981 struct tegra_usb_phy
*tegra_phy
= NULL
;
982 struct device_node
*np
= pdev
->dev
.of_node
;
983 enum usb_phy_interface phy_type
;
986 tegra_phy
= devm_kzalloc(&pdev
->dev
, sizeof(*tegra_phy
), GFP_KERNEL
);
990 match
= of_match_device(tegra_usb_phy_id_table
, &pdev
->dev
);
992 dev_err(&pdev
->dev
, "Error: No device match found\n");
995 tegra_phy
->soc_config
= match
->data
;
997 res
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
999 dev_err(&pdev
->dev
, "Failed to get I/O memory\n");
1003 tegra_phy
->regs
= devm_ioremap(&pdev
->dev
, res
->start
,
1004 resource_size(res
));
1005 if (!tegra_phy
->regs
) {
1006 dev_err(&pdev
->dev
, "Failed to remap I/O memory\n");
1010 tegra_phy
->is_legacy_phy
=
1011 of_property_read_bool(np
, "nvidia,has-legacy-mode");
1013 phy_type
= of_usb_get_phy_mode(np
);
1015 case USBPHY_INTERFACE_MODE_UTMI
:
1016 err
= utmi_phy_probe(tegra_phy
, pdev
);
1021 case USBPHY_INTERFACE_MODE_ULPI
:
1022 tegra_phy
->is_ulpi_phy
= true;
1024 tegra_phy
->reset_gpio
=
1025 of_get_named_gpio(np
, "nvidia,phy-reset-gpio", 0);
1026 if (!gpio_is_valid(tegra_phy
->reset_gpio
)) {
1027 dev_err(&pdev
->dev
, "invalid gpio: %d\n",
1028 tegra_phy
->reset_gpio
);
1029 return tegra_phy
->reset_gpio
;
1031 tegra_phy
->config
= NULL
;
1035 dev_err(&pdev
->dev
, "phy_type is invalid or unsupported\n");
1039 if (of_find_property(np
, "dr_mode", NULL
))
1040 tegra_phy
->mode
= usb_get_dr_mode(&pdev
->dev
);
1042 tegra_phy
->mode
= USB_DR_MODE_HOST
;
1044 if (tegra_phy
->mode
== USB_DR_MODE_UNKNOWN
) {
1045 dev_err(&pdev
->dev
, "dr_mode is invalid\n");
1049 /* On some boards, the VBUS regulator doesn't need to be controlled */
1050 if (of_find_property(np
, "vbus-supply", NULL
)) {
1051 tegra_phy
->vbus
= devm_regulator_get(&pdev
->dev
, "vbus");
1052 if (IS_ERR(tegra_phy
->vbus
))
1053 return PTR_ERR(tegra_phy
->vbus
);
1055 dev_notice(&pdev
->dev
, "no vbus regulator");
1056 tegra_phy
->vbus
= ERR_PTR(-ENODEV
);
1059 tegra_phy
->u_phy
.dev
= &pdev
->dev
;
1060 err
= tegra_usb_phy_init(tegra_phy
);
1064 tegra_phy
->u_phy
.set_suspend
= tegra_usb_phy_suspend
;
1066 platform_set_drvdata(pdev
, tegra_phy
);
1068 err
= usb_add_phy_dev(&tegra_phy
->u_phy
);
1070 tegra_usb_phy_close(tegra_phy
);
1077 static int tegra_usb_phy_remove(struct platform_device
*pdev
)
1079 struct tegra_usb_phy
*tegra_phy
= platform_get_drvdata(pdev
);
1081 usb_remove_phy(&tegra_phy
->u_phy
);
1082 tegra_usb_phy_close(tegra_phy
);
1087 static struct platform_driver tegra_usb_phy_driver
= {
1088 .probe
= tegra_usb_phy_probe
,
1089 .remove
= tegra_usb_phy_remove
,
1091 .name
= "tegra-phy",
1092 .of_match_table
= tegra_usb_phy_id_table
,
1095 module_platform_driver(tegra_usb_phy_driver
);
1097 MODULE_DESCRIPTION("Tegra USB PHY driver");
1098 MODULE_LICENSE("GPL v2");