drivers/phy/tegra/xusb-tegra186.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Copyright (c) 2016-2022, NVIDIA CORPORATION.  All rights reserved.
   4  */
   5
   6 #include <linux/delay.h>
   7 #include <linux/io.h>
   8 #include <linux/module.h>
   9 #include <linux/of.h>
  10 #include <linux/phy/phy.h>
  11 #include <linux/regulator/consumer.h>
  12 #include <linux/platform_device.h>
  13 #include <linux/clk.h>
  14 #include <linux/slab.h>
  15
  16 #include <soc/tegra/fuse.h>
  17
  18 #include "xusb.h"
  19
  20 /* FUSE USB_CALIB registers */
  21 #define HS_CURR_LEVEL_PADX_SHIFT(x)     ((x) ? (11 + (x - 1) * 6) : 0)
  22 #define HS_CURR_LEVEL_PAD_MASK          0x3f
  23 #define HS_TERM_RANGE_ADJ_SHIFT         7
  24 #define HS_TERM_RANGE_ADJ_MASK          0xf
  25 #define HS_SQUELCH_SHIFT                29
  26 #define HS_SQUELCH_MASK                 0x7
  27
  28 #define RPD_CTRL_SHIFT                  0
  29 #define RPD_CTRL_MASK                   0x1f
  30
  31 /* XUSB PADCTL registers */
  32 #define XUSB_PADCTL_USB2_PAD_MUX        0x4
  33 #define  USB2_PORT_SHIFT(x)             ((x) * 2)
  34 #define  USB2_PORT_MASK                 0x3
  35 #define   PORT_XUSB                     1
  36 #define  HSIC_PORT_SHIFT(x)             ((x) + 20)
  37 #define  HSIC_PORT_MASK                 0x1
  38 #define   PORT_HSIC                     0
  39
  40 #define XUSB_PADCTL_USB2_PORT_CAP       0x8
  41 #define XUSB_PADCTL_SS_PORT_CAP         0xc
  42 #define  PORTX_CAP_SHIFT(x)             ((x) * 4)
  43 #define  PORT_CAP_MASK                  0x3
  44 #define   PORT_CAP_DISABLED             0x0
  45 #define   PORT_CAP_HOST                 0x1
  46 #define   PORT_CAP_DEVICE               0x2
  47 #define   PORT_CAP_OTG                  0x3
  48
  49 #define XUSB_PADCTL_ELPG_PROGRAM                0x20
  50 #define  USB2_PORT_WAKE_INTERRUPT_ENABLE(x)             BIT(x)
  51 #define  USB2_PORT_WAKEUP_EVENT(x)                      BIT((x) +  7)
  52 #define  SS_PORT_WAKE_INTERRUPT_ENABLE(x)               BIT((x) + 14)
  53 #define  SS_PORT_WAKEUP_EVENT(x)                        BIT((x) + 21)
  54 #define  USB2_HSIC_PORT_WAKE_INTERRUPT_ENABLE(x)        BIT((x) + 28)
  55 #define  USB2_HSIC_PORT_WAKEUP_EVENT(x)                 BIT((x) + 30)
  56 #define  ALL_WAKE_EVENTS                                                \
  57         (USB2_PORT_WAKEUP_EVENT(0) | USB2_PORT_WAKEUP_EVENT(1) |        \
  58         USB2_PORT_WAKEUP_EVENT(2) | SS_PORT_WAKEUP_EVENT(0) |           \
  59         SS_PORT_WAKEUP_EVENT(1) | SS_PORT_WAKEUP_EVENT(2) |             \
  60         USB2_HSIC_PORT_WAKEUP_EVENT(0))
  61
  62 #define XUSB_PADCTL_ELPG_PROGRAM_1              0x24
  63 #define  SSPX_ELPG_CLAMP_EN(x)                  BIT(0 + (x) * 3)
  64 #define  SSPX_ELPG_CLAMP_EN_EARLY(x)            BIT(1 + (x) * 3)
  65 #define  SSPX_ELPG_VCORE_DOWN(x)                BIT(2 + (x) * 3)
  66 #define XUSB_PADCTL_SS_PORT_CFG                 0x2c
  67 #define   PORTX_SPEED_SUPPORT_SHIFT(x)          ((x) * 4)
  68 #define   PORTX_SPEED_SUPPORT_MASK              (0x3)
  69 #define     PORT_SPEED_SUPPORT_GEN1             (0x0)
  70
  71 #define XUSB_PADCTL_USB2_OTG_PADX_CTL0(x)       (0x88 + (x) * 0x40)
  72 #define  HS_CURR_LEVEL(x)                       ((x) & 0x3f)
  73 #define  TERM_SEL                               BIT(25)
  74 #define  USB2_OTG_PD                            BIT(26)
  75 #define  USB2_OTG_PD2                           BIT(27)
  76 #define  USB2_OTG_PD2_OVRD_EN                   BIT(28)
  77 #define  USB2_OTG_PD_ZI                         BIT(29)
  78
  79 #define XUSB_PADCTL_USB2_OTG_PADX_CTL1(x)       (0x8c + (x) * 0x40)
  80 #define  USB2_OTG_PD_DR                         BIT(2)
  81 #define  TERM_RANGE_ADJ(x)                      (((x) & 0xf) << 3)
  82 #define  RPD_CTRL(x)                            (((x) & 0x1f) << 26)
  83
  84 #define XUSB_PADCTL_USB2_BIAS_PAD_CTL0          0x284
  85 #define  BIAS_PAD_PD                            BIT(11)
  86 #define  HS_SQUELCH_LEVEL(x)                    (((x) & 0x7) << 0)
  87
  88 #define XUSB_PADCTL_USB2_BIAS_PAD_CTL1          0x288
  89 #define  USB2_TRK_START_TIMER(x)                (((x) & 0x7f) << 12)
  90 #define  USB2_TRK_DONE_RESET_TIMER(x)           (((x) & 0x7f) << 19)
  91 #define  USB2_PD_TRK                            BIT(26)
  92
  93 #define XUSB_PADCTL_HSIC_PADX_CTL0(x)           (0x300 + (x) * 0x20)
  94 #define  HSIC_PD_TX_DATA0                       BIT(1)
  95 #define  HSIC_PD_TX_STROBE                      BIT(3)
  96 #define  HSIC_PD_RX_DATA0                       BIT(4)
  97 #define  HSIC_PD_RX_STROBE                      BIT(6)
  98 #define  HSIC_PD_ZI_DATA0                       BIT(7)
  99 #define  HSIC_PD_ZI_STROBE                      BIT(9)
 100 #define  HSIC_RPD_DATA0                         BIT(13)
 101 #define  HSIC_RPD_STROBE                        BIT(15)
 102 #define  HSIC_RPU_DATA0                         BIT(16)
 103 #define  HSIC_RPU_STROBE                        BIT(18)
 104
 105 #define XUSB_PADCTL_HSIC_PAD_TRK_CTL0           0x340
 106 #define  HSIC_TRK_START_TIMER(x)                (((x) & 0x7f) << 5)
 107 #define  HSIC_TRK_DONE_RESET_TIMER(x)           (((x) & 0x7f) << 12)
 108 #define  HSIC_PD_TRK                            BIT(19)
 109
 110 #define USB2_VBUS_ID                            0x360
 111 #define  VBUS_OVERRIDE                          BIT(14)
 112 #define  ID_OVERRIDE(x)                         (((x) & 0xf) << 18)
 113 #define  ID_OVERRIDE_FLOATING                   ID_OVERRIDE(8)
 114 #define  ID_OVERRIDE_GROUNDED                   ID_OVERRIDE(0)
 115
 116 /* XUSB AO registers */
 117 #define XUSB_AO_USB_DEBOUNCE_DEL                (0x4)
 118 #define   UHSIC_LINE_DEB_CNT(x)                 (((x) & 0xf) << 4)
 119 #define   UTMIP_LINE_DEB_CNT(x)                 ((x) & 0xf)
 120
 121 #define XUSB_AO_UTMIP_TRIGGERS(x)               (0x40 + (x) * 4)
 122 #define   CLR_WALK_PTR                          BIT(0)
 123 #define   CAP_CFG                               BIT(1)
 124 #define   CLR_WAKE_ALARM                        BIT(3)
 125
 126 #define XUSB_AO_UHSIC_TRIGGERS(x)               (0x60 + (x) * 4)
 127 #define   HSIC_CLR_WALK_PTR                     BIT(0)
 128 #define   HSIC_CLR_WAKE_ALARM                   BIT(3)
 129 #define   HSIC_CAP_CFG                          BIT(4)
 130
 131 #define XUSB_AO_UTMIP_SAVED_STATE(x)            (0x70 + (x) * 4)
 132 #define   SPEED(x)                              ((x) & 0x3)
 133 #define     UTMI_HS                             SPEED(0)
 134 #define     UTMI_FS                             SPEED(1)
 135 #define     UTMI_LS                             SPEED(2)
 136 #define     UTMI_RST                            SPEED(3)
 137
 138 #define XUSB_AO_UHSIC_SAVED_STATE(x)            (0x90 + (x) * 4)
 139 #define   MODE(x)                               ((x) & 0x1)
 140 #define   MODE_HS                               MODE(0)
 141 #define   MODE_RST                              MODE(1)
 142
 143 #define XUSB_AO_UTMIP_SLEEPWALK_CFG(x)          (0xd0 + (x) * 4)
 144 #define XUSB_AO_UHSIC_SLEEPWALK_CFG(x)          (0xf0 + (x) * 4)
 145 #define   FAKE_USBOP_VAL                        BIT(0)
 146 #define   FAKE_USBON_VAL                        BIT(1)
 147 #define   FAKE_USBOP_EN                         BIT(2)
 148 #define   FAKE_USBON_EN                         BIT(3)
 149 #define   FAKE_STROBE_VAL                       BIT(0)
 150 #define   FAKE_DATA_VAL                         BIT(1)
 151 #define   FAKE_STROBE_EN                        BIT(2)
 152 #define   FAKE_DATA_EN                          BIT(3)
 153 #define   WAKE_WALK_EN                          BIT(14)
 154 #define   MASTER_ENABLE                         BIT(15)
 155 #define   LINEVAL_WALK_EN                       BIT(16)
 156 #define   WAKE_VAL(x)                           (((x) & 0xf) << 17)
 157 #define     WAKE_VAL_NONE                       WAKE_VAL(12)
 158 #define     WAKE_VAL_ANY                        WAKE_VAL(15)
 159 #define     WAKE_VAL_DS10                       WAKE_VAL(2)
 160 #define   LINE_WAKEUP_EN                        BIT(21)
 161 #define   MASTER_CFG_SEL                        BIT(22)
 162
 163 #define XUSB_AO_UTMIP_SLEEPWALK(x)              (0x100 + (x) * 4)
 164 /* phase A */
 165 #define   USBOP_RPD_A                           BIT(0)
 166 #define   USBON_RPD_A                           BIT(1)
 167 #define   AP_A                                  BIT(4)
 168 #define   AN_A                                  BIT(5)
 169 #define   HIGHZ_A                               BIT(6)
 170 /* phase B */
 171 #define   USBOP_RPD_B                           BIT(8)
 172 #define   USBON_RPD_B                           BIT(9)
 173 #define   AP_B                                  BIT(12)
 174 #define   AN_B                                  BIT(13)
 175 #define   HIGHZ_B                               BIT(14)
 176 /* phase C */
 177 #define   USBOP_RPD_C                           BIT(16)
 178 #define   USBON_RPD_C                           BIT(17)
 179 #define   AP_C                                  BIT(20)
 180 #define   AN_C                                  BIT(21)
 181 #define   HIGHZ_C                               BIT(22)
 182 /* phase D */
 183 #define   USBOP_RPD_D                           BIT(24)
 184 #define   USBON_RPD_D                           BIT(25)
 185 #define   AP_D                                  BIT(28)
 186 #define   AN_D                                  BIT(29)
 187 #define   HIGHZ_D                               BIT(30)
 188
 189 #define XUSB_AO_UHSIC_SLEEPWALK(x)              (0x120 + (x) * 4)
 190 /* phase A */
 191 #define   RPD_STROBE_A                          BIT(0)
 192 #define   RPD_DATA0_A                           BIT(1)
 193 #define   RPU_STROBE_A                          BIT(2)
 194 #define   RPU_DATA0_A                           BIT(3)
 195 /* phase B */
 196 #define   RPD_STROBE_B                          BIT(8)
 197 #define   RPD_DATA0_B                           BIT(9)
 198 #define   RPU_STROBE_B                          BIT(10)
 199 #define   RPU_DATA0_B                           BIT(11)
 200 /* phase C */
 201 #define   RPD_STROBE_C                          BIT(16)
 202 #define   RPD_DATA0_C                           BIT(17)
 203 #define   RPU_STROBE_C                          BIT(18)
 204 #define   RPU_DATA0_C                           BIT(19)
 205 /* phase D */
 206 #define   RPD_STROBE_D                          BIT(24)
 207 #define   RPD_DATA0_D                           BIT(25)
 208 #define   RPU_STROBE_D                          BIT(26)
 209 #define   RPU_DATA0_D                           BIT(27)
 210
 211 #define XUSB_AO_UTMIP_PAD_CFG(x)                (0x130 + (x) * 4)
 212 #define   FSLS_USE_XUSB_AO                      BIT(3)
 213 #define   TRK_CTRL_USE_XUSB_AO                  BIT(4)
 214 #define   RPD_CTRL_USE_XUSB_AO                  BIT(5)
 215 #define   RPU_USE_XUSB_AO                       BIT(6)
 216 #define   VREG_USE_XUSB_AO                      BIT(7)
 217 #define   USBOP_VAL_PD                          BIT(8)
 218 #define   USBON_VAL_PD                          BIT(9)
 219 #define   E_DPD_OVRD_EN                         BIT(10)
 220 #define   E_DPD_OVRD_VAL                        BIT(11)
 221
 222 #define XUSB_AO_UHSIC_PAD_CFG(x)                (0x150 + (x) * 4)
 223 #define   STROBE_VAL_PD                         BIT(0)
 224 #define   DATA0_VAL_PD                          BIT(1)
 225 #define   USE_XUSB_AO                           BIT(4)
 226
 227 #define TEGRA186_LANE(_name, _offset, _shift, _mask, _type)             \
 228         {                                                               \
 229                 .name = _name,                                          \
 230                 .offset = _offset,                                      \
 231                 .shift = _shift,                                        \
 232                 .mask = _mask,                                          \
 233                 .num_funcs = ARRAY_SIZE(tegra186_##_type##_functions),  \
 234                 .funcs = tegra186_##_type##_functions,                  \
 235         }
 236
 237 struct tegra_xusb_fuse_calibration {
 238         u32 *hs_curr_level;
 239         u32 hs_squelch;
 240         u32 hs_term_range_adj;
 241         u32 rpd_ctrl;
 242 };
 243
 244 struct tegra186_xusb_padctl_context {
 245         u32 vbus_id;
 246         u32 usb2_pad_mux;
 247         u32 usb2_port_cap;
 248         u32 ss_port_cap;
 249 };
 250
 251 struct tegra186_xusb_padctl {
 252         struct tegra_xusb_padctl base;
 253         void __iomem *ao_regs;
 254
 255         struct tegra_xusb_fuse_calibration calib;
 256
 257         /* UTMI bias and tracking */
 258         struct clk *usb2_trk_clk;
 259         unsigned int bias_pad_enable;
 260
 261         /* padctl context */
 262         struct tegra186_xusb_padctl_context context;
 263 };
 264
 265 static inline void ao_writel(struct tegra186_xusb_padctl *priv, u32 value, unsigned int offset)
 266 {
 267         writel(value, priv->ao_regs + offset);
 268 }
 269
 270 static inline u32 ao_readl(struct tegra186_xusb_padctl *priv, unsigned int offset)
 271 {
 272         return readl(priv->ao_regs + offset);
 273 }
 274
 275 static inline struct tegra186_xusb_padctl *
 276 to_tegra186_xusb_padctl(struct tegra_xusb_padctl *padctl)
 277 {
 278         return container_of(padctl, struct tegra186_xusb_padctl, base);
 279 }
 280
 281 /* USB 2.0 UTMI PHY support */
 282 static struct tegra_xusb_lane *
 283 tegra186_usb2_lane_probe(struct tegra_xusb_pad *pad, struct device_node *np,
 284                          unsigned int index)
 285 {
 286         struct tegra_xusb_usb2_lane *usb2;
 287         int err;
 288
 289         usb2 = kzalloc(sizeof(*usb2), GFP_KERNEL);
 290         if (!usb2)
 291                 return ERR_PTR(-ENOMEM);
 292
 293         INIT_LIST_HEAD(&usb2->base.list);
 294         usb2->base.soc = &pad->soc->lanes[index];
 295         usb2->base.index = index;
 296         usb2->base.pad = pad;
 297         usb2->base.np = np;
 298
 299         err = tegra_xusb_lane_parse_dt(&usb2->base, np);
 300         if (err < 0) {
 301                 kfree(usb2);
 302                 return ERR_PTR(err);
 303         }
 304
 305         return &usb2->base;
 306 }
 307
 308 static void tegra186_usb2_lane_remove(struct tegra_xusb_lane *lane)
 309 {
 310         struct tegra_xusb_usb2_lane *usb2 = to_usb2_lane(lane);
 311
 312         kfree(usb2);
 313 }
 314
 315 static int tegra186_utmi_enable_phy_sleepwalk(struct tegra_xusb_lane *lane,
 316                                               enum usb_device_speed speed)
 317 {
 318         struct tegra_xusb_padctl *padctl = lane->pad->padctl;
 319         struct tegra186_xusb_padctl *priv = to_tegra186_xusb_padctl(padctl);
 320         unsigned int index = lane->index;
 321         u32 value;
 322
 323         mutex_lock(&padctl->lock);
 324
 325         /* ensure sleepwalk logic is disabled */
 326         value = ao_readl(priv, XUSB_AO_UTMIP_SLEEPWALK_CFG(index));
 327         value &= ~MASTER_ENABLE;
 328         ao_writel(priv, value, XUSB_AO_UTMIP_SLEEPWALK_CFG(index));
 329
 330         /* ensure sleepwalk logics are in low power mode */
 331         value = ao_readl(priv, XUSB_AO_UTMIP_SLEEPWALK_CFG(index));
 332         value |= MASTER_CFG_SEL;
 333         ao_writel(priv, value, XUSB_AO_UTMIP_SLEEPWALK_CFG(index));
 334
 335         /* set debounce time */
 336         value = ao_readl(priv, XUSB_AO_USB_DEBOUNCE_DEL);
 337         value &= ~UTMIP_LINE_DEB_CNT(~0);
 338         value |= UTMIP_LINE_DEB_CNT(1);
 339         ao_writel(priv, value, XUSB_AO_USB_DEBOUNCE_DEL);
 340
 341         /* ensure fake events of sleepwalk logic are desiabled */
 342         value = ao_readl(priv, XUSB_AO_UTMIP_SLEEPWALK_CFG(index));
 343         value &= ~(FAKE_USBOP_VAL | FAKE_USBON_VAL |
 344                 FAKE_USBOP_EN | FAKE_USBON_EN);
 345         ao_writel(priv, value, XUSB_AO_UTMIP_SLEEPWALK_CFG(index));
 346
 347         /* ensure wake events of sleepwalk logic are not latched */
 348         value = ao_readl(priv, XUSB_AO_UTMIP_SLEEPWALK_CFG(index));
 349         value &= ~LINE_WAKEUP_EN;
 350         ao_writel(priv, value, XUSB_AO_UTMIP_SLEEPWALK_CFG(index));
 351
 352         /* disable wake event triggers of sleepwalk logic */
 353         value = ao_readl(priv, XUSB_AO_UTMIP_SLEEPWALK_CFG(index));
 354         value &= ~WAKE_VAL(~0);
 355         value |= WAKE_VAL_NONE;
 356         ao_writel(priv, value, XUSB_AO_UTMIP_SLEEPWALK_CFG(index));
 357
 358         /* power down the line state detectors of the pad */
 359         value = ao_readl(priv, XUSB_AO_UTMIP_PAD_CFG(index));
 360         value |= (USBOP_VAL_PD | USBON_VAL_PD);
 361         ao_writel(priv, value, XUSB_AO_UTMIP_PAD_CFG(index));
 362
 363         /* save state per speed */
 364         value = ao_readl(priv, XUSB_AO_UTMIP_SAVED_STATE(index));
 365         value &= ~SPEED(~0);
 366
 367         switch (speed) {
 368         case USB_SPEED_HIGH:
 369                 value |= UTMI_HS;
 370                 break;
 371
 372         case USB_SPEED_FULL:
 373                 value |= UTMI_FS;
 374                 break;
 375
 376         case USB_SPEED_LOW:
 377                 value |= UTMI_LS;
 378                 break;
 379
 380         default:
 381                 value |= UTMI_RST;
 382                 break;
 383         }
 384
 385         ao_writel(priv, value, XUSB_AO_UTMIP_SAVED_STATE(index));
 386
 387         /* enable the trigger of the sleepwalk logic */
 388         value = ao_readl(priv, XUSB_AO_UTMIP_SLEEPWALK_CFG(index));
 389         value |= LINEVAL_WALK_EN;
 390         value &= ~WAKE_WALK_EN;
 391         ao_writel(priv, value, XUSB_AO_UTMIP_SLEEPWALK_CFG(index));
 392
 393         /* reset the walk pointer and clear the alarm of the sleepwalk logic,
 394          * as well as capture the configuration of the USB2.0 pad
 395          */
 396         value = ao_readl(priv, XUSB_AO_UTMIP_TRIGGERS(index));
 397         value |= (CLR_WALK_PTR | CLR_WAKE_ALARM | CAP_CFG);
 398         ao_writel(priv, value, XUSB_AO_UTMIP_TRIGGERS(index));
 399
 400         /* setup the pull-ups and pull-downs of the signals during the four
 401          * stages of sleepwalk.
 402          * if device is connected, program sleepwalk logic to maintain a J and
 403          * keep driving K upon seeing remote wake.
 404          */
 405         value = USBOP_RPD_A | USBOP_RPD_B | USBOP_RPD_C | USBOP_RPD_D;
 406         value |= USBON_RPD_A | USBON_RPD_B | USBON_RPD_C | USBON_RPD_D;
 407
 408         switch (speed) {
 409         case USB_SPEED_HIGH:
 410         case USB_SPEED_FULL:
 411                 /* J state: D+/D- = high/low, K state: D+/D- = low/high */
 412                 value |= HIGHZ_A;
 413                 value |= AP_A;
 414                 value |= AN_B | AN_C | AN_D;
 415                 break;
 416
 417         case USB_SPEED_LOW:
 418                 /* J state: D+/D- = low/high, K state: D+/D- = high/low */
 419                 value |= HIGHZ_A;
 420                 value |= AN_A;
 421                 value |= AP_B | AP_C | AP_D;
 422                 break;
 423
 424         default:
 425                 value |= HIGHZ_A | HIGHZ_B | HIGHZ_C | HIGHZ_D;
 426                 break;
 427         }
 428
 429         ao_writel(priv, value, XUSB_AO_UTMIP_SLEEPWALK(index));
 430
 431         /* power up the line state detectors of the pad */
 432         value = ao_readl(priv, XUSB_AO_UTMIP_PAD_CFG(index));
 433         value &= ~(USBOP_VAL_PD | USBON_VAL_PD);
 434         ao_writel(priv, value, XUSB_AO_UTMIP_PAD_CFG(index));
 435
 436         usleep_range(150, 200);
 437
 438         /* switch the electric control of the USB2.0 pad to XUSB_AO */
 439         value = ao_readl(priv, XUSB_AO_UTMIP_PAD_CFG(index));
 440         value |= FSLS_USE_XUSB_AO | TRK_CTRL_USE_XUSB_AO | RPD_CTRL_USE_XUSB_AO |
 441                  RPU_USE_XUSB_AO | VREG_USE_XUSB_AO;
 442         ao_writel(priv, value, XUSB_AO_UTMIP_PAD_CFG(index));
 443
 444         /* set the wake signaling trigger events */
 445         value = ao_readl(priv, XUSB_AO_UTMIP_SLEEPWALK_CFG(index));
 446         value &= ~WAKE_VAL(~0);
 447         value |= WAKE_VAL_ANY;
 448         ao_writel(priv, value, XUSB_AO_UTMIP_SLEEPWALK_CFG(index));
 449
 450         /* enable the wake detection */
 451         value = ao_readl(priv, XUSB_AO_UTMIP_SLEEPWALK_CFG(index));
 452         value |= MASTER_ENABLE | LINE_WAKEUP_EN;
 453         ao_writel(priv, value, XUSB_AO_UTMIP_SLEEPWALK_CFG(index));
 454
 455         mutex_unlock(&padctl->lock);
 456
 457         return 0;
 458 }
 459
 460 static int tegra186_utmi_disable_phy_sleepwalk(struct tegra_xusb_lane *lane)
 461 {
 462         struct tegra_xusb_padctl *padctl = lane->pad->padctl;
 463         struct tegra186_xusb_padctl *priv = to_tegra186_xusb_padctl(padctl);
 464         unsigned int index = lane->index;
 465         u32 value;
 466
 467         mutex_lock(&padctl->lock);
 468
 469         /* disable the wake detection */
 470         value = ao_readl(priv, XUSB_AO_UTMIP_SLEEPWALK_CFG(index));
 471         value &= ~(MASTER_ENABLE | LINE_WAKEUP_EN);
 472         ao_writel(priv, value, XUSB_AO_UTMIP_SLEEPWALK_CFG(index));
 473
 474         /* switch the electric control of the USB2.0 pad to XUSB vcore logic */
 475         value = ao_readl(priv, XUSB_AO_UTMIP_PAD_CFG(index));
 476         value &= ~(FSLS_USE_XUSB_AO | TRK_CTRL_USE_XUSB_AO | RPD_CTRL_USE_XUSB_AO |
 477                    RPU_USE_XUSB_AO | VREG_USE_XUSB_AO);
 478         ao_writel(priv, value, XUSB_AO_UTMIP_PAD_CFG(index));
 479
 480         /* disable wake event triggers of sleepwalk logic */
 481         value = ao_readl(priv, XUSB_AO_UTMIP_SLEEPWALK_CFG(index));
 482         value &= ~WAKE_VAL(~0);
 483         value |= WAKE_VAL_NONE;
 484         ao_writel(priv, value, XUSB_AO_UTMIP_SLEEPWALK_CFG(index));
 485
 486         /* power down the line state detectors of the port */
 487         value = ao_readl(priv, XUSB_AO_UTMIP_PAD_CFG(index));
 488         value |= USBOP_VAL_PD | USBON_VAL_PD;
 489         ao_writel(priv, value, XUSB_AO_UTMIP_PAD_CFG(index));
 490
 491         /* clear alarm of the sleepwalk logic */
 492         value = ao_readl(priv, XUSB_AO_UTMIP_TRIGGERS(index));
 493         value |= CLR_WAKE_ALARM;
 494         ao_writel(priv, value, XUSB_AO_UTMIP_TRIGGERS(index));
 495
 496         mutex_unlock(&padctl->lock);
 497
 498         return 0;
 499 }
 500
 501 static int tegra186_utmi_enable_phy_wake(struct tegra_xusb_lane *lane)
 502 {
 503         struct tegra_xusb_padctl *padctl = lane->pad->padctl;
 504         unsigned int index = lane->index;
 505         u32 value;
 506
 507         mutex_lock(&padctl->lock);
 508
 509         value = padctl_readl(padctl, XUSB_PADCTL_ELPG_PROGRAM);
 510         value &= ~ALL_WAKE_EVENTS;
 511         value |= USB2_PORT_WAKEUP_EVENT(index);
 512         padctl_writel(padctl, value, XUSB_PADCTL_ELPG_PROGRAM);
 513
 514         usleep_range(10, 20);
 515
 516         value = padctl_readl(padctl, XUSB_PADCTL_ELPG_PROGRAM);
 517         value &= ~ALL_WAKE_EVENTS;
 518         value |= USB2_PORT_WAKE_INTERRUPT_ENABLE(index);
 519         padctl_writel(padctl, value, XUSB_PADCTL_ELPG_PROGRAM);
 520
 521         mutex_unlock(&padctl->lock);
 522
 523         return 0;
 524 }
 525
 526 static int tegra186_utmi_disable_phy_wake(struct tegra_xusb_lane *lane)
 527 {
 528         struct tegra_xusb_padctl *padctl = lane->pad->padctl;
 529         unsigned int index = lane->index;
 530         u32 value;
 531
 532         mutex_lock(&padctl->lock);
 533
 534         value = padctl_readl(padctl, XUSB_PADCTL_ELPG_PROGRAM);
 535         value &= ~ALL_WAKE_EVENTS;
 536         value &= ~USB2_PORT_WAKE_INTERRUPT_ENABLE(index);
 537         padctl_writel(padctl, value, XUSB_PADCTL_ELPG_PROGRAM);
 538
 539         usleep_range(10, 20);
 540
 541         value = padctl_readl(padctl, XUSB_PADCTL_ELPG_PROGRAM);
 542         value &= ~ALL_WAKE_EVENTS;
 543         value |= USB2_PORT_WAKEUP_EVENT(index);
 544         padctl_writel(padctl, value, XUSB_PADCTL_ELPG_PROGRAM);
 545
 546         mutex_unlock(&padctl->lock);
 547
 548         return 0;
 549 }
 550
 551 static bool tegra186_utmi_phy_remote_wake_detected(struct tegra_xusb_lane *lane)
 552 {
 553         struct tegra_xusb_padctl *padctl = lane->pad->padctl;
 554         unsigned int index = lane->index;
 555         u32 value;
 556
 557         value = padctl_readl(padctl, XUSB_PADCTL_ELPG_PROGRAM);
 558         if ((value & USB2_PORT_WAKE_INTERRUPT_ENABLE(index)) &&
 559             (value & USB2_PORT_WAKEUP_EVENT(index)))
 560                 return true;
 561
 562         return false;
 563 }
 564
 565 static const struct tegra_xusb_lane_ops tegra186_usb2_lane_ops = {
 566         .probe = tegra186_usb2_lane_probe,
 567         .remove = tegra186_usb2_lane_remove,
 568         .enable_phy_sleepwalk = tegra186_utmi_enable_phy_sleepwalk,
 569         .disable_phy_sleepwalk = tegra186_utmi_disable_phy_sleepwalk,
 570         .enable_phy_wake = tegra186_utmi_enable_phy_wake,
 571         .disable_phy_wake = tegra186_utmi_disable_phy_wake,
 572         .remote_wake_detected = tegra186_utmi_phy_remote_wake_detected,
 573 };
 574
 575 static void tegra186_utmi_bias_pad_power_on(struct tegra_xusb_padctl *padctl)
 576 {
 577         struct tegra186_xusb_padctl *priv = to_tegra186_xusb_padctl(padctl);
 578         struct device *dev = padctl->dev;
 579         u32 value;
 580         int err;
 581
 582         mutex_lock(&padctl->lock);
 583
 584         if (priv->bias_pad_enable++ > 0) {
 585                 mutex_unlock(&padctl->lock);
 586                 return;
 587         }
 588
 589         err = clk_prepare_enable(priv->usb2_trk_clk);
 590         if (err < 0)
 591                 dev_warn(dev, "failed to enable USB2 trk clock: %d\n", err);
 592
 593         value = padctl_readl(padctl, XUSB_PADCTL_USB2_BIAS_PAD_CTL1);
 594         value &= ~USB2_TRK_START_TIMER(~0);
 595         value |= USB2_TRK_START_TIMER(0x1e);
 596         value &= ~USB2_TRK_DONE_RESET_TIMER(~0);
 597         value |= USB2_TRK_DONE_RESET_TIMER(0xa);
 598         padctl_writel(padctl, value, XUSB_PADCTL_USB2_BIAS_PAD_CTL1);
 599
 600         value = padctl_readl(padctl, XUSB_PADCTL_USB2_BIAS_PAD_CTL0);
 601         value &= ~BIAS_PAD_PD;
 602         value &= ~HS_SQUELCH_LEVEL(~0);
 603         value |= HS_SQUELCH_LEVEL(priv->calib.hs_squelch);
 604         padctl_writel(padctl, value, XUSB_PADCTL_USB2_BIAS_PAD_CTL0);
 605
 606         udelay(1);
 607
 608         value = padctl_readl(padctl, XUSB_PADCTL_USB2_BIAS_PAD_CTL1);
 609         value &= ~USB2_PD_TRK;
 610         padctl_writel(padctl, value, XUSB_PADCTL_USB2_BIAS_PAD_CTL1);
 611
 612         mutex_unlock(&padctl->lock);
 613 }
 614
 615 static void tegra186_utmi_bias_pad_power_off(struct tegra_xusb_padctl *padctl)
 616 {
 617         struct tegra186_xusb_padctl *priv = to_tegra186_xusb_padctl(padctl);
 618         u32 value;
 619
 620         mutex_lock(&padctl->lock);
 621
 622         if (WARN_ON(priv->bias_pad_enable == 0)) {
 623                 mutex_unlock(&padctl->lock);
 624                 return;
 625         }
 626
 627         if (--priv->bias_pad_enable > 0) {
 628                 mutex_unlock(&padctl->lock);
 629                 return;
 630         }
 631
 632         value = padctl_readl(padctl, XUSB_PADCTL_USB2_BIAS_PAD_CTL1);
 633         value |= USB2_PD_TRK;
 634         padctl_writel(padctl, value, XUSB_PADCTL_USB2_BIAS_PAD_CTL1);
 635
 636         clk_disable_unprepare(priv->usb2_trk_clk);
 637
 638         mutex_unlock(&padctl->lock);
 639 }
 640
 641 static void tegra186_utmi_pad_power_on(struct phy *phy)
 642 {
 643         struct tegra_xusb_lane *lane = phy_get_drvdata(phy);
 644         struct tegra_xusb_padctl *padctl = lane->pad->padctl;
 645         struct tegra_xusb_usb2_port *port;
 646         struct device *dev = padctl->dev;
 647         unsigned int index = lane->index;
 648         u32 value;
 649
 650         if (!phy)
 651                 return;
 652
 653         port = tegra_xusb_find_usb2_port(padctl, index);
 654         if (!port) {
 655                 dev_err(dev, "no port found for USB2 lane %u\n", index);
 656                 return;
 657         }
 658
 659         dev_dbg(dev, "power on UTMI pad %u\n", index);
 660
 661         tegra186_utmi_bias_pad_power_on(padctl);
 662
 663         udelay(2);
 664
 665         value = padctl_readl(padctl, XUSB_PADCTL_USB2_OTG_PADX_CTL0(index));
 666         value &= ~USB2_OTG_PD;
 667         padctl_writel(padctl, value, XUSB_PADCTL_USB2_OTG_PADX_CTL0(index));
 668
 669         value = padctl_readl(padctl, XUSB_PADCTL_USB2_OTG_PADX_CTL1(index));
 670         value &= ~USB2_OTG_PD_DR;
 671         padctl_writel(padctl, value, XUSB_PADCTL_USB2_OTG_PADX_CTL1(index));
 672 }
 673
 674 static void tegra186_utmi_pad_power_down(struct phy *phy)
 675 {
 676         struct tegra_xusb_lane *lane = phy_get_drvdata(phy);
 677         struct tegra_xusb_padctl *padctl = lane->pad->padctl;
 678         unsigned int index = lane->index;
 679         u32 value;
 680
 681         if (!phy)
 682                 return;
 683
 684         dev_dbg(padctl->dev, "power down UTMI pad %u\n", index);
 685
 686         value = padctl_readl(padctl, XUSB_PADCTL_USB2_OTG_PADX_CTL0(index));
 687         value |= USB2_OTG_PD;
 688         padctl_writel(padctl, value, XUSB_PADCTL_USB2_OTG_PADX_CTL0(index));
 689
 690         value = padctl_readl(padctl, XUSB_PADCTL_USB2_OTG_PADX_CTL1(index));
 691         value |= USB2_OTG_PD_DR;
 692         padctl_writel(padctl, value, XUSB_PADCTL_USB2_OTG_PADX_CTL1(index));
 693
 694         udelay(2);
 695
 696         tegra186_utmi_bias_pad_power_off(padctl);
 697 }
 698
 699 static int tegra186_xusb_padctl_vbus_override(struct tegra_xusb_padctl *padctl,
 700                                                bool status)
 701 {
 702         u32 value;
 703
 704         dev_dbg(padctl->dev, "%s vbus override\n", status ? "set" : "clear");
 705
 706         value = padctl_readl(padctl, USB2_VBUS_ID);
 707
 708         if (status) {
 709                 value |= VBUS_OVERRIDE;
 710                 value &= ~ID_OVERRIDE(~0);
 711                 value |= ID_OVERRIDE_FLOATING;
 712         } else {
 713                 value &= ~VBUS_OVERRIDE;
 714         }
 715
 716         padctl_writel(padctl, value, USB2_VBUS_ID);
 717
 718         return 0;
 719 }
 720
 721 static int tegra186_xusb_padctl_id_override(struct tegra_xusb_padctl *padctl,
 722                                             bool status)
 723 {
 724         u32 value;
 725
 726         dev_dbg(padctl->dev, "%s id override\n", status ? "set" : "clear");
 727
 728         value = padctl_readl(padctl, USB2_VBUS_ID);
 729
 730         if (status) {
 731                 if (value & VBUS_OVERRIDE) {
 732                         value &= ~VBUS_OVERRIDE;
 733                         padctl_writel(padctl, value, USB2_VBUS_ID);
 734                         usleep_range(1000, 2000);
 735
 736                         value = padctl_readl(padctl, USB2_VBUS_ID);
 737                 }
 738
 739                 value &= ~ID_OVERRIDE(~0);
 740                 value |= ID_OVERRIDE_GROUNDED;
 741         } else {
 742                 value &= ~ID_OVERRIDE(~0);
 743                 value |= ID_OVERRIDE_FLOATING;
 744         }
 745
 746         padctl_writel(padctl, value, USB2_VBUS_ID);
 747
 748         return 0;
 749 }
 750
 751 static int tegra186_utmi_phy_set_mode(struct phy *phy, enum phy_mode mode,
 752                                       int submode)
 753 {
 754         struct tegra_xusb_lane *lane = phy_get_drvdata(phy);
 755         struct tegra_xusb_padctl *padctl = lane->pad->padctl;
 756         struct tegra_xusb_usb2_port *port = tegra_xusb_find_usb2_port(padctl,
 757                                                                 lane->index);
 758         int err = 0;
 759
 760         mutex_lock(&padctl->lock);
 761
 762         dev_dbg(&port->base.dev, "%s: mode %d", __func__, mode);
 763
 764         if (mode == PHY_MODE_USB_OTG) {
 765                 if (submode == USB_ROLE_HOST) {
 766                         tegra186_xusb_padctl_id_override(padctl, true);
 767
 768                         err = regulator_enable(port->supply);
 769                 } else if (submode == USB_ROLE_DEVICE) {
 770                         tegra186_xusb_padctl_vbus_override(padctl, true);
 771                 } else if (submode == USB_ROLE_NONE) {
 772                         /*
 773                          * When port is peripheral only or role transitions to
 774                          * USB_ROLE_NONE from USB_ROLE_DEVICE, regulator is not
 775                          * enabled.
 776                          */
 777                         if (regulator_is_enabled(port->supply))
 778                                 regulator_disable(port->supply);
 779
 780                         tegra186_xusb_padctl_id_override(padctl, false);
 781                         tegra186_xusb_padctl_vbus_override(padctl, false);
 782                 }
 783         }
 784
 785         mutex_unlock(&padctl->lock);
 786
 787         return err;
 788 }
 789
 790 static int tegra186_utmi_phy_power_on(struct phy *phy)
 791 {
 792         struct tegra_xusb_lane *lane = phy_get_drvdata(phy);
 793         struct tegra_xusb_usb2_lane *usb2 = to_usb2_lane(lane);
 794         struct tegra_xusb_padctl *padctl = lane->pad->padctl;
 795         struct tegra186_xusb_padctl *priv = to_tegra186_xusb_padctl(padctl);
 796         struct tegra_xusb_usb2_port *port;
 797         unsigned int index = lane->index;
 798         struct device *dev = padctl->dev;
 799         u32 value;
 800
 801         port = tegra_xusb_find_usb2_port(padctl, index);
 802         if (!port) {
 803                 dev_err(dev, "no port found for USB2 lane %u\n", index);
 804                 return -ENODEV;
 805         }
 806
 807         value = padctl_readl(padctl, XUSB_PADCTL_USB2_PAD_MUX);
 808         value &= ~(USB2_PORT_MASK << USB2_PORT_SHIFT(index));
 809         value |= (PORT_XUSB << USB2_PORT_SHIFT(index));
 810         padctl_writel(padctl, value, XUSB_PADCTL_USB2_PAD_MUX);
 811
 812         value = padctl_readl(padctl, XUSB_PADCTL_USB2_PORT_CAP);
 813         value &= ~(PORT_CAP_MASK << PORTX_CAP_SHIFT(index));
 814
 815         if (port->mode == USB_DR_MODE_UNKNOWN)
 816                 value |= (PORT_CAP_DISABLED << PORTX_CAP_SHIFT(index));
 817         else if (port->mode == USB_DR_MODE_PERIPHERAL)
 818                 value |= (PORT_CAP_DEVICE << PORTX_CAP_SHIFT(index));
 819         else if (port->mode == USB_DR_MODE_HOST)
 820                 value |= (PORT_CAP_HOST << PORTX_CAP_SHIFT(index));
 821         else if (port->mode == USB_DR_MODE_OTG)
 822                 value |= (PORT_CAP_OTG << PORTX_CAP_SHIFT(index));
 823
 824         padctl_writel(padctl, value, XUSB_PADCTL_USB2_PORT_CAP);
 825
 826         value = padctl_readl(padctl, XUSB_PADCTL_USB2_OTG_PADX_CTL0(index));
 827         value &= ~USB2_OTG_PD_ZI;
 828         value |= TERM_SEL;
 829         value &= ~HS_CURR_LEVEL(~0);
 830
 831         if (usb2->hs_curr_level_offset) {
 832                 int hs_current_level;
 833
 834                 hs_current_level = (int)priv->calib.hs_curr_level[index] +
 835                                                 usb2->hs_curr_level_offset;
 836
 837                 if (hs_current_level < 0)
 838                         hs_current_level = 0;
 839                 if (hs_current_level > 0x3f)
 840                         hs_current_level = 0x3f;
 841
 842                 value |= HS_CURR_LEVEL(hs_current_level);
 843         } else {
 844                 value |= HS_CURR_LEVEL(priv->calib.hs_curr_level[index]);
 845         }
 846
 847         padctl_writel(padctl, value, XUSB_PADCTL_USB2_OTG_PADX_CTL0(index));
 848
 849         value = padctl_readl(padctl, XUSB_PADCTL_USB2_OTG_PADX_CTL1(index));
 850         value &= ~TERM_RANGE_ADJ(~0);
 851         value |= TERM_RANGE_ADJ(priv->calib.hs_term_range_adj);
 852         value &= ~RPD_CTRL(~0);
 853         value |= RPD_CTRL(priv->calib.rpd_ctrl);
 854         padctl_writel(padctl, value, XUSB_PADCTL_USB2_OTG_PADX_CTL1(index));
 855
 856         tegra186_utmi_pad_power_on(phy);
 857
 858         return 0;
 859 }
 860
 861 static int tegra186_utmi_phy_power_off(struct phy *phy)
 862 {
 863         tegra186_utmi_pad_power_down(phy);
 864
 865         return 0;
 866 }
 867
 868 static int tegra186_utmi_phy_init(struct phy *phy)
 869 {
 870         struct tegra_xusb_lane *lane = phy_get_drvdata(phy);
 871         struct tegra_xusb_padctl *padctl = lane->pad->padctl;
 872         struct tegra_xusb_usb2_port *port;
 873         unsigned int index = lane->index;
 874         struct device *dev = padctl->dev;
 875         int err;
 876
 877         port = tegra_xusb_find_usb2_port(padctl, index);
 878         if (!port) {
 879                 dev_err(dev, "no port found for USB2 lane %u\n", index);
 880                 return -ENODEV;
 881         }
 882
 883         if (port->supply && port->mode == USB_DR_MODE_HOST) {
 884                 err = regulator_enable(port->supply);
 885                 if (err) {
 886                         dev_err(dev, "failed to enable port %u VBUS: %d\n",
 887                                 index, err);
 888                         return err;
 889                 }
 890         }
 891
 892         return 0;
 893 }
 894
 895 static int tegra186_utmi_phy_exit(struct phy *phy)
 896 {
 897         struct tegra_xusb_lane *lane = phy_get_drvdata(phy);
 898         struct tegra_xusb_padctl *padctl = lane->pad->padctl;
 899         struct tegra_xusb_usb2_port *port;
 900         unsigned int index = lane->index;
 901         struct device *dev = padctl->dev;
 902         int err;
 903
 904         port = tegra_xusb_find_usb2_port(padctl, index);
 905         if (!port) {
 906                 dev_err(dev, "no port found for USB2 lane %u\n", index);
 907                 return -ENODEV;
 908         }
 909
 910         if (port->supply && port->mode == USB_DR_MODE_HOST) {
 911                 err = regulator_disable(port->supply);
 912                 if (err) {
 913                         dev_err(dev, "failed to disable port %u VBUS: %d\n",
 914                                 index, err);
 915                         return err;
 916                 }
 917         }
 918
 919         return 0;
 920 }
 921
 922 static const struct phy_ops utmi_phy_ops = {
 923         .init = tegra186_utmi_phy_init,
 924         .exit = tegra186_utmi_phy_exit,
 925         .power_on = tegra186_utmi_phy_power_on,
 926         .power_off = tegra186_utmi_phy_power_off,
 927         .set_mode = tegra186_utmi_phy_set_mode,
 928         .owner = THIS_MODULE,
 929 };
 930
 931 static struct tegra_xusb_pad *
 932 tegra186_usb2_pad_probe(struct tegra_xusb_padctl *padctl,
 933                         const struct tegra_xusb_pad_soc *soc,
 934                         struct device_node *np)
 935 {
 936         struct tegra186_xusb_padctl *priv = to_tegra186_xusb_padctl(padctl);
 937         struct tegra_xusb_usb2_pad *usb2;
 938         struct tegra_xusb_pad *pad;
 939         int err;
 940
 941         usb2 = kzalloc(sizeof(*usb2), GFP_KERNEL);
 942         if (!usb2)
 943                 return ERR_PTR(-ENOMEM);
 944
 945         pad = &usb2->base;
 946         pad->ops = &tegra186_usb2_lane_ops;
 947         pad->soc = soc;
 948
 949         err = tegra_xusb_pad_init(pad, padctl, np);
 950         if (err < 0) {
 951                 kfree(usb2);
 952                 goto out;
 953         }
 954
 955         priv->usb2_trk_clk = devm_clk_get(&pad->dev, "trk");
 956         if (IS_ERR(priv->usb2_trk_clk)) {
 957                 err = PTR_ERR(priv->usb2_trk_clk);
 958                 dev_dbg(&pad->dev, "failed to get usb2 trk clock: %d\n", err);
 959                 goto unregister;
 960         }
 961
 962         err = tegra_xusb_pad_register(pad, &utmi_phy_ops);
 963         if (err < 0)
 964                 goto unregister;
 965
 966         dev_set_drvdata(&pad->dev, pad);
 967
 968         return pad;
 969
 970 unregister:
 971         device_unregister(&pad->dev);
 972 out:
 973         return ERR_PTR(err);
 974 }
 975
 976 static void tegra186_usb2_pad_remove(struct tegra_xusb_pad *pad)
 977 {
 978         struct tegra_xusb_usb2_pad *usb2 = to_usb2_pad(pad);
 979
 980         kfree(usb2);
 981 }
 982
 983 static const struct tegra_xusb_pad_ops tegra186_usb2_pad_ops = {
 984         .probe = tegra186_usb2_pad_probe,
 985         .remove = tegra186_usb2_pad_remove,
 986 };
 987
 988 static const char * const tegra186_usb2_functions[] = {
 989         "xusb",
 990 };
 991
 992 static int tegra186_usb2_port_enable(struct tegra_xusb_port *port)
 993 {
 994         return 0;
 995 }
 996
 997 static void tegra186_usb2_port_disable(struct tegra_xusb_port *port)
 998 {
 999 }
1000
1001 static struct tegra_xusb_lane *
1002 tegra186_usb2_port_map(struct tegra_xusb_port *port)
1003 {
1004         return tegra_xusb_find_lane(port->padctl, "usb2", port->index);
1005 }
1006
1007 static const struct tegra_xusb_port_ops tegra186_usb2_port_ops = {
1008         .release = tegra_xusb_usb2_port_release,
1009         .remove = tegra_xusb_usb2_port_remove,
1010         .enable = tegra186_usb2_port_enable,
1011         .disable = tegra186_usb2_port_disable,
1012         .map = tegra186_usb2_port_map,
1013 };
1014
1015 /* SuperSpeed PHY support */
1016 static struct tegra_xusb_lane *
1017 tegra186_usb3_lane_probe(struct tegra_xusb_pad *pad, struct device_node *np,
1018                          unsigned int index)
1019 {
1020         struct tegra_xusb_usb3_lane *usb3;
1021         int err;
1022
1023         usb3 = kzalloc(sizeof(*usb3), GFP_KERNEL);
1024         if (!usb3)
1025                 return ERR_PTR(-ENOMEM);
1026
1027         INIT_LIST_HEAD(&usb3->base.list);
1028         usb3->base.soc = &pad->soc->lanes[index];
1029         usb3->base.index = index;
1030         usb3->base.pad = pad;
1031         usb3->base.np = np;
1032
1033         err = tegra_xusb_lane_parse_dt(&usb3->base, np);
1034         if (err < 0) {
1035                 kfree(usb3);
1036                 return ERR_PTR(err);
1037         }
1038
1039         return &usb3->base;
1040 }
1041
1042 static void tegra186_usb3_lane_remove(struct tegra_xusb_lane *lane)
1043 {
1044         struct tegra_xusb_usb3_lane *usb3 = to_usb3_lane(lane);
1045
1046         kfree(usb3);
1047 }
1048
1049 static int tegra186_usb3_enable_phy_sleepwalk(struct tegra_xusb_lane *lane,
1050                                               enum usb_device_speed speed)
1051 {
1052         struct tegra_xusb_padctl *padctl = lane->pad->padctl;
1053         unsigned int index = lane->index;
1054         u32 value;
1055
1056         mutex_lock(&padctl->lock);
1057
1058         value = padctl_readl(padctl, XUSB_PADCTL_ELPG_PROGRAM_1);
1059         value |= SSPX_ELPG_CLAMP_EN_EARLY(index);
1060         padctl_writel(padctl, value, XUSB_PADCTL_ELPG_PROGRAM_1);
1061
1062         usleep_range(100, 200);
1063
1064         value = padctl_readl(padctl, XUSB_PADCTL_ELPG_PROGRAM_1);
1065         value |= SSPX_ELPG_CLAMP_EN(index);
1066         padctl_writel(padctl, value, XUSB_PADCTL_ELPG_PROGRAM_1);
1067
1068         usleep_range(250, 350);
1069
1070         mutex_unlock(&padctl->lock);
1071
1072         return 0;
1073 }
1074
1075 static int tegra186_usb3_disable_phy_sleepwalk(struct tegra_xusb_lane *lane)
1076 {
1077         struct tegra_xusb_padctl *padctl = lane->pad->padctl;
1078         unsigned int index = lane->index;
1079         u32 value;
1080
1081         mutex_lock(&padctl->lock);
1082
1083         value = padctl_readl(padctl, XUSB_PADCTL_ELPG_PROGRAM_1);
1084         value &= ~SSPX_ELPG_CLAMP_EN_EARLY(index);
1085         padctl_writel(padctl, value, XUSB_PADCTL_ELPG_PROGRAM_1);
1086
1087         usleep_range(100, 200);
1088
1089         value = padctl_readl(padctl, XUSB_PADCTL_ELPG_PROGRAM_1);
1090         value &= ~SSPX_ELPG_CLAMP_EN(index);
1091         padctl_writel(padctl, value, XUSB_PADCTL_ELPG_PROGRAM_1);
1092
1093         mutex_unlock(&padctl->lock);
1094
1095         return 0;
1096 }
1097
1098 static int tegra186_usb3_enable_phy_wake(struct tegra_xusb_lane *lane)
1099 {
1100         struct tegra_xusb_padctl *padctl = lane->pad->padctl;
1101         unsigned int index = lane->index;
1102         u32 value;
1103
1104         mutex_lock(&padctl->lock);
1105
1106         value = padctl_readl(padctl, XUSB_PADCTL_ELPG_PROGRAM);
1107         value &= ~ALL_WAKE_EVENTS;
1108         value |= SS_PORT_WAKEUP_EVENT(index);
1109         padctl_writel(padctl, value, XUSB_PADCTL_ELPG_PROGRAM);
1110
1111         usleep_range(10, 20);
1112
1113         value = padctl_readl(padctl, XUSB_PADCTL_ELPG_PROGRAM);
1114         value &= ~ALL_WAKE_EVENTS;
1115         value |= SS_PORT_WAKE_INTERRUPT_ENABLE(index);
1116         padctl_writel(padctl, value, XUSB_PADCTL_ELPG_PROGRAM);
1117
1118         mutex_unlock(&padctl->lock);
1119
1120         return 0;
1121 }
1122
1123 static int tegra186_usb3_disable_phy_wake(struct tegra_xusb_lane *lane)
1124 {
1125         struct tegra_xusb_padctl *padctl = lane->pad->padctl;
1126         unsigned int index = lane->index;
1127         u32 value;
1128
1129         mutex_lock(&padctl->lock);
1130
1131         value = padctl_readl(padctl, XUSB_PADCTL_ELPG_PROGRAM);
1132         value &= ~ALL_WAKE_EVENTS;
1133         value &= ~SS_PORT_WAKE_INTERRUPT_ENABLE(index);
1134         padctl_writel(padctl, value, XUSB_PADCTL_ELPG_PROGRAM);
1135
1136         usleep_range(10, 20);
1137
1138         value = padctl_readl(padctl, XUSB_PADCTL_ELPG_PROGRAM);
1139         value &= ~ALL_WAKE_EVENTS;
1140         value |= SS_PORT_WAKEUP_EVENT(index);
1141         padctl_writel(padctl, value, XUSB_PADCTL_ELPG_PROGRAM);
1142
1143         mutex_unlock(&padctl->lock);
1144
1145         return 0;
1146 }
1147
1148 static bool tegra186_usb3_phy_remote_wake_detected(struct tegra_xusb_lane *lane)
1149 {
1150         struct tegra_xusb_padctl *padctl = lane->pad->padctl;
1151         unsigned int index = lane->index;
1152         u32 value;
1153
1154         value = padctl_readl(padctl, XUSB_PADCTL_ELPG_PROGRAM);
1155         if ((value & SS_PORT_WAKE_INTERRUPT_ENABLE(index)) && (value & SS_PORT_WAKEUP_EVENT(index)))
1156                 return true;
1157
1158         return false;
1159 }
1160
1161 static const struct tegra_xusb_lane_ops tegra186_usb3_lane_ops = {
1162         .probe = tegra186_usb3_lane_probe,
1163         .remove = tegra186_usb3_lane_remove,
1164         .enable_phy_sleepwalk = tegra186_usb3_enable_phy_sleepwalk,
1165         .disable_phy_sleepwalk = tegra186_usb3_disable_phy_sleepwalk,
1166         .enable_phy_wake = tegra186_usb3_enable_phy_wake,
1167         .disable_phy_wake = tegra186_usb3_disable_phy_wake,
1168         .remote_wake_detected = tegra186_usb3_phy_remote_wake_detected,
1169 };
1170
1171 static int tegra186_usb3_port_enable(struct tegra_xusb_port *port)
1172 {
1173         return 0;
1174 }
1175
1176 static void tegra186_usb3_port_disable(struct tegra_xusb_port *port)
1177 {
1178 }
1179
1180 static struct tegra_xusb_lane *
1181 tegra186_usb3_port_map(struct tegra_xusb_port *port)
1182 {
1183         return tegra_xusb_find_lane(port->padctl, "usb3", port->index);
1184 }
1185
1186 static const struct tegra_xusb_port_ops tegra186_usb3_port_ops = {
1187         .release = tegra_xusb_usb3_port_release,
1188         .remove = tegra_xusb_usb3_port_remove,
1189         .enable = tegra186_usb3_port_enable,
1190         .disable = tegra186_usb3_port_disable,
1191         .map = tegra186_usb3_port_map,
1192 };
1193
1194 static int tegra186_usb3_phy_power_on(struct phy *phy)
1195 {
1196         struct tegra_xusb_lane *lane = phy_get_drvdata(phy);
1197         struct tegra_xusb_padctl *padctl = lane->pad->padctl;
1198         struct tegra_xusb_usb3_port *port;
1199         struct tegra_xusb_usb2_port *usb2;
1200         unsigned int index = lane->index;
1201         struct device *dev = padctl->dev;
1202         u32 value;
1203
1204         port = tegra_xusb_find_usb3_port(padctl, index);
1205         if (!port) {
1206                 dev_err(dev, "no port found for USB3 lane %u\n", index);
1207                 return -ENODEV;
1208         }
1209
1210         usb2 = tegra_xusb_find_usb2_port(padctl, port->port);
1211         if (!usb2) {
1212                 dev_err(dev, "no companion port found for USB3 lane %u\n",
1213                         index);
1214                 return -ENODEV;
1215         }
1216
1217         mutex_lock(&padctl->lock);
1218
1219         value = padctl_readl(padctl, XUSB_PADCTL_SS_PORT_CAP);
1220         value &= ~(PORT_CAP_MASK << PORTX_CAP_SHIFT(index));
1221
1222         if (usb2->mode == USB_DR_MODE_UNKNOWN)
1223                 value |= (PORT_CAP_DISABLED << PORTX_CAP_SHIFT(index));
1224         else if (usb2->mode == USB_DR_MODE_PERIPHERAL)
1225                 value |= (PORT_CAP_DEVICE << PORTX_CAP_SHIFT(index));
1226         else if (usb2->mode == USB_DR_MODE_HOST)
1227                 value |= (PORT_CAP_HOST << PORTX_CAP_SHIFT(index));
1228         else if (usb2->mode == USB_DR_MODE_OTG)
1229                 value |= (PORT_CAP_OTG << PORTX_CAP_SHIFT(index));
1230
1231         padctl_writel(padctl, value, XUSB_PADCTL_SS_PORT_CAP);
1232
1233         if (padctl->soc->supports_gen2 && port->disable_gen2) {
1234                 value = padctl_readl(padctl, XUSB_PADCTL_SS_PORT_CFG);
1235                 value &= ~(PORTX_SPEED_SUPPORT_MASK <<
1236                         PORTX_SPEED_SUPPORT_SHIFT(index));
1237                 value |= (PORT_SPEED_SUPPORT_GEN1 <<
1238                         PORTX_SPEED_SUPPORT_SHIFT(index));
1239                 padctl_writel(padctl, value, XUSB_PADCTL_SS_PORT_CFG);
1240         }
1241
1242         value = padctl_readl(padctl, XUSB_PADCTL_ELPG_PROGRAM_1);
1243         value &= ~SSPX_ELPG_VCORE_DOWN(index);
1244         padctl_writel(padctl, value, XUSB_PADCTL_ELPG_PROGRAM_1);
1245
1246         usleep_range(100, 200);
1247
1248         value = padctl_readl(padctl, XUSB_PADCTL_ELPG_PROGRAM_1);
1249         value &= ~SSPX_ELPG_CLAMP_EN_EARLY(index);
1250         padctl_writel(padctl, value, XUSB_PADCTL_ELPG_PROGRAM_1);
1251
1252         usleep_range(100, 200);
1253
1254         value = padctl_readl(padctl, XUSB_PADCTL_ELPG_PROGRAM_1);
1255         value &= ~SSPX_ELPG_CLAMP_EN(index);
1256         padctl_writel(padctl, value, XUSB_PADCTL_ELPG_PROGRAM_1);
1257
1258         mutex_unlock(&padctl->lock);
1259
1260         return 0;
1261 }
1262
1263 static int tegra186_usb3_phy_power_off(struct phy *phy)
1264 {
1265         struct tegra_xusb_lane *lane = phy_get_drvdata(phy);
1266         struct tegra_xusb_padctl *padctl = lane->pad->padctl;
1267         struct tegra_xusb_usb3_port *port;
1268         unsigned int index = lane->index;
1269         struct device *dev = padctl->dev;
1270         u32 value;
1271
1272         port = tegra_xusb_find_usb3_port(padctl, index);
1273         if (!port) {
1274                 dev_err(dev, "no port found for USB3 lane %u\n", index);
1275                 return -ENODEV;
1276         }
1277
1278         mutex_lock(&padctl->lock);
1279
1280         value = padctl_readl(padctl, XUSB_PADCTL_ELPG_PROGRAM_1);
1281         value |= SSPX_ELPG_CLAMP_EN_EARLY(index);
1282         padctl_writel(padctl, value, XUSB_PADCTL_ELPG_PROGRAM_1);
1283
1284         usleep_range(100, 200);
1285
1286         value = padctl_readl(padctl, XUSB_PADCTL_ELPG_PROGRAM_1);
1287         value |= SSPX_ELPG_CLAMP_EN(index);
1288         padctl_writel(padctl, value, XUSB_PADCTL_ELPG_PROGRAM_1);
1289
1290         usleep_range(250, 350);
1291
1292         value = padctl_readl(padctl, XUSB_PADCTL_ELPG_PROGRAM_1);
1293         value |= SSPX_ELPG_VCORE_DOWN(index);
1294         padctl_writel(padctl, value, XUSB_PADCTL_ELPG_PROGRAM_1);
1295
1296         mutex_unlock(&padctl->lock);
1297
1298         return 0;
1299 }
1300
1301 static int tegra186_usb3_phy_init(struct phy *phy)
1302 {
1303         return 0;
1304 }
1305
1306 static int tegra186_usb3_phy_exit(struct phy *phy)
1307 {
1308         return 0;
1309 }
1310
1311 static const struct phy_ops usb3_phy_ops = {
1312         .init = tegra186_usb3_phy_init,
1313         .exit = tegra186_usb3_phy_exit,
1314         .power_on = tegra186_usb3_phy_power_on,
1315         .power_off = tegra186_usb3_phy_power_off,
1316         .owner = THIS_MODULE,
1317 };
1318
1319 static struct tegra_xusb_pad *
1320 tegra186_usb3_pad_probe(struct tegra_xusb_padctl *padctl,
1321                         const struct tegra_xusb_pad_soc *soc,
1322                         struct device_node *np)
1323 {
1324         struct tegra_xusb_usb3_pad *usb3;
1325         struct tegra_xusb_pad *pad;
1326         int err;
1327
1328         usb3 = kzalloc(sizeof(*usb3), GFP_KERNEL);
1329         if (!usb3)
1330                 return ERR_PTR(-ENOMEM);
1331
1332         pad = &usb3->base;
1333         pad->ops = &tegra186_usb3_lane_ops;
1334         pad->soc = soc;
1335
1336         err = tegra_xusb_pad_init(pad, padctl, np);
1337         if (err < 0) {
1338                 kfree(usb3);
1339                 goto out;
1340         }
1341
1342         err = tegra_xusb_pad_register(pad, &usb3_phy_ops);
1343         if (err < 0)
1344                 goto unregister;
1345
1346         dev_set_drvdata(&pad->dev, pad);
1347
1348         return pad;
1349
1350 unregister:
1351         device_unregister(&pad->dev);
1352 out:
1353         return ERR_PTR(err);
1354 }
1355
1356 static void tegra186_usb3_pad_remove(struct tegra_xusb_pad *pad)
1357 {
1358         struct tegra_xusb_usb2_pad *usb2 = to_usb2_pad(pad);
1359
1360         kfree(usb2);
1361 }
1362
1363 static const struct tegra_xusb_pad_ops tegra186_usb3_pad_ops = {
1364         .probe = tegra186_usb3_pad_probe,
1365         .remove = tegra186_usb3_pad_remove,
1366 };
1367
1368 static const char * const tegra186_usb3_functions[] = {
1369         "xusb",
1370 };
1371
1372 static int
1373 tegra186_xusb_read_fuse_calibration(struct tegra186_xusb_padctl *padctl)
1374 {
1375         struct device *dev = padctl->base.dev;
1376         unsigned int i, count;
1377         u32 value, *level;
1378         int err;
1379
1380         count = padctl->base.soc->ports.usb2.count;
1381
1382         level = devm_kcalloc(dev, count, sizeof(u32), GFP_KERNEL);
1383         if (!level)
1384                 return -ENOMEM;
1385
1386         err = tegra_fuse_readl(TEGRA_FUSE_SKU_CALIB_0, &value);
1387         if (err)
1388                 return dev_err_probe(dev, err,
1389                                      "failed to read calibration fuse\n");
1390
1391         dev_dbg(dev, "FUSE_USB_CALIB_0 %#x\n", value);
1392
1393         for (i = 0; i < count; i++)
1394                 level[i] = (value >> HS_CURR_LEVEL_PADX_SHIFT(i)) &
1395                                 HS_CURR_LEVEL_PAD_MASK;
1396
1397         padctl->calib.hs_curr_level = level;
1398
1399         padctl->calib.hs_squelch = (value >> HS_SQUELCH_SHIFT) &
1400                                         HS_SQUELCH_MASK;
1401         padctl->calib.hs_term_range_adj = (value >> HS_TERM_RANGE_ADJ_SHIFT) &
1402                                                 HS_TERM_RANGE_ADJ_MASK;
1403
1404         err = tegra_fuse_readl(TEGRA_FUSE_USB_CALIB_EXT_0, &value);
1405         if (err) {
1406                 dev_err(dev, "failed to read calibration fuse: %d\n", err);
1407                 return err;
1408         }
1409
1410         dev_dbg(dev, "FUSE_USB_CALIB_EXT_0 %#x\n", value);
1411
1412         padctl->calib.rpd_ctrl = (value >> RPD_CTRL_SHIFT) & RPD_CTRL_MASK;
1413
1414         return 0;
1415 }
1416
1417 static struct tegra_xusb_padctl *
1418 tegra186_xusb_padctl_probe(struct device *dev,
1419                            const struct tegra_xusb_padctl_soc *soc)
1420 {
1421         struct platform_device *pdev = to_platform_device(dev);
1422         struct tegra186_xusb_padctl *priv;
1423         struct resource *res;
1424         int err;
1425
1426         priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
1427         if (!priv)
1428                 return ERR_PTR(-ENOMEM);
1429
1430         priv->base.dev = dev;
1431         priv->base.soc = soc;
1432
1433         res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "ao");
1434         priv->ao_regs = devm_ioremap_resource(dev, res);
1435         if (IS_ERR(priv->ao_regs))
1436                 return ERR_CAST(priv->ao_regs);
1437
1438         err = tegra186_xusb_read_fuse_calibration(priv);
1439         if (err < 0)
1440                 return ERR_PTR(err);
1441
1442         return &priv->base;
1443 }
1444
1445 static void tegra186_xusb_padctl_save(struct tegra_xusb_padctl *padctl)
1446 {
1447         struct tegra186_xusb_padctl *priv = to_tegra186_xusb_padctl(padctl);
1448
1449         priv->context.vbus_id = padctl_readl(padctl, USB2_VBUS_ID);
1450         priv->context.usb2_pad_mux = padctl_readl(padctl, XUSB_PADCTL_USB2_PAD_MUX);
1451         priv->context.usb2_port_cap = padctl_readl(padctl, XUSB_PADCTL_USB2_PORT_CAP);
1452         priv->context.ss_port_cap = padctl_readl(padctl, XUSB_PADCTL_SS_PORT_CAP);
1453 }
1454
1455 static void tegra186_xusb_padctl_restore(struct tegra_xusb_padctl *padctl)
1456 {
1457         struct tegra186_xusb_padctl *priv = to_tegra186_xusb_padctl(padctl);
1458
1459         padctl_writel(padctl, priv->context.usb2_pad_mux, XUSB_PADCTL_USB2_PAD_MUX);
1460         padctl_writel(padctl, priv->context.usb2_port_cap, XUSB_PADCTL_USB2_PORT_CAP);
1461         padctl_writel(padctl, priv->context.ss_port_cap, XUSB_PADCTL_SS_PORT_CAP);
1462         padctl_writel(padctl, priv->context.vbus_id, USB2_VBUS_ID);
1463 }
1464
1465 static int tegra186_xusb_padctl_suspend_noirq(struct tegra_xusb_padctl *padctl)
1466 {
1467         tegra186_xusb_padctl_save(padctl);
1468
1469         return 0;
1470 }
1471
1472 static int tegra186_xusb_padctl_resume_noirq(struct tegra_xusb_padctl *padctl)
1473 {
1474         tegra186_xusb_padctl_restore(padctl);
1475
1476         return 0;
1477 }
1478
1479 static void tegra186_xusb_padctl_remove(struct tegra_xusb_padctl *padctl)
1480 {
1481 }
1482
1483 static const struct tegra_xusb_padctl_ops tegra186_xusb_padctl_ops = {
1484         .probe = tegra186_xusb_padctl_probe,
1485         .remove = tegra186_xusb_padctl_remove,
1486         .suspend_noirq = tegra186_xusb_padctl_suspend_noirq,
1487         .resume_noirq = tegra186_xusb_padctl_resume_noirq,
1488         .vbus_override = tegra186_xusb_padctl_vbus_override,
1489         .utmi_pad_power_on = tegra186_utmi_pad_power_on,
1490         .utmi_pad_power_down = tegra186_utmi_pad_power_down,
1491 };
1492
1493 #if IS_ENABLED(CONFIG_ARCH_TEGRA_186_SOC)
1494 static const char * const tegra186_xusb_padctl_supply_names[] = {
1495         "avdd-pll-erefeut",
1496         "avdd-usb",
1497         "vclamp-usb",
1498         "vddio-hsic",
1499 };
1500
1501 static const struct tegra_xusb_lane_soc tegra186_usb2_lanes[] = {
1502         TEGRA186_LANE("usb2-0", 0,  0, 0, usb2),
1503         TEGRA186_LANE("usb2-1", 0,  0, 0, usb2),
1504         TEGRA186_LANE("usb2-2", 0,  0, 0, usb2),
1505 };
1506
1507 static const struct tegra_xusb_pad_soc tegra186_usb2_pad = {
1508         .name = "usb2",
1509         .num_lanes = ARRAY_SIZE(tegra186_usb2_lanes),
1510         .lanes = tegra186_usb2_lanes,
1511         .ops = &tegra186_usb2_pad_ops,
1512 };
1513
1514 static const struct tegra_xusb_lane_soc tegra186_usb3_lanes[] = {
1515         TEGRA186_LANE("usb3-0", 0,  0, 0, usb3),
1516         TEGRA186_LANE("usb3-1", 0,  0, 0, usb3),
1517         TEGRA186_LANE("usb3-2", 0,  0, 0, usb3),
1518 };
1519
1520 static const struct tegra_xusb_pad_soc tegra186_usb3_pad = {
1521         .name = "usb3",
1522         .num_lanes = ARRAY_SIZE(tegra186_usb3_lanes),
1523         .lanes = tegra186_usb3_lanes,
1524         .ops = &tegra186_usb3_pad_ops,
1525 };
1526
1527 static const struct tegra_xusb_pad_soc * const tegra186_pads[] = {
1528         &tegra186_usb2_pad,
1529         &tegra186_usb3_pad,
1530 #if 0 /* TODO implement */
1531         &tegra186_hsic_pad,
1532 #endif
1533 };
1534
1535 const struct tegra_xusb_padctl_soc tegra186_xusb_padctl_soc = {
1536         .num_pads = ARRAY_SIZE(tegra186_pads),
1537         .pads = tegra186_pads,
1538         .ports = {
1539                 .usb2 = {
1540                         .ops = &tegra186_usb2_port_ops,
1541                         .count = 3,
1542                 },
1543 #if 0 /* TODO implement */
1544                 .hsic = {
1545                         .ops = &tegra186_hsic_port_ops,
1546                         .count = 1,
1547                 },
1548 #endif
1549                 .usb3 = {
1550                         .ops = &tegra186_usb3_port_ops,
1551                         .count = 3,
1552                 },
1553         },
1554         .ops = &tegra186_xusb_padctl_ops,
1555         .supply_names = tegra186_xusb_padctl_supply_names,
1556         .num_supplies = ARRAY_SIZE(tegra186_xusb_padctl_supply_names),
1557 };
1558 EXPORT_SYMBOL_GPL(tegra186_xusb_padctl_soc);
1559 #endif
1560
1561 #if IS_ENABLED(CONFIG_ARCH_TEGRA_194_SOC)
1562 static const char * const tegra194_xusb_padctl_supply_names[] = {
1563         "avdd-usb",
1564         "vclamp-usb",
1565 };
1566
1567 static const struct tegra_xusb_lane_soc tegra194_usb2_lanes[] = {
1568         TEGRA186_LANE("usb2-0", 0,  0, 0, usb2),
1569         TEGRA186_LANE("usb2-1", 0,  0, 0, usb2),
1570         TEGRA186_LANE("usb2-2", 0,  0, 0, usb2),
1571         TEGRA186_LANE("usb2-3", 0,  0, 0, usb2),
1572 };
1573
1574 static const struct tegra_xusb_pad_soc tegra194_usb2_pad = {
1575         .name = "usb2",
1576         .num_lanes = ARRAY_SIZE(tegra194_usb2_lanes),
1577         .lanes = tegra194_usb2_lanes,
1578         .ops = &tegra186_usb2_pad_ops,
1579 };
1580
1581 static const struct tegra_xusb_lane_soc tegra194_usb3_lanes[] = {
1582         TEGRA186_LANE("usb3-0", 0,  0, 0, usb3),
1583         TEGRA186_LANE("usb3-1", 0,  0, 0, usb3),
1584         TEGRA186_LANE("usb3-2", 0,  0, 0, usb3),
1585         TEGRA186_LANE("usb3-3", 0,  0, 0, usb3),
1586 };
1587
1588 static const struct tegra_xusb_pad_soc tegra194_usb3_pad = {
1589         .name = "usb3",
1590         .num_lanes = ARRAY_SIZE(tegra194_usb3_lanes),
1591         .lanes = tegra194_usb3_lanes,
1592         .ops = &tegra186_usb3_pad_ops,
1593 };
1594
1595 static const struct tegra_xusb_pad_soc * const tegra194_pads[] = {
1596         &tegra194_usb2_pad,
1597         &tegra194_usb3_pad,
1598 };
1599
1600 const struct tegra_xusb_padctl_soc tegra194_xusb_padctl_soc = {
1601         .num_pads = ARRAY_SIZE(tegra194_pads),
1602         .pads = tegra194_pads,
1603         .ports = {
1604                 .usb2 = {
1605                         .ops = &tegra186_usb2_port_ops,
1606                         .count = 4,
1607                 },
1608                 .usb3 = {
1609                         .ops = &tegra186_usb3_port_ops,
1610                         .count = 4,
1611                 },
1612         },
1613         .ops = &tegra186_xusb_padctl_ops,
1614         .supply_names = tegra194_xusb_padctl_supply_names,
1615         .num_supplies = ARRAY_SIZE(tegra194_xusb_padctl_supply_names),
1616         .supports_gen2 = true,
1617 };
1618 EXPORT_SYMBOL_GPL(tegra194_xusb_padctl_soc);
1619 #endif
1620
1621 MODULE_AUTHOR("JC Kuo <jckuo@nvidia.com>");
1622 MODULE_DESCRIPTION("NVIDIA Tegra186 XUSB Pad Controller driver");
1623 MODULE_LICENSE("GPL v2");