sys/arm/nvidia/tegra124/tegra124_xusbpadctl.c

   1 /*-
   2  * Copyright (c) 2016 Michal Meloun <mmel@FreeBSD.org>
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  */
  26
  27 #include <sys/cdefs.h>
  28 __FBSDID("$FreeBSD$");
  29
  30 #include <sys/param.h>
  31 #include <sys/systm.h>
  32 #include <sys/bus.h>
  33 #include <sys/kernel.h>
  34 #include <sys/module.h>
  35 #include <sys/malloc.h>
  36 #include <sys/rman.h>
  37
  38 #include <machine/bus.h>
  39 #include <machine/fdt.h>
  40
  41 #include <dev/extres/hwreset/hwreset.h>
  42 #include <dev/extres/phy/phy.h>
  43 #include <dev/extres/regulator/regulator.h>
  44 #include <dev/fdt/fdt_common.h>
  45 #include <dev/fdt/fdt_pinctrl.h>
  46 #include <dev/ofw/openfirm.h>
  47 #include <dev/ofw/ofw_bus.h>
  48 #include <dev/ofw/ofw_bus_subr.h>
  49
  50 #include <arm/nvidia/tegra_efuse.h>
  51
  52 #include <gnu/dts/include/dt-bindings/pinctrl/pinctrl-tegra-xusb.h>
  53
  54 #include "phydev_if.h"
  55
  56 /* FUSE calibration data. */
  57 #define FUSE_XUSB_CALIB                         0x0F0
  58 #define   FUSE_XUSB_CALIB_HS_CURR_LEVEL_123(x)          (((x) >> 15) & 0x3F);
  59 #define   FUSE_XUSB_CALIB_HS_IREF_CAP(x)                (((x) >> 13) & 0x03);
  60 #define   FUSE_XUSB_CALIB_HS_SQUELCH_LEVEL(x)           (((x) >> 11) & 0x03);
  61 #define   FUSE_XUSB_CALIB_HS_TERM_RANGE_ADJ(x)          (((x) >>  7) & 0x0F);
  62 #define   FUSE_XUSB_CALIB_HS_CURR_LEVEL_0(x)            (((x) >>  0) & 0x3F);
  63
  64
  65 /* Registers. */
  66 #define XUSB_PADCTL_USB2_PAD_MUX                0x004
  67
  68 #define XUSB_PADCTL_USB2_PORT_CAP               0x008
  69 #define  USB2_PORT_CAP_ULPI_PORT_INTERNAL               (1 << 25)
  70 #define  USB2_PORT_CAP_ULPI_PORT_CAP                    (1 << 24)
  71 #define  USB2_PORT_CAP_PORT_REVERSE_ID(p)               (1 << (3 + (p) * 4))
  72 #define  USB2_PORT_CAP_PORT_INTERNAL(p)                 (1 << (2 + (p) * 4))
  73 #define  USB2_PORT_CAP_PORT_CAP(p, x)                   (((x) & 3) << ((p) * 4))
  74 #define   USB2_PORT_CAP_PORT_CAP_OTG                    0x3
  75 #define   USB2_PORT_CAP_PORT_CAP_DEVICE                 0x2
  76 #define   USB2_PORT_CAP_PORT_CAP_HOST                   0x1
  77 #define   USB2_PORT_CAP_PORT_CAP_DISABLED               0x0
  78
  79 #define XUSB_PADCTL_SS_PORT_MAP                 0x014
  80 #define  SS_PORT_MAP_PORT_INTERNAL(p)                   (1 << (3 + (p) * 4))
  81 #define  SS_PORT_MAP_PORT_MAP(p, x)                     (((x) & 7) << ((p) * 4))
  82
  83 #define XUSB_PADCTL_ELPG_PROGRAM                0x01C
  84 #define  ELPG_PROGRAM_AUX_MUX_LP0_VCORE_DOWN            (1 << 26)
  85 #define  ELPG_PROGRAM_AUX_MUX_LP0_CLAMP_EN_EARLY        (1 << 25)
  86 #define  ELPG_PROGRAM_AUX_MUX_LP0_CLAMP_EN              (1 << 24)
  87 #define  ELPG_PROGRAM_SSP_ELPG_VCORE_DOWN(x)            (1 << (18 + (x) * 4))
  88 #define  ELPG_PROGRAM_SSP_ELPG_CLAMP_EN_EARLY(x)        (1 << (17 + (x) * 4))
  89 #define  ELPG_PROGRAM_SSP_ELPG_CLAMP_EN(x)              (1 << (16 + (x) * 4))
  90
  91 #define XUSB_PADCTL_IOPHY_PLL_P0_CTL1           0x040
  92 #define  IOPHY_PLL_P0_CTL1_PLL0_LOCKDET                 (1 << 19)
  93 #define  IOPHY_PLL_P0_CTL1_REFCLK_SEL(x)                (((x) & 0xF) << 12)
  94 #define  IOPHY_PLL_P0_CTL1_PLL_RST                      (1 << 1)
  95
  96 #define XUSB_PADCTL_IOPHY_PLL_P0_CTL2           0x044
  97 #define  IOPHY_PLL_P0_CTL2_REFCLKBUF_EN                 (1 << 6)
  98 #define  IOPHY_PLL_P0_CTL2_TXCLKREF_EN                  (1 << 5)
  99 #define  IOPHY_PLL_P0_CTL2_TXCLKREF_SEL                 (1 << 4)
 100
 101 #define XUSB_PADCTL_IOPHY_USB3_PAD_CTL2(x)      (0x058 + (x) * 4)
 102 #define  IOPHY_USB3_PAD_CTL2_CDR_CNTL(x)                (((x) & 0x00FF) <<  4)
 103 #define  IOPHY_USB3_PAD_CTL2_RX_EQ(x)                   (((x) & 0xFFFF) <<  8)
 104 #define  IOPHY_USB3_PAD_CTL2_RX_WANDER(x)               (((x) & 0x000F) <<  4)
 105 #define  IOPHY_USB3_PAD_CTL2_RX_TERM_CNTL(x)            (((x) & 0x0003) <<  2)
 106 #define  IOPHY_USB3_PAD_CTL2_TX_TERM_CNTL(x)            (((x) & 0x0003) <<  0)
 107
 108
 109 #define XUSB_PADCTL_IOPHY_USB3_PAD_CTL4(x)      (0x068 + (x) * 4)
 110
 111 #define XUSB_PADCTL_USB2_OTG_PAD_CTL0(x)        (0x0A0 + (x) * 4)
 112 #define  USB2_OTG_PAD_CTL0_LSBIAS_SEL                   (1 << 23)
 113 #define  USB2_OTG_PAD_CTL0_DISCON_DETECT_METHOD         (1 << 22)
 114 #define  USB2_OTG_PAD_CTL0_PD_ZI                        (1 << 21)
 115 #define  USB2_OTG_PAD_CTL0_PD2                          (1 << 20)
 116 #define  USB2_OTG_PAD_CTL0_PD                           (1 << 19)
 117 #define  USB2_OTG_PAD_CTL0_TERM_EN                      (1 << 18)
 118 #define  USB2_OTG_PAD_CTL0_LS_LS_FSLEW(x)               (((x) & 0x03) << 16)
 119 #define  USB2_OTG_PAD_CTL0_LS_RSLEW(x)                  (((x) & 0x03) << 14)
 120 #define  USB2_OTG_PAD_CTL0_FS_SLEW(x)                   (((x) & 0x03) << 12)
 121 #define  USB2_OTG_PAD_CTL0_HS_SLEW(x)                   (((x) & 0x3F) <<  6)
 122 #define  USB2_OTG_PAD_CTL0_HS_CURR_LEVEL(x)             (((x) & 0x3F) <<  0)
 123
 124 #define XUSB_PADCTL_USB2_OTG_PAD_CTL1(x)        (0x0AC + (x) * 4)
 125 #define  USB2_OTG_PAD_CTL1_RPU_RANGE_ADJ(x)             (((x) & 0x3) << 11)
 126 #define  USB2_OTG_PAD_CTL1_HS_IREF_CAP(x)               (((x) & 0x3) <<  9)
 127 #define  USB2_OTG_PAD_CTL1_SPARE(x)                     (((x) & 0x3) <<  7)
 128 #define  USB2_OTG_PAD_CTL1_TERM_RANGE_ADJ(x)            (((x) & 0xF) <<  3)
 129 #define  USB2_OTG_PAD_CTL1_PD_DR                        (1 <<  2)
 130 #define  USB2_OTG_PAD_CTL1_PD_DISC_FORCE_POWERUP        (1 <<  1)
 131 #define  USB2_OTG_PAD_CTL1_PD_CHRP_FORCE_POWERUP        (1 <<  0)
 132
 133 #define XUSB_PADCTL_USB2_BIAS_PAD_CTL0          0x0B8
 134 #define  USB2_BIAS_PAD_CTL0_ADJRPU(x)                   (((x) & 0x7) << 14)
 135 #define  USB2_BIAS_PAD_CTL0_PD_TRK                      (1 << 13)
 136 #define  USB2_BIAS_PAD_CTL0_PD                          (1 << 12)
 137 #define  USB2_BIAS_PAD_CTL0_TERM_OFFSETL(x)             (((x) & 0x3) <<  9)
 138 #define  USB2_BIAS_PAD_CTL0_VBUS_LEVEL(x)               (((x) & 0x3) <<  7)
 139 #define  USB2_BIAS_PAD_CTL0_HS_CHIRP_LEVEL(x)           (((x) & 0x3) <<  5)
 140 #define  USB2_BIAS_PAD_CTL0_HS_DISCON_LEVEL(x)          (((x) & 0x7) <<  2)
 141 #define  USB2_BIAS_PAD_CTL0_HS_SQUELCH_LEVEL(x)         (((x) & 0x3) <<  0)
 142
 143 #define XUSB_PADCTL_HSIC_PAD0_CTL0              0x0C8
 144 #define  HSIC_PAD0_CTL0_HSIC_OPT(x)                     (((x) & 0xF) << 16)
 145 #define  HSIC_PAD0_CTL0_TX_SLEWN(x)                     (((x) & 0xF) << 12)
 146 #define  HSIC_PAD0_CTL0_TX_SLEWP(x)                     (((x) & 0xF) <<  8)
 147 #define  HSIC_PAD0_CTL0_TX_RTUNEN(x)                    (((x) & 0xF) <<  4)
 148 #define  HSIC_PAD0_CTL0_TX_RTUNEP(x)                    (((x) & 0xF) <<  0)
 149
 150 #define XUSB_PADCTL_USB3_PAD_MUX                0x134
 151 #define  USB3_PAD_MUX_PCIE_IDDQ_DISABLE(x)              (1 << (1 + (x)))
 152 #define  USB3_PAD_MUX_SATA_IDDQ_DISABLE                 (1 << 6)
 153
 154
 155 #define XUSB_PADCTL_IOPHY_PLL_S0_CTL1           0x138
 156 #define  IOPHY_PLL_S0_CTL1_PLL1_LOCKDET                 (1 << 27)
 157 #define  IOPHY_PLL_S0_CTL1_PLL1_MODE                    (1 << 24)
 158 #define  IOPHY_PLL_S0_CTL1_PLL_PWR_OVRD                 (1 << 3)
 159 #define  IOPHY_PLL_S0_CTL1_PLL_RST_L                    (1 << 1)
 160 #define  IOPHY_PLL_S0_CTL1_PLL_IDDQ                     (1 << 0)
 161
 162 #define XUSB_PADCTL_IOPHY_PLL_S0_CTL2           0x13C
 163 #define XUSB_PADCTL_IOPHY_PLL_S0_CTL3           0x140
 164 #define XUSB_PADCTL_IOPHY_PLL_S0_CTL4           0x144
 165
 166 #define XUSB_PADCTL_IOPHY_MISC_PAD_S0_CTL1      0x148
 167 #define  IOPHY_MISC_PAD_S0_CTL1_IDDQ_OVRD               (1 << 1)
 168 #define  IOPHY_MISC_PAD_S0_CTL1_IDDQ                    (1 << 0)
 169
 170 #define XUSB_PADCTL_IOPHY_MISC_PAD_S0_CTL2      0x14C
 171 #define XUSB_PADCTL_IOPHY_MISC_PAD_S0_CTL3      0x150
 172 #define XUSB_PADCTL_IOPHY_MISC_PAD_S0_CTL4      0x154
 173 #define XUSB_PADCTL_IOPHY_MISC_PAD_S0_CTL5      0x158
 174 #define XUSB_PADCTL_IOPHY_MISC_PAD_S0_CTL6      0x15C
 175
 176
 177 #define WR4(_sc, _r, _v)        bus_write_4((_sc)->mem_res, (_r), (_v))
 178 #define RD4(_sc, _r)            bus_read_4((_sc)->mem_res, (_r))
 179
 180
 181 struct padctl_softc {
 182         device_t        dev;
 183         struct resource *mem_res;
 184         hwreset_t       rst;
 185         int             phy_ena_cnt;
 186
 187         /* Fuses calibration data */
 188         uint32_t        hs_curr_level_0;
 189         uint32_t        hs_curr_level_123;
 190         uint32_t        hs_iref_cap;
 191         uint32_t        hs_term_range_adj;
 192         uint32_t        hs_squelch_level;
 193
 194         uint32_t        hs_curr_level_offset;
 195 };
 196
 197 static struct ofw_compat_data compat_data[] = {
 198         {"nvidia,tegra124-xusb-padctl", 1},
 199         {NULL,                          0},
 200 };
 201
 202 /* Ports. */
 203 enum padctl_port_type {
 204         PADCTL_PORT_USB2,
 205         PADCTL_PORT_ULPI,
 206         PADCTL_PORT_HSIC,
 207         PADCTL_PORT_USB3,
 208 };
 209
 210 struct padctl_lane;
 211 struct padctl_port {
 212         enum padctl_port_type   type;
 213         const char              *name;
 214         const char              *base_name;
 215         int                     idx;
 216         int                     (*init)(struct padctl_softc *sc,
 217                                     struct padctl_port *port);
 218
 219         /* Runtime data. */
 220         bool                    enabled;
 221         regulator_t             supply_vbus;    /* USB2, USB3 */
 222         bool                    internal;       /* ULPI, USB2, USB3 */
 223         uint32_t                companion;      /* USB3 */
 224         struct padctl_lane      *lane;
 225 };
 226
 227 static int usb3_port_init(struct padctl_softc *sc, struct padctl_port *port);
 228
 229 #define PORT(t, n, p, i) {                                              \
 230         .type = t,                                                      \
 231         .name = n "-" #p,                                               \
 232         .base_name = n,                                                 \
 233         .idx = p,                                                       \
 234         .init = i,                                                      \
 235 }
 236 static struct padctl_port ports_tbl[] = {
 237         PORT(PADCTL_PORT_USB2, "usb2", 0, NULL),
 238         PORT(PADCTL_PORT_USB2, "usb2", 1, NULL),
 239         PORT(PADCTL_PORT_USB2, "usb2", 2, NULL),
 240         PORT(PADCTL_PORT_ULPI, "ulpi", 0, NULL),
 241         PORT(PADCTL_PORT_HSIC, "hsic", 0, NULL),
 242         PORT(PADCTL_PORT_HSIC, "hsic", 1, NULL),
 243         PORT(PADCTL_PORT_USB3, "usb3", 0, usb3_port_init),
 244         PORT(PADCTL_PORT_USB3, "usb3", 1, usb3_port_init),
 245 };
 246
 247 /* Pads - a group of lannes. */
 248 enum padctl_pad_type {
 249         PADCTL_PAD_USB2,
 250         PADCTL_PAD_ULPI,
 251         PADCTL_PAD_HSIC,
 252         PADCTL_PAD_PCIE,
 253         PADCTL_PAD_SATA,
 254 };
 255
 256 struct padctl_lane;
 257 struct padctl_pad {
 258         const char              *name;
 259         enum padctl_pad_type    type;
 260         int                     (*powerup)(struct padctl_softc *sc,
 261                                     struct padctl_lane *lane);
 262         int                     (*powerdown)(struct padctl_softc *sc,
 263                                     struct padctl_lane *lane);
 264         /* Runtime data. */
 265         bool                    enabled;
 266         struct padctl_lane      *lanes[8];      /* Safe maximum value. */
 267         int                     nlanes;
 268 };
 269
 270 static int usb2_powerup(struct padctl_softc *sc, struct padctl_lane *lane);
 271 static int usb2_powerdown(struct padctl_softc *sc, struct padctl_lane *lane);
 272 static int pcie_powerup(struct padctl_softc *sc, struct padctl_lane *lane);
 273 static int pcie_powerdown(struct padctl_softc *sc, struct padctl_lane *lane);
 274 static int sata_powerup(struct padctl_softc *sc, struct padctl_lane *lane);
 275 static int sata_powerdown(struct padctl_softc *sc, struct padctl_lane *lane);
 276
 277 #define PAD(n, t, u, d) {                                               \
 278         .name = n,                                                      \
 279         .type = t,                                                      \
 280         .powerup = u,                                                   \
 281         .powerdown = d,                                                 \
 282 }
 283 static struct padctl_pad pads_tbl[] = {
 284         PAD("usb2", PADCTL_PAD_USB2, usb2_powerup, usb2_powerdown),
 285         PAD("ulpi", PADCTL_PAD_ULPI, NULL, NULL),
 286         PAD("hsic", PADCTL_PAD_HSIC, NULL, NULL),
 287         PAD("pcie", PADCTL_PAD_PCIE, pcie_powerup, pcie_powerdown),
 288         PAD("sata", PADCTL_PAD_SATA, sata_powerup, sata_powerdown),
 289 };
 290
 291 /* Lanes. */
 292 static char *otg_mux[] = {"snps", "xusb", "uart", "rsvd"};
 293 static char *usb_mux[] = {"snps", "xusb"};
 294 static char *pci_mux[] = {"pcie", "usb3-ss", "sata", "rsvd"};
 295
 296 struct padctl_lane {
 297         const char              *name;
 298         int                     idx;
 299         bus_size_t              reg;
 300         uint32_t                shift;
 301         uint32_t                mask;
 302         char                    **mux;
 303         int                     nmux;
 304         /* Runtime data. */
 305         bool                    enabled;
 306         struct padctl_pad       *pad;
 307         struct padctl_port      *port;
 308         int                     mux_idx;
 309
 310 };
 311
 312 #define LANE(n, p, r, s, m, mx) {                                       \
 313         .name = n "-" #p,                                               \
 314         .idx = p,                                                       \
 315         .reg = r,                                                       \
 316         .shift = s,                                                     \
 317         .mask = m,                                                      \
 318         .mux = mx,                                                      \
 319         .nmux = nitems(mx),                                             \
 320 }
 321 static struct padctl_lane lanes_tbl[] = {
 322         LANE("usb2", 0, XUSB_PADCTL_USB2_PAD_MUX,  0, 0x3, otg_mux),
 323         LANE("usb2", 1, XUSB_PADCTL_USB2_PAD_MUX,  2, 0x3, otg_mux),
 324         LANE("usb2", 2, XUSB_PADCTL_USB2_PAD_MUX,  4, 0x3, otg_mux),
 325         LANE("ulpi", 0, XUSB_PADCTL_USB2_PAD_MUX, 12, 0x1, usb_mux),
 326         LANE("hsic", 0, XUSB_PADCTL_USB2_PAD_MUX, 14, 0x1, usb_mux),
 327         LANE("hsic", 1, XUSB_PADCTL_USB2_PAD_MUX, 15, 0x1, usb_mux),
 328         LANE("pcie", 0, XUSB_PADCTL_USB3_PAD_MUX, 16, 0x3, pci_mux),
 329         LANE("pcie", 1, XUSB_PADCTL_USB3_PAD_MUX, 18, 0x3, pci_mux),
 330         LANE("pcie", 2, XUSB_PADCTL_USB3_PAD_MUX, 20, 0x3, pci_mux),
 331         LANE("pcie", 3, XUSB_PADCTL_USB3_PAD_MUX, 22, 0x3, pci_mux),
 332         LANE("pcie", 4, XUSB_PADCTL_USB3_PAD_MUX, 24, 0x3, pci_mux),
 333         LANE("sata", 0, XUSB_PADCTL_USB3_PAD_MUX, 26, 0x3, pci_mux),
 334 };
 335
 336 /* Define all possible mappings for USB3 port lanes */
 337 struct padctl_lane_map {
 338         int                     port_idx;
 339         enum padctl_pad_type    pad_type;
 340         int                     lane_idx;
 341 };
 342
 343 #define LANE_MAP(pi, pt, li) {                                          \
 344         .port_idx = pi,                                                 \
 345         .pad_type = pt,                                                 \
 346         .lane_idx = li,                                                 \
 347 }
 348 static struct padctl_lane_map lane_map_tbl[] = {
 349         LANE_MAP(0, PADCTL_PAD_PCIE, 0),        /* port USB3-0 -> lane PCIE-0 */
 350         LANE_MAP(1, PADCTL_PAD_PCIE, 1),        /* port USB3-1 -> lane PCIE-1 */
 351                                                 /* -- or -- */
 352         LANE_MAP(1, PADCTL_PAD_SATA, 0),        /* port USB3-1 -> lane SATA-0 */
 353 };
 354
 355  /* Phy class and methods. */
 356 static int xusbpadctl_phy_enable(struct phynode *phy, bool enable);
 357 static phynode_method_t xusbpadctl_phynode_methods[] = {
 358         PHYNODEMETHOD(phynode_enable,   xusbpadctl_phy_enable),
 359         PHYNODEMETHOD_END
 360
 361 };
 362 DEFINE_CLASS_1(xusbpadctl_phynode, xusbpadctl_phynode_class,
 363     xusbpadctl_phynode_methods, 0, phynode_class);
 364
 365 static struct padctl_port *search_lane_port(struct padctl_softc *sc,
 366     struct padctl_lane *lane);
 367 /* -------------------------------------------------------------------------
 368  *
 369  *   PHY functions
 370  */
 371 static int
 372 usb3_port_init(struct padctl_softc *sc, struct padctl_port *port)
 373 {
 374         uint32_t reg;
 375
 376         reg = RD4(sc, XUSB_PADCTL_SS_PORT_MAP);
 377         if (port->internal)
 378                 reg &= ~SS_PORT_MAP_PORT_INTERNAL(port->idx);
 379         else
 380                 reg |= SS_PORT_MAP_PORT_INTERNAL(port->idx);
 381         reg &= ~SS_PORT_MAP_PORT_MAP(port->idx, ~0);
 382         reg |= SS_PORT_MAP_PORT_MAP(port->idx, port->companion);
 383         WR4(sc, XUSB_PADCTL_SS_PORT_MAP, reg);
 384
 385         reg = RD4(sc, XUSB_PADCTL_IOPHY_USB3_PAD_CTL2(port->idx));
 386         reg &= ~IOPHY_USB3_PAD_CTL2_CDR_CNTL(~0);
 387         reg &= ~IOPHY_USB3_PAD_CTL2_RX_EQ(~0);
 388         reg &= ~IOPHY_USB3_PAD_CTL2_RX_WANDER(~0);
 389         reg |= IOPHY_USB3_PAD_CTL2_CDR_CNTL(0x24);
 390         reg |= IOPHY_USB3_PAD_CTL2_RX_EQ(0xF070);
 391         reg |= IOPHY_USB3_PAD_CTL2_RX_WANDER(0xF);
 392         WR4(sc, XUSB_PADCTL_IOPHY_USB3_PAD_CTL2(port->idx), reg);
 393
 394         WR4(sc, XUSB_PADCTL_IOPHY_USB3_PAD_CTL4(port->idx),
 395             0x002008EE);
 396
 397         reg = RD4(sc, XUSB_PADCTL_ELPG_PROGRAM);
 398         reg &= ~ELPG_PROGRAM_SSP_ELPG_VCORE_DOWN(port->idx);
 399         WR4(sc, XUSB_PADCTL_ELPG_PROGRAM, reg);
 400         DELAY(100);
 401
 402         reg = RD4(sc, XUSB_PADCTL_ELPG_PROGRAM);
 403         reg &= ~ELPG_PROGRAM_SSP_ELPG_CLAMP_EN_EARLY(port->idx);
 404         WR4(sc, XUSB_PADCTL_ELPG_PROGRAM, reg);
 405         DELAY(100);
 406
 407         reg = RD4(sc, XUSB_PADCTL_ELPG_PROGRAM);
 408         reg &= ~ELPG_PROGRAM_SSP_ELPG_CLAMP_EN(port->idx);
 409         WR4(sc, XUSB_PADCTL_ELPG_PROGRAM, reg);
 410         DELAY(100);
 411
 412         return (0);
 413 }
 414
 415 static int
 416 pcie_powerup(struct padctl_softc *sc, struct padctl_lane *lane)
 417 {
 418         uint32_t reg;
 419         int i;
 420
 421         reg = RD4(sc, XUSB_PADCTL_IOPHY_PLL_P0_CTL1);
 422         reg &= ~IOPHY_PLL_P0_CTL1_REFCLK_SEL(~0);
 423         WR4(sc, XUSB_PADCTL_IOPHY_PLL_P0_CTL1, reg);
 424         DELAY(100);
 425
 426         reg = RD4(sc, XUSB_PADCTL_IOPHY_PLL_P0_CTL2);
 427         reg |= IOPHY_PLL_P0_CTL2_REFCLKBUF_EN;
 428         reg |= IOPHY_PLL_P0_CTL2_TXCLKREF_EN;
 429         reg |= IOPHY_PLL_P0_CTL2_TXCLKREF_SEL;
 430         WR4(sc, XUSB_PADCTL_IOPHY_PLL_P0_CTL2, reg);
 431         DELAY(100);
 432
 433         reg = RD4(sc, XUSB_PADCTL_IOPHY_PLL_P0_CTL1);
 434         reg |= IOPHY_PLL_P0_CTL1_PLL_RST;
 435         WR4(sc, XUSB_PADCTL_IOPHY_PLL_P0_CTL1, reg);
 436         DELAY(100);
 437
 438         for (i = 100; i > 0; i--) {
 439                 reg = RD4(sc, XUSB_PADCTL_IOPHY_PLL_P0_CTL1);
 440                 if (reg & IOPHY_PLL_P0_CTL1_PLL0_LOCKDET)
 441                         break;
 442                 DELAY(10);
 443         }
 444         if (i <= 0) {
 445                 device_printf(sc->dev, "Failed to power up PCIe phy\n");
 446                 return (ETIMEDOUT);
 447         }
 448         reg = RD4(sc, XUSB_PADCTL_USB3_PAD_MUX);
 449         reg |= USB3_PAD_MUX_PCIE_IDDQ_DISABLE(lane->idx);
 450         WR4(sc, XUSB_PADCTL_USB3_PAD_MUX, reg);
 451
 452         return (0);
 453 }
 454
 455 static int
 456 pcie_powerdown(struct padctl_softc *sc, struct padctl_lane *lane)
 457 {
 458         uint32_t reg;
 459
 460         reg = RD4(sc, XUSB_PADCTL_USB3_PAD_MUX);
 461         reg &= ~USB3_PAD_MUX_PCIE_IDDQ_DISABLE(lane->idx);
 462         WR4(sc, XUSB_PADCTL_USB3_PAD_MUX, reg);
 463
 464         reg = RD4(sc, XUSB_PADCTL_IOPHY_PLL_P0_CTL1);
 465         reg &= ~IOPHY_PLL_P0_CTL1_PLL_RST;
 466         WR4(sc, XUSB_PADCTL_IOPHY_PLL_P0_CTL1, reg);
 467         DELAY(100);
 468
 469         return (0);
 470
 471 }
 472
 473 static int
 474 sata_powerup(struct padctl_softc *sc, struct padctl_lane *lane)
 475 {
 476         uint32_t reg;
 477         int i;
 478
 479         reg = RD4(sc, XUSB_PADCTL_IOPHY_MISC_PAD_S0_CTL1);
 480         reg &= ~IOPHY_MISC_PAD_S0_CTL1_IDDQ_OVRD;
 481         reg &= ~IOPHY_MISC_PAD_S0_CTL1_IDDQ;
 482         WR4(sc, XUSB_PADCTL_IOPHY_MISC_PAD_S0_CTL1, reg);
 483
 484         reg = RD4(sc, XUSB_PADCTL_IOPHY_PLL_S0_CTL1);
 485         reg &= ~IOPHY_PLL_S0_CTL1_PLL_PWR_OVRD;
 486         reg &= ~IOPHY_PLL_S0_CTL1_PLL_IDDQ;
 487         WR4(sc, XUSB_PADCTL_IOPHY_PLL_S0_CTL1, reg);
 488
 489         reg = RD4(sc, XUSB_PADCTL_IOPHY_PLL_S0_CTL1);
 490         reg |= IOPHY_PLL_S0_CTL1_PLL1_MODE;
 491         WR4(sc, XUSB_PADCTL_IOPHY_PLL_S0_CTL1, reg);
 492
 493         reg = RD4(sc, XUSB_PADCTL_IOPHY_PLL_S0_CTL1);
 494         reg |= IOPHY_PLL_S0_CTL1_PLL_RST_L;
 495         WR4(sc, XUSB_PADCTL_IOPHY_PLL_S0_CTL1, reg);
 496
 497         for (i = 100; i >= 0; i--) {
 498                 reg = RD4(sc, XUSB_PADCTL_IOPHY_PLL_S0_CTL1);
 499                 if (reg & IOPHY_PLL_S0_CTL1_PLL1_LOCKDET)
 500                         break;
 501                 DELAY(100);
 502         }
 503         if (i <= 0) {
 504                 device_printf(sc->dev, "Failed to power up SATA phy\n");
 505                 return (ETIMEDOUT);
 506         }
 507         reg = RD4(sc, XUSB_PADCTL_USB3_PAD_MUX);
 508         reg |= IOPHY_PLL_S0_CTL1_PLL_RST_L;
 509         WR4(sc, XUSB_PADCTL_USB3_PAD_MUX, reg);
 510
 511         reg = RD4(sc, XUSB_PADCTL_USB3_PAD_MUX);
 512         reg |= USB3_PAD_MUX_SATA_IDDQ_DISABLE;
 513         WR4(sc, XUSB_PADCTL_USB3_PAD_MUX, reg);
 514
 515         return (0);
 516 }
 517
 518 static int
 519 sata_powerdown(struct padctl_softc *sc, struct padctl_lane *lane)
 520 {
 521         uint32_t reg;
 522
 523         reg = RD4(sc, XUSB_PADCTL_USB3_PAD_MUX);
 524         reg &= ~USB3_PAD_MUX_SATA_IDDQ_DISABLE;
 525         WR4(sc, XUSB_PADCTL_USB3_PAD_MUX, reg);
 526
 527         reg = RD4(sc, XUSB_PADCTL_IOPHY_PLL_S0_CTL1);
 528         reg &= ~IOPHY_PLL_S0_CTL1_PLL_RST_L;
 529         WR4(sc, XUSB_PADCTL_IOPHY_PLL_S0_CTL1, reg);
 530         DELAY(100);
 531
 532         reg = RD4(sc, XUSB_PADCTL_IOPHY_PLL_S0_CTL1);
 533         reg &= ~IOPHY_PLL_S0_CTL1_PLL1_MODE;
 534         WR4(sc, XUSB_PADCTL_IOPHY_PLL_S0_CTL1, reg);
 535         DELAY(100);
 536
 537         reg = RD4(sc, XUSB_PADCTL_IOPHY_PLL_S0_CTL1);
 538         reg |= IOPHY_PLL_S0_CTL1_PLL_PWR_OVRD;
 539         reg |= IOPHY_PLL_S0_CTL1_PLL_IDDQ;
 540         WR4(sc, XUSB_PADCTL_IOPHY_PLL_S0_CTL1, reg);
 541         DELAY(100);
 542
 543         reg = RD4(sc, XUSB_PADCTL_IOPHY_MISC_PAD_S0_CTL1);
 544         reg |= IOPHY_MISC_PAD_S0_CTL1_IDDQ_OVRD;
 545         reg |= IOPHY_MISC_PAD_S0_CTL1_IDDQ;
 546         WR4(sc, XUSB_PADCTL_IOPHY_MISC_PAD_S0_CTL1, reg);
 547         DELAY(100);
 548
 549         return (0);
 550 }
 551
 552 static int
 553 usb2_powerup(struct padctl_softc *sc, struct padctl_lane *lane)
 554 {
 555         uint32_t reg;
 556         struct padctl_port *port;
 557         int rv;
 558
 559         port = search_lane_port(sc, lane);
 560         if (port == NULL) {
 561                 device_printf(sc->dev, "Cannot find port for lane: %s\n",
 562                     lane->name);
 563         }
 564         reg = RD4(sc, XUSB_PADCTL_USB2_BIAS_PAD_CTL0);
 565         reg &= ~USB2_BIAS_PAD_CTL0_HS_SQUELCH_LEVEL(~0);
 566         reg &= ~USB2_BIAS_PAD_CTL0_HS_DISCON_LEVEL(~0);
 567         reg |= USB2_BIAS_PAD_CTL0_HS_SQUELCH_LEVEL(sc->hs_squelch_level);
 568         reg |= USB2_BIAS_PAD_CTL0_HS_DISCON_LEVEL(5);
 569         WR4(sc, XUSB_PADCTL_USB2_BIAS_PAD_CTL0, reg);
 570
 571         reg = RD4(sc, XUSB_PADCTL_USB2_PORT_CAP);
 572         reg &= ~USB2_PORT_CAP_PORT_CAP(lane->idx, ~0);
 573         reg |= USB2_PORT_CAP_PORT_CAP(lane->idx, USB2_PORT_CAP_PORT_CAP_HOST);
 574         WR4(sc, XUSB_PADCTL_USB2_PORT_CAP, reg);
 575
 576         reg = RD4(sc, XUSB_PADCTL_USB2_OTG_PAD_CTL0(lane->idx));
 577         reg &= ~USB2_OTG_PAD_CTL0_HS_CURR_LEVEL(~0);
 578         reg &= ~USB2_OTG_PAD_CTL0_HS_SLEW(~0);
 579         reg &= ~USB2_OTG_PAD_CTL0_LS_RSLEW(~0);
 580         reg &= ~USB2_OTG_PAD_CTL0_PD;
 581         reg &= ~USB2_OTG_PAD_CTL0_PD2;
 582         reg &= ~USB2_OTG_PAD_CTL0_PD_ZI;
 583
 584         reg |= USB2_OTG_PAD_CTL0_HS_SLEW(14);
 585         if (lane->idx == 0) {
 586                 reg |= USB2_OTG_PAD_CTL0_HS_CURR_LEVEL(sc->hs_curr_level_0);
 587                 reg |= USB2_OTG_PAD_CTL0_LS_RSLEW(3);
 588         } else {
 589                 reg |= USB2_OTG_PAD_CTL0_HS_CURR_LEVEL(sc->hs_curr_level_123);
 590                 reg |= USB2_OTG_PAD_CTL0_LS_RSLEW(0);
 591         }
 592         WR4(sc, XUSB_PADCTL_USB2_OTG_PAD_CTL0(lane->idx), reg);
 593
 594         reg = RD4(sc, XUSB_PADCTL_USB2_OTG_PAD_CTL1(lane->idx));
 595         reg &= ~USB2_OTG_PAD_CTL1_TERM_RANGE_ADJ(~0);
 596         reg &= ~USB2_OTG_PAD_CTL1_HS_IREF_CAP(~0);
 597         reg &= ~USB2_OTG_PAD_CTL1_PD_DR;
 598         reg &= ~USB2_OTG_PAD_CTL1_PD_DISC_FORCE_POWERUP;
 599         reg &= ~USB2_OTG_PAD_CTL1_PD_CHRP_FORCE_POWERUP;
 600
 601         reg |= USB2_OTG_PAD_CTL1_TERM_RANGE_ADJ(sc->hs_term_range_adj);
 602         reg |= USB2_OTG_PAD_CTL1_HS_IREF_CAP(sc->hs_iref_cap);
 603         WR4(sc, XUSB_PADCTL_USB2_OTG_PAD_CTL1(lane->idx), reg);
 604
 605         if (port != NULL && port->supply_vbus != NULL) {
 606                 rv = regulator_enable(port->supply_vbus);
 607                 if (rv != 0) {
 608                         device_printf(sc->dev,
 609                             "Cannot enable vbus regulator\n");
 610                         return (rv);
 611                 }
 612         }
 613         reg = RD4(sc, XUSB_PADCTL_USB2_BIAS_PAD_CTL0);
 614         reg &= ~USB2_BIAS_PAD_CTL0_PD;
 615         WR4(sc, XUSB_PADCTL_USB2_BIAS_PAD_CTL0, reg);
 616
 617         return (0);
 618 }
 619
 620 static int
 621 usb2_powerdown(struct padctl_softc *sc, struct padctl_lane *lane)
 622 {
 623         uint32_t reg;
 624         struct padctl_port *port;
 625         int rv;
 626
 627         port = search_lane_port(sc, lane);
 628         if (port == NULL) {
 629                 device_printf(sc->dev, "Cannot find port for lane: %s\n",
 630                     lane->name);
 631         }
 632         reg = RD4(sc, XUSB_PADCTL_USB2_BIAS_PAD_CTL0);
 633         reg |= USB2_BIAS_PAD_CTL0_PD;
 634         WR4(sc, XUSB_PADCTL_USB2_BIAS_PAD_CTL0, reg);
 635
 636         if (port != NULL && port->supply_vbus != NULL) {
 637                 rv = regulator_enable(port->supply_vbus);
 638                 if (rv != 0) {
 639                         device_printf(sc->dev,
 640                             "Cannot disable vbus regulator\n");
 641                         return (rv);
 642                 }
 643         }
 644         return (0);
 645 }
 646
 647
 648 static int
 649 phy_powerup(struct padctl_softc *sc)
 650 {
 651         uint32_t reg;
 652
 653         reg = RD4(sc, XUSB_PADCTL_ELPG_PROGRAM);
 654         reg &= ~ELPG_PROGRAM_AUX_MUX_LP0_VCORE_DOWN;
 655         WR4(sc, XUSB_PADCTL_ELPG_PROGRAM, reg);
 656         DELAY(100);
 657
 658         reg = RD4(sc, XUSB_PADCTL_ELPG_PROGRAM);
 659         reg &= ~ELPG_PROGRAM_AUX_MUX_LP0_CLAMP_EN;
 660         WR4(sc, XUSB_PADCTL_ELPG_PROGRAM, reg);
 661         DELAY(100);
 662
 663         reg = RD4(sc, XUSB_PADCTL_ELPG_PROGRAM);
 664         reg &= ~ELPG_PROGRAM_AUX_MUX_LP0_CLAMP_EN_EARLY;
 665         WR4(sc, XUSB_PADCTL_ELPG_PROGRAM, reg);
 666         DELAY(100);
 667
 668         return (0);
 669 }
 670
 671 static int
 672 phy_powerdown(struct padctl_softc *sc)
 673 {
 674         uint32_t reg;
 675
 676         reg = RD4(sc, XUSB_PADCTL_ELPG_PROGRAM);
 677         reg |= ELPG_PROGRAM_AUX_MUX_LP0_CLAMP_EN_EARLY;
 678         WR4(sc, XUSB_PADCTL_ELPG_PROGRAM, reg);
 679         DELAY(100);
 680
 681         reg = RD4(sc, XUSB_PADCTL_ELPG_PROGRAM);
 682         reg |= ELPG_PROGRAM_AUX_MUX_LP0_CLAMP_EN;
 683         WR4(sc, XUSB_PADCTL_ELPG_PROGRAM, reg);
 684         DELAY(100);
 685
 686         reg = RD4(sc, XUSB_PADCTL_ELPG_PROGRAM);
 687         reg |= ELPG_PROGRAM_AUX_MUX_LP0_VCORE_DOWN;
 688         WR4(sc, XUSB_PADCTL_ELPG_PROGRAM, reg);
 689         DELAY(100);
 690
 691         return (0);
 692 }
 693
 694 static int
 695 xusbpadctl_phy_enable(struct phynode *phy, bool enable)
 696 {
 697         device_t dev;
 698         intptr_t id;
 699         struct padctl_softc *sc;
 700         struct padctl_lane *lane;
 701         struct padctl_pad *pad;
 702         int rv;
 703
 704         dev = phynode_get_device(phy);
 705         id = phynode_get_id(phy);
 706         sc = device_get_softc(dev);
 707
 708         if (id < 0 || id >= nitems(lanes_tbl)) {
 709                 device_printf(dev, "Unknown phy: %d\n", id);
 710                 return (ENXIO);
 711         }
 712         lane = lanes_tbl + id;
 713         if (!lane->enabled) {
 714                 device_printf(dev, "Lane is not enabled/configured: %s\n",
 715                     lane->name);
 716                 return (ENXIO);
 717         }
 718         pad = lane->pad;
 719         if (enable) {
 720                 if (sc->phy_ena_cnt == 0) {
 721                         rv = phy_powerup(sc);
 722                         if (rv != 0)
 723                                 return (rv);
 724                 }
 725                 sc->phy_ena_cnt++;
 726         }
 727
 728         if (enable)
 729                 rv = pad->powerup(sc, lane);
 730         else
 731                 rv = pad->powerdown(sc, lane);
 732         if (rv != 0)
 733                 return (rv);
 734
 735         if (!enable) {
 736                  if (sc->phy_ena_cnt == 1) {
 737                         rv = phy_powerdown(sc);
 738                         if (rv != 0)
 739                                 return (rv);
 740                 }
 741                 sc->phy_ena_cnt--;
 742         }
 743
 744         return (0);
 745 }
 746
 747 /* -------------------------------------------------------------------------
 748  *
 749  *   FDT processing
 750  */
 751 static struct padctl_port *
 752 search_port(struct padctl_softc *sc, char *port_name)
 753 {
 754         int i;
 755
 756         for (i = 0; i < nitems(ports_tbl); i++) {
 757                 if (strcmp(port_name, ports_tbl[i].name) == 0)
 758                         return (&ports_tbl[i]);
 759         }
 760         return (NULL);
 761 }
 762
 763 static struct padctl_port *
 764 search_lane_port(struct padctl_softc *sc, struct padctl_lane *lane)
 765 {
 766         int i;
 767
 768         for (i = 0; i < nitems(ports_tbl); i++) {
 769                 if (!ports_tbl[i].enabled)
 770                         continue;
 771                 if (ports_tbl[i].lane == lane)
 772                         return (ports_tbl + i);
 773         }
 774         return (NULL);
 775 }
 776
 777 static struct padctl_lane *
 778 search_lane(struct padctl_softc *sc, char *lane_name)
 779 {
 780         int i;
 781
 782         for (i = 0; i < nitems(lanes_tbl); i++) {
 783                 if (strcmp(lane_name, lanes_tbl[i].name) == 0)
 784                         return  (lanes_tbl + i);
 785         }
 786         return (NULL);
 787 }
 788
 789 static struct padctl_lane *
 790 search_pad_lane(struct padctl_softc *sc, enum padctl_pad_type type, int idx)
 791 {
 792         int i;
 793
 794         for (i = 0; i < nitems(lanes_tbl); i++) {
 795                 if (!lanes_tbl[i].enabled)
 796                         continue;
 797                 if (type == lanes_tbl[i].pad->type && idx == lanes_tbl[i].idx)
 798                         return  (lanes_tbl + i);
 799         }
 800         return (NULL);
 801 }
 802
 803 static struct padctl_lane *
 804 search_usb3_pad_lane(struct padctl_softc *sc, int idx)
 805 {
 806         int i;
 807         struct padctl_lane *lane, *tmp;
 808
 809         lane = NULL;
 810         for (i = 0; i < nitems(lane_map_tbl); i++) {
 811                 if (idx != lane_map_tbl[i].port_idx)
 812                         continue;
 813                 tmp = search_pad_lane(sc, lane_map_tbl[i].pad_type,
 814                     lane_map_tbl[i].lane_idx);
 815                 if (tmp == NULL)
 816                         continue;
 817                 if (strcmp(tmp->mux[tmp->mux_idx], "usb3-ss") != 0)
 818                         continue;
 819                 if (lane != NULL) {
 820                         device_printf(sc->dev, "Duplicated mappings found for"
 821                          " lanes: %s and %s\n", lane->name, tmp->name);
 822                         return (NULL);
 823                 }
 824                 lane = tmp;
 825         }
 826         return (lane);
 827 }
 828
 829 static struct padctl_pad *
 830 search_pad(struct padctl_softc *sc, char *pad_name)
 831 {
 832         int i;
 833
 834         for (i = 0; i < nitems(pads_tbl); i++) {
 835                 if (strcmp(pad_name, pads_tbl[i].name) == 0)
 836                         return  (pads_tbl + i);
 837         }
 838         return (NULL);
 839 }
 840
 841 static int
 842 search_mux(struct padctl_softc *sc, struct padctl_lane *lane, char *fnc_name)
 843 {
 844         int i;
 845
 846         for (i = 0; i < lane->nmux; i++) {
 847                 if (strcmp(fnc_name, lane->mux[i]) == 0)
 848                         return  (i);
 849         }
 850         return (-1);
 851 }
 852
 853 static int
 854 config_lane(struct padctl_softc *sc, struct padctl_lane *lane)
 855 {
 856         uint32_t reg;
 857
 858         reg = RD4(sc, lane->reg);
 859         reg &= ~(lane->mask << lane->shift);
 860         reg |=  (lane->mux_idx & lane->mask) << lane->shift;
 861         WR4(sc, lane->reg, reg);
 862         return (0);
 863 }
 864
 865 static int
 866 process_lane(struct padctl_softc *sc, phandle_t node, struct padctl_pad *pad)
 867 {
 868         struct padctl_lane *lane;
 869         struct phynode *phynode;
 870         struct phynode_init_def phy_init;
 871         char *name;
 872         char *function;
 873         int rv;
 874
 875         name = NULL;
 876         function = NULL;
 877         rv = OF_getprop_alloc(node, "name", (void **)&name);
 878         if (rv <= 0) {
 879                 device_printf(sc->dev, "Cannot read lane name.\n");
 880                 return (ENXIO);
 881         }
 882
 883         lane = search_lane(sc, name);
 884         if (lane == NULL) {
 885                 device_printf(sc->dev, "Unknown lane: %s\n", name);
 886                 rv = ENXIO;
 887                 goto end;
 888         }
 889
 890         /* Read function (mux) settings. */
 891         rv = OF_getprop_alloc(node, "nvidia,function", (void **)&function);
 892         if (rv <= 0) {
 893                 device_printf(sc->dev, "Cannot read lane function.\n");
 894                 rv = ENXIO;
 895                 goto end;
 896         }
 897
 898         lane->mux_idx = search_mux(sc, lane, function);
 899         if (lane->mux_idx == ~0) {
 900                 device_printf(sc->dev, "Unknown function %s for lane %s\n",
 901                     function, name);
 902                 rv = ENXIO;
 903                 goto end;
 904         }
 905
 906         rv = config_lane(sc, lane);
 907         if (rv != 0) {
 908                 device_printf(sc->dev, "Cannot configure lane: %s: %d\n",
 909                     name, rv);
 910                 rv = ENXIO;
 911                 goto end;
 912         }
 913         lane->pad = pad;
 914         lane->enabled = true;
 915         pad->lanes[pad->nlanes++] = lane;
 916
 917         /* Create and register phy. */
 918         bzero(&phy_init, sizeof(phy_init));
 919         phy_init.id = lane - lanes_tbl;
 920         phy_init.ofw_node = node;
 921         phynode = phynode_create(sc->dev, &xusbpadctl_phynode_class, &phy_init);
 922         if (phynode == NULL) {
 923                 device_printf(sc->dev, "Cannot create phy\n");
 924                 rv = ENXIO;
 925                 goto end;
 926         }
 927         if (phynode_register(phynode) == NULL) {
 928                 device_printf(sc->dev, "Cannot create phy\n");
 929                 return (ENXIO);
 930         }
 931
 932         rv = 0;
 933
 934 end:
 935         if (name != NULL)
 936                 OF_prop_free(name);
 937         if (function != NULL)
 938                 OF_prop_free(function);
 939         return (rv);
 940 }
 941
 942 static int
 943 process_pad(struct padctl_softc *sc, phandle_t node)
 944 {
 945         struct padctl_pad *pad;
 946         char *name;
 947         int rv;
 948
 949         name = NULL;
 950         rv = OF_getprop_alloc(node, "name", (void **)&name);
 951         if (rv <= 0) {
 952                 device_printf(sc->dev, "Cannot read pad name.\n");
 953                 return (ENXIO);
 954         }
 955         pad = search_pad(sc, name);
 956         if (pad == NULL) {
 957                 device_printf(sc->dev, "Unknown pad: %s\n", name);
 958                 rv = ENXIO;
 959                 goto end;
 960         }
 961
 962         /* Read and process associated lanes. */
 963         node = ofw_bus_find_child(node, "lanes");
 964         if (node <= 0) {
 965                 device_printf(sc->dev, "Cannot find regulators subnode\n");
 966                 rv = ENXIO;
 967                 goto end;
 968         }
 969
 970         for (node = OF_child(node); node != 0; node = OF_peer(node)) {
 971                 if (!ofw_bus_node_status_okay(node))
 972                         continue;
 973
 974                 rv = process_lane(sc, node, pad);
 975                 if (rv != 0)
 976                         goto end;
 977         }
 978         pad->enabled = true;
 979         rv = 0;
 980 end:
 981         if (name != NULL)
 982                 OF_prop_free(name);
 983         return (rv);
 984 }
 985
 986 static int
 987 process_port(struct padctl_softc *sc, phandle_t node)
 988 {
 989
 990         struct padctl_port *port;
 991         char *name;
 992         int rv;
 993
 994         name = NULL;
 995         rv = OF_getprop_alloc(node, "name", (void **)&name);
 996         if (rv <= 0) {
 997                 device_printf(sc->dev, "Cannot read port name.\n");
 998                 return (ENXIO);
 999         }
1000
1001         port = search_port(sc, name);
1002         if (port == NULL) {
1003                 device_printf(sc->dev, "Unknown port: %s\n", name);
1004                 rv = ENXIO;
1005                 goto end;
1006         }
1007
1008         if (port->type == PADCTL_PORT_USB3) {
1009                 rv = OF_getencprop(node,  "nvidia,usb2-companion",
1010                    &(port->companion), sizeof(port->companion));
1011                 if (rv <= 0) {
1012                         device_printf(sc->dev,
1013                             "Missing 'nvidia,usb2-companion' property "
1014                             "for port: %s\n", name);
1015                         rv = ENXIO;
1016                         goto end;
1017                 }
1018         }
1019
1020         if (OF_hasprop(node, "vbus-supply")) {
1021                 rv = regulator_get_by_ofw_property(sc->dev, 0,
1022                     "vbus-supply", &port->supply_vbus);
1023                 if (rv <= 0) {
1024                         device_printf(sc->dev,
1025                             "Cannot get 'vbus-supply' regulator "
1026                             "for port: %s\n", name);
1027                         rv = ENXIO;
1028                         goto end;
1029                 }
1030         }
1031
1032         if (OF_hasprop(node, "nvidia,internal"))
1033                 port->internal = true;
1034         /* Find assigned lane */
1035         if (port->lane == NULL) {
1036                 switch(port->type) {
1037                 /* Routing is fixed for USB2, ULPI AND HSIC. */
1038                 case PADCTL_PORT_USB2:
1039                         port->lane = search_pad_lane(sc, PADCTL_PAD_USB2,
1040                             port->idx);
1041                         break;
1042                 case PADCTL_PORT_ULPI:
1043                         port->lane = search_pad_lane(sc, PADCTL_PAD_ULPI,
1044                             port->idx);
1045                         break;
1046                 case PADCTL_PORT_HSIC:
1047                         port->lane = search_pad_lane(sc, PADCTL_PAD_HSIC,
1048                             port->idx);
1049                         break;
1050                 case PADCTL_PORT_USB3:
1051                         port->lane = search_usb3_pad_lane(sc, port->idx);
1052                         break;
1053                 }
1054         }
1055         if (port->lane == NULL) {
1056                 device_printf(sc->dev, "Cannot find lane for port: %s\n", name);
1057                 rv = ENXIO;
1058                 goto end;
1059         }
1060         port->enabled = true;
1061         rv = 0;
1062 end:
1063         if (name != NULL)
1064                 OF_prop_free(name);
1065         return (rv);
1066 }
1067
1068 static int
1069 parse_fdt(struct padctl_softc *sc, phandle_t base_node)
1070 {
1071         phandle_t node;
1072         int rv;
1073
1074         rv = 0;
1075         node = ofw_bus_find_child(base_node, "pads");
1076
1077         if (node <= 0) {
1078                 device_printf(sc->dev, "Cannot find pads subnode.\n");
1079                 return (ENXIO);
1080         }
1081         for (node = OF_child(node); node != 0; node = OF_peer(node)) {
1082                 if (!ofw_bus_node_status_okay(node))
1083                         continue;
1084                 rv = process_pad(sc, node);
1085                 if (rv != 0)
1086                         return (rv);
1087         }
1088
1089         node = ofw_bus_find_child(base_node, "ports");
1090         if (node <= 0) {
1091                 device_printf(sc->dev, "Cannot find ports subnode.\n");
1092                 return (ENXIO);
1093         }
1094         for (node = OF_child(node); node != 0; node = OF_peer(node)) {
1095                 if (!ofw_bus_node_status_okay(node))
1096                         continue;
1097                 rv = process_port(sc, node);
1098                 if (rv != 0)
1099                         return (rv);
1100         }
1101
1102         return (0);
1103 }
1104
1105 static void
1106 load_calibration(struct padctl_softc *sc)
1107 {
1108         uint32_t reg;
1109
1110         /* All XUSB pad calibrations are packed into single dword.*/
1111         reg = tegra_fuse_read_4(FUSE_XUSB_CALIB);
1112         sc->hs_curr_level_0 = FUSE_XUSB_CALIB_HS_CURR_LEVEL_0(reg);
1113         sc->hs_curr_level_123 = FUSE_XUSB_CALIB_HS_CURR_LEVEL_123(reg);
1114         sc->hs_iref_cap = FUSE_XUSB_CALIB_HS_IREF_CAP(reg);
1115         sc->hs_squelch_level = FUSE_XUSB_CALIB_HS_SQUELCH_LEVEL(reg);
1116         sc->hs_term_range_adj = FUSE_XUSB_CALIB_HS_TERM_RANGE_ADJ(reg);
1117 }
1118
1119 /* -------------------------------------------------------------------------
1120  *
1121  *   BUS functions
1122  */
1123 static int
1124 xusbpadctl_probe(device_t dev)
1125 {
1126
1127         if (!ofw_bus_status_okay(dev))
1128                 return (ENXIO);
1129
1130         if (!ofw_bus_search_compatible(dev, compat_data)->ocd_data)
1131                 return (ENXIO);
1132
1133         device_set_desc(dev, "Tegra XUSB phy");
1134         return (BUS_PROBE_DEFAULT);
1135 }
1136
1137 static int
1138 xusbpadctl_detach(device_t dev)
1139 {
1140
1141         /* This device is always present. */
1142         return (EBUSY);
1143 }
1144
1145 static int
1146 xusbpadctl_attach(device_t dev)
1147 {
1148         struct padctl_softc * sc;
1149         int i, rid, rv;
1150         struct padctl_port *port;
1151         phandle_t node;
1152
1153         sc = device_get_softc(dev);
1154         sc->dev = dev;
1155         node = ofw_bus_get_node(dev);
1156
1157         rid = 0;
1158         sc->mem_res = bus_alloc_resource_any(dev, SYS_RES_MEMORY, &rid,
1159             RF_ACTIVE);
1160         if (sc->mem_res == NULL) {
1161                 device_printf(dev, "Cannot allocate memory resources\n");
1162                 return (ENXIO);
1163         }
1164
1165         rv = hwreset_get_by_ofw_name(dev, 0, "padctl", &sc->rst);
1166         if (rv != 0) {
1167                 device_printf(dev, "Cannot get 'padctl' reset: %d\n", rv);
1168                 return (rv);
1169         }
1170         rv = hwreset_deassert(sc->rst);
1171         if (rv != 0) {
1172                 device_printf(dev, "Cannot unreset 'padctl' reset: %d\n", rv);
1173                 return (rv);
1174         }
1175
1176         load_calibration(sc);
1177
1178         rv = parse_fdt(sc, node);
1179         if (rv != 0) {
1180                 device_printf(dev, "Cannot parse fdt configuration: %d\n", rv);
1181                 return (rv);
1182         }
1183         for (i = 0; i < nitems(ports_tbl); i++) {
1184                 port = ports_tbl + i;
1185                 if (!port->enabled)
1186                         continue;
1187                 if (port->init == NULL)
1188                         continue;
1189                 rv = port->init(sc, port);
1190                 if (rv != 0) {
1191                         device_printf(dev, "Cannot init port '%s'\n",
1192                             port->name);
1193                         return (rv);
1194                 }
1195         }
1196         return (0);
1197 }
1198
1199 static device_method_t tegra_xusbpadctl_methods[] = {
1200         /* Device interface */
1201         DEVMETHOD(device_probe,         xusbpadctl_probe),
1202         DEVMETHOD(device_attach,        xusbpadctl_attach),
1203         DEVMETHOD(device_detach,        xusbpadctl_detach),
1204
1205         DEVMETHOD_END
1206 };
1207
1208 static devclass_t tegra_xusbpadctl_devclass;
1209 static DEFINE_CLASS_0(xusbpadctl, tegra_xusbpadctl_driver,
1210     tegra_xusbpadctl_methods, sizeof(struct padctl_softc));
1211 EARLY_DRIVER_MODULE(tegra_xusbpadctl, simplebus, tegra_xusbpadctl_driver,
1212     tegra_xusbpadctl_devclass, NULL, NULL, 73);