Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
FreeBSD/Linux Kernel Cross Reference
sys/arm/nvidia/tegra_pcie.c
Version:
- FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
SearchContext: - none - 3 - 10
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 /* 31 * Nvidia Integrated PCI/PCI-Express controller driver. 32 */ 33 34 #include <sys/param.h> 35 #include <sys/systm.h> 36 #include <sys/bus.h> 37 #include <sys/devmap.h> 38 #include <sys/proc.h> 39 #include <sys/kernel.h> 40 #include <sys/malloc.h> 41 #include <sys/module.h> 42 #include <sys/mutex.h> 43 #include <sys/rman.h> 44 45 #include <machine/intr.h> 46 47 #include <vm/vm.h> 48 #include <vm/vm_extern.h> 49 #include <vm/vm_kern.h> 50 #include <vm/pmap.h> 51 52 #include <dev/extres/clk/clk.h> 53 #include <dev/extres/hwreset/hwreset.h> 54 #include <dev/extres/phy/phy.h> 55 #include <dev/extres/regulator/regulator.h> 56 #include <dev/ofw/ofw_bus.h> 57 #include <dev/ofw/ofw_bus_subr.h> 58 #include <dev/ofw/ofw_pci.h> 59 #include <dev/ofw/ofwpci.h> 60 #include <dev/pci/pcivar.h> 61 #include <dev/pci/pcireg.h> 62 #include <dev/pci/pcib_private.h> 63 64 #include <machine/resource.h> 65 #include <machine/bus.h> 66 67 #include <arm/nvidia/tegra_pmc.h> 68 69 #include "ofw_bus_if.h" 70 #include "msi_if.h" 71 #include "pcib_if.h" 72 #include "pic_if.h" 73 74 #define AFI_AXI_BAR0_SZ 0x000 75 #define AFI_AXI_BAR1_SZ 0x004 76 #define AFI_AXI_BAR2_SZ 0x008 77 #define AFI_AXI_BAR3_SZ 0x00c 78 #define AFI_AXI_BAR4_SZ 0x010 79 #define AFI_AXI_BAR5_SZ 0x014 80 #define AFI_AXI_BAR0_START 0x018 81 #define AFI_AXI_BAR1_START 0x01c 82 #define AFI_AXI_BAR2_START 0x020 83 #define AFI_AXI_BAR3_START 0x024 84 #define AFI_AXI_BAR4_START 0x028 85 #define AFI_AXI_BAR5_START 0x02c 86 #define AFI_FPCI_BAR0 0x030 87 #define AFI_FPCI_BAR1 0x034 88 #define AFI_FPCI_BAR2 0x038 89 #define AFI_FPCI_BAR3 0x03c 90 #define AFI_FPCI_BAR4 0x040 91 #define AFI_FPCI_BAR5 0x044 92 #define AFI_MSI_BAR_SZ 0x060 93 #define AFI_MSI_FPCI_BAR_ST 0x064 94 #define AFI_MSI_AXI_BAR_ST 0x068 95 #define AFI_MSI_VEC(x) (0x06c + 4 * (x)) 96 #define AFI_MSI_EN_VEC(x) (0x08c + 4 * (x)) 97 #define AFI_MSI_INTR_IN_REG 32 98 #define AFI_MSI_REGS 8 99 100 #define AFI_CONFIGURATION 0x0ac 101 #define AFI_CONFIGURATION_EN_FPCI (1 << 0) 102 103 #define AFI_FPCI_ERROR_MASKS 0x0b0 104 #define AFI_INTR_MASK 0x0b4 105 #define AFI_INTR_MASK_MSI_MASK (1 << 8) 106 #define AFI_INTR_MASK_INT_MASK (1 << 0) 107 108 #define AFI_INTR_CODE 0x0b8 109 #define AFI_INTR_CODE_MASK 0xf 110 #define AFI_INTR_CODE_INT_CODE_INI_SLVERR 1 111 #define AFI_INTR_CODE_INT_CODE_INI_DECERR 2 112 #define AFI_INTR_CODE_INT_CODE_TGT_SLVERR 3 113 #define AFI_INTR_CODE_INT_CODE_TGT_DECERR 4 114 #define AFI_INTR_CODE_INT_CODE_TGT_WRERR 5 115 #define AFI_INTR_CODE_INT_CODE_SM_MSG 6 116 #define AFI_INTR_CODE_INT_CODE_DFPCI_DECERR 7 117 #define AFI_INTR_CODE_INT_CODE_AXI_DECERR 8 118 #define AFI_INTR_CODE_INT_CODE_FPCI_TIMEOUT 9 119 #define AFI_INTR_CODE_INT_CODE_PE_PRSNT_SENSE 10 120 #define AFI_INTR_CODE_INT_CODE_PE_CLKREQ_SENSE 11 121 #define AFI_INTR_CODE_INT_CODE_CLKCLAMP_SENSE 12 122 #define AFI_INTR_CODE_INT_CODE_RDY4PD_SENSE 13 123 #define AFI_INTR_CODE_INT_CODE_P2P_ERROR 14 124 125 #define AFI_INTR_SIGNATURE 0x0bc 126 #define AFI_UPPER_FPCI_ADDRESS 0x0c0 127 #define AFI_SM_INTR_ENABLE 0x0c4 128 #define AFI_SM_INTR_RP_DEASSERT (1 << 14) 129 #define AFI_SM_INTR_RP_ASSERT (1 << 13) 130 #define AFI_SM_INTR_HOTPLUG (1 << 12) 131 #define AFI_SM_INTR_PME (1 << 11) 132 #define AFI_SM_INTR_FATAL_ERROR (1 << 10) 133 #define AFI_SM_INTR_UNCORR_ERROR (1 << 9) 134 #define AFI_SM_INTR_CORR_ERROR (1 << 8) 135 #define AFI_SM_INTR_INTD_DEASSERT (1 << 7) 136 #define AFI_SM_INTR_INTC_DEASSERT (1 << 6) 137 #define AFI_SM_INTR_INTB_DEASSERT (1 << 5) 138 #define AFI_SM_INTR_INTA_DEASSERT (1 << 4) 139 #define AFI_SM_INTR_INTD_ASSERT (1 << 3) 140 #define AFI_SM_INTR_INTC_ASSERT (1 << 2) 141 #define AFI_SM_INTR_INTB_ASSERT (1 << 1) 142 #define AFI_SM_INTR_INTA_ASSERT (1 << 0) 143 144 #define AFI_AFI_INTR_ENABLE 0x0c8 145 #define AFI_AFI_INTR_ENABLE_CODE(code) (1 << (code)) 146 147 #define AFI_PCIE_CONFIG 0x0f8 148 #define AFI_PCIE_CONFIG_PCIE_DISABLE(x) (1 << ((x) + 1)) 149 #define AFI_PCIE_CONFIG_PCIE_DISABLE_ALL 0x6 150 #define AFI_PCIE_CONFIG_SM2TMS0_XBAR_CONFIG_MASK (0xf << 20) 151 #define AFI_PCIE_CONFIG_SM2TMS0_XBAR_CONFIG_XBAR2_1 (0x0 << 20) 152 #define AFI_PCIE_CONFIG_SM2TMS0_XBAR_CONFIG_XBAR4_1 (0x1 << 20) 153 154 #define AFI_FUSE 0x104 155 #define AFI_FUSE_PCIE_T0_GEN2_DIS (1 << 2) 156 157 #define AFI_PEX0_CTRL 0x110 158 #define AFI_PEX1_CTRL 0x118 159 #define AFI_PEX2_CTRL 0x128 160 #define AFI_PEX_CTRL_OVERRIDE_EN (1 << 4) 161 #define AFI_PEX_CTRL_REFCLK_EN (1 << 3) 162 #define AFI_PEX_CTRL_CLKREQ_EN (1 << 1) 163 #define AFI_PEX_CTRL_RST_L (1 << 0) 164 165 #define AFI_AXI_BAR6_SZ 0x134 166 #define AFI_AXI_BAR7_SZ 0x138 167 #define AFI_AXI_BAR8_SZ 0x13c 168 #define AFI_AXI_BAR6_START 0x140 169 #define AFI_AXI_BAR7_START 0x144 170 #define AFI_AXI_BAR8_START 0x148 171 #define AFI_FPCI_BAR6 0x14c 172 #define AFI_FPCI_BAR7 0x150 173 #define AFI_FPCI_BAR8 0x154 174 #define AFI_PLLE_CONTROL 0x160 175 #define AFI_PLLE_CONTROL_BYPASS_PADS2PLLE_CONTROL (1 << 9) 176 #define AFI_PLLE_CONTROL_BYPASS_PCIE2PLLE_CONTROL (1 << 8) 177 #define AFI_PLLE_CONTROL_PADS2PLLE_CONTROL_EN (1 << 1) 178 #define AFI_PLLE_CONTROL_PCIE2PLLE_CONTROL_EN (1 << 0) 179 180 #define AFI_PEXBIAS_CTRL 0x168 181 182 /* Configuration space */ 183 #define RP_VEND_XP 0x0F00 184 #define RP_VEND_XP_DL_UP (1 << 30) 185 186 #define RP_VEND_CTL2 0x0fa8 187 #define RP_VEND_CTL2_PCA_ENABLE (1 << 7) 188 189 #define RP_PRIV_MISC 0x0FE0 190 #define RP_PRIV_MISC_PRSNT_MAP_EP_PRSNT (0xE << 0) 191 #define RP_PRIV_MISC_PRSNT_MAP_EP_ABSNT (0xF << 0) 192 193 #define RP_LINK_CONTROL_STATUS 0x0090 194 #define RP_LINK_CONTROL_STATUS_DL_LINK_ACTIVE 0x20000000 195 #define RP_LINK_CONTROL_STATUS_LINKSTAT_MASK 0x3fff0000 196 197 /* PADS space */ 198 #define PADS_REFCLK_CFG0 0x000c8 199 #define PADS_REFCLK_CFG1 0x000cc 200 201 202 /* Wait 50 ms (per port) for link. */ 203 #define TEGRA_PCIE_LINKUP_TIMEOUT 50000 204 205 /* FPCI Address space */ 206 #define FPCI_MAP_IO 0xFDFC000000ULL 207 #define FPCI_MAP_TYPE0_CONFIG 0xFDFC000000ULL 208 #define FPCI_MAP_TYPE1_CONFIG 0xFDFF000000ULL 209 #define FPCI_MAP_EXT_TYPE0_CONFIG 0xFE00000000ULL 210 #define FPCI_MAP_EXT_TYPE1_CONFIG 0xFE10000000ULL 211 212 #define TEGRA_PCIB_MSI_ENABLE 213 214 #define DEBUG 215 #ifdef DEBUG 216 #define debugf(fmt, args...) do { printf(fmt,##args); } while (0) 217 #else 218 #define debugf(fmt, args...) 219 #endif 220 221 /* 222 * Configuration space format: 223 * [27:24] extended register 224 * [23:16] bus 225 * [15:11] slot (device) 226 * [10: 8] function 227 * [ 7: 0] register 228 */ 229 #define PCI_CFG_EXT_REG(reg) ((((reg) >> 8) & 0x0f) << 24) 230 #define PCI_CFG_BUS(bus) (((bus) & 0xff) << 16) 231 #define PCI_CFG_DEV(dev) (((dev) & 0x1f) << 11) 232 #define PCI_CFG_FUN(fun) (((fun) & 0x07) << 8) 233 #define PCI_CFG_BASE_REG(reg) ((reg) & 0xff) 234 235 #define PADS_WR4(_sc, _r, _v) bus_write_4((_sc)->pads_mem_res, (_r), (_v)) 236 #define PADS_RD4(_sc, _r) bus_read_4((_sc)->pads_mem_res, (_r)) 237 #define AFI_WR4(_sc, _r, _v) bus_write_4((_sc)->afi_mem_res, (_r), (_v)) 238 #define AFI_RD4(_sc, _r) bus_read_4((_sc)->afi_mem_res, (_r)) 239 240 static struct { 241 bus_size_t axi_start; 242 bus_size_t fpci_start; 243 bus_size_t size; 244 } bars[] = { 245 {AFI_AXI_BAR0_START, AFI_FPCI_BAR0, AFI_AXI_BAR0_SZ}, /* BAR 0 */ 246 {AFI_AXI_BAR1_START, AFI_FPCI_BAR1, AFI_AXI_BAR1_SZ}, /* BAR 1 */ 247 {AFI_AXI_BAR2_START, AFI_FPCI_BAR2, AFI_AXI_BAR2_SZ}, /* BAR 2 */ 248 {AFI_AXI_BAR3_START, AFI_FPCI_BAR3, AFI_AXI_BAR3_SZ}, /* BAR 3 */ 249 {AFI_AXI_BAR4_START, AFI_FPCI_BAR4, AFI_AXI_BAR4_SZ}, /* BAR 4 */ 250 {AFI_AXI_BAR5_START, AFI_FPCI_BAR5, AFI_AXI_BAR5_SZ}, /* BAR 5 */ 251 {AFI_AXI_BAR6_START, AFI_FPCI_BAR6, AFI_AXI_BAR6_SZ}, /* BAR 6 */ 252 {AFI_AXI_BAR7_START, AFI_FPCI_BAR7, AFI_AXI_BAR7_SZ}, /* BAR 7 */ 253 {AFI_AXI_BAR8_START, AFI_FPCI_BAR8, AFI_AXI_BAR8_SZ}, /* BAR 8 */ 254 {AFI_MSI_AXI_BAR_ST, AFI_MSI_FPCI_BAR_ST, AFI_MSI_BAR_SZ}, /* MSI 9 */ 255 }; 256 257 258 struct pcie_soc { 259 char **regulator_names; 260 bool cml_clk; 261 bool pca_enable; 262 uint32_t pads_refclk_cfg0; 263 uint32_t pads_refclk_cfg1; 264 }; 265 266 /* Tegra 124 config. */ 267 static char *tegra124_reg_names[] = { 268 "avddio-pex-supply", 269 "dvddio-pex-supply", 270 "avdd-pex-pll-supply", 271 "hvdd-pex-supply", 272 "hvdd-pex-pll-e-supply", 273 "vddio-pex-ctl-supply", 274 "avdd-pll-erefe-supply", 275 NULL 276 }; 277 278 static struct pcie_soc tegra124_soc = { 279 .regulator_names = tegra124_reg_names, 280 .cml_clk = true, 281 .pca_enable = false, 282 .pads_refclk_cfg0 = 0x44ac44ac, 283 }; 284 285 /* Tegra 210 config. */ 286 static char *tegra210_reg_names[] = { 287 "avdd-pll-uerefe-supply", 288 "hvddio-pex-supply", 289 "dvddio-pex-supply", 290 "dvdd-pex-pll-supply", 291 "hvdd-pex-pll-e-supply", 292 "vddio-pex-ctl-supply", 293 NULL 294 }; 295 296 static struct pcie_soc tegra210_soc = { 297 .regulator_names = tegra210_reg_names, 298 .cml_clk = true, 299 .pca_enable = true, 300 .pads_refclk_cfg0 = 0x90b890b8, 301 }; 302 303 /* Compatible devices. */ 304 static struct ofw_compat_data compat_data[] = { 305 {"nvidia,tegra124-pcie", (uintptr_t)&tegra124_soc}, 306 {"nvidia,tegra210-pcie", (uintptr_t)&tegra210_soc}, 307 {NULL, 0}, 308 }; 309 310 #define TEGRA_FLAG_MSI_USED 0x0001 311 struct tegra_pcib_irqsrc { 312 struct intr_irqsrc isrc; 313 u_int irq; 314 u_int flags; 315 }; 316 317 struct tegra_pcib_port { 318 int enabled; 319 int port_idx; /* chip port index */ 320 int num_lanes; /* number of lanes */ 321 bus_size_t afi_pex_ctrl; /* offset of afi_pex_ctrl */ 322 phy_t phy; /* port phy */ 323 324 /* Config space properties. */ 325 bus_addr_t rp_base_addr; /* PA of config window */ 326 bus_size_t rp_size; /* size of config window */ 327 bus_space_handle_t cfg_handle; /* handle of config window */ 328 }; 329 330 #define TEGRA_PCIB_MAX_PORTS 3 331 #define TEGRA_PCIB_MAX_MSI AFI_MSI_INTR_IN_REG * AFI_MSI_REGS 332 struct tegra_pcib_softc { 333 struct ofw_pci_softc ofw_pci; 334 device_t dev; 335 struct pcie_soc *soc; 336 struct mtx mtx; 337 struct resource *pads_mem_res; 338 struct resource *afi_mem_res; 339 struct resource *cfg_mem_res; 340 struct resource *irq_res; 341 struct resource *msi_irq_res; 342 void *intr_cookie; 343 void *msi_intr_cookie; 344 345 struct ofw_pci_range mem_range; 346 struct ofw_pci_range pref_mem_range; 347 struct ofw_pci_range io_range; 348 349 clk_t clk_pex; 350 clk_t clk_afi; 351 clk_t clk_pll_e; 352 clk_t clk_cml; 353 hwreset_t hwreset_pex; 354 hwreset_t hwreset_afi; 355 hwreset_t hwreset_pcie_x; 356 regulator_t regulators[16]; /* Safe maximum */ 357 358 vm_offset_t msi_page; /* VA of MSI page */ 359 bus_addr_t cfg_base_addr; /* base address of config */ 360 bus_size_t cfg_cur_offs; /* currently mapped window */ 361 bus_space_handle_t cfg_handle; /* handle of config window */ 362 bus_space_tag_t bus_tag; /* tag of config window */ 363 int lanes_cfg; 364 int num_ports; 365 struct tegra_pcib_port *ports[TEGRA_PCIB_MAX_PORTS]; 366 struct tegra_pcib_irqsrc *isrcs; 367 }; 368 369 static int 370 tegra_pcib_maxslots(device_t dev) 371 { 372 return (16); 373 } 374 375 static int 376 tegra_pcib_route_interrupt(device_t bus, device_t dev, int pin) 377 { 378 struct tegra_pcib_softc *sc; 379 u_int irq; 380 381 sc = device_get_softc(bus); 382 irq = intr_map_clone_irq(rman_get_start(sc->irq_res)); 383 device_printf(bus, "route pin %d for device %d.%d to %u\n", 384 pin, pci_get_slot(dev), pci_get_function(dev), 385 irq); 386 387 return (irq); 388 } 389 390 static int 391 tegra_pcbib_map_cfg(struct tegra_pcib_softc *sc, u_int bus, u_int slot, 392 u_int func, u_int reg) 393 { 394 bus_size_t offs; 395 int rv; 396 397 offs = sc->cfg_base_addr; 398 offs |= PCI_CFG_BUS(bus) | PCI_CFG_DEV(slot) | PCI_CFG_FUN(func) | 399 PCI_CFG_EXT_REG(reg); 400 if ((sc->cfg_handle != 0) && (sc->cfg_cur_offs == offs)) 401 return (0); 402 if (sc->cfg_handle != 0) 403 bus_space_unmap(sc->bus_tag, sc->cfg_handle, 0x800); 404 405 rv = bus_space_map(sc->bus_tag, offs, 0x800, 0, &sc->cfg_handle); 406 if (rv != 0) 407 device_printf(sc->dev, "Cannot map config space\n"); 408 else 409 sc->cfg_cur_offs = offs; 410 return (rv); 411 } 412 413 static uint32_t 414 tegra_pcib_read_config(device_t dev, u_int bus, u_int slot, u_int func, 415 u_int reg, int bytes) 416 { 417 struct tegra_pcib_softc *sc; 418 bus_space_handle_t hndl; 419 uint32_t off; 420 uint32_t val; 421 int rv, i; 422 423 sc = device_get_softc(dev); 424 if (bus == 0) { 425 if (func != 0) 426 return (0xFFFFFFFF); 427 for (i = 0; i < TEGRA_PCIB_MAX_PORTS; i++) { 428 if ((sc->ports[i] != NULL) && 429 (sc->ports[i]->port_idx == slot)) { 430 hndl = sc->ports[i]->cfg_handle; 431 off = reg & 0xFFF; 432 break; 433 } 434 } 435 if (i >= TEGRA_PCIB_MAX_PORTS) 436 return (0xFFFFFFFF); 437 } else { 438 rv = tegra_pcbib_map_cfg(sc, bus, slot, func, reg); 439 if (rv != 0) 440 return (0xFFFFFFFF); 441 hndl = sc->cfg_handle; 442 off = PCI_CFG_BASE_REG(reg); 443 } 444 445 val = bus_space_read_4(sc->bus_tag, hndl, off & ~3); 446 switch (bytes) { 447 case 4: 448 break; 449 case 2: 450 if (off & 3) 451 val >>= 16; 452 val &= 0xffff; 453 break; 454 case 1: 455 val >>= ((off & 3) << 3); 456 val &= 0xff; 457 break; 458 } 459 return val; 460 } 461 462 static void 463 tegra_pcib_write_config(device_t dev, u_int bus, u_int slot, u_int func, 464 u_int reg, uint32_t val, int bytes) 465 { 466 struct tegra_pcib_softc *sc; 467 bus_space_handle_t hndl; 468 uint32_t off; 469 uint32_t val2; 470 int rv, i; 471 472 sc = device_get_softc(dev); 473 if (bus == 0) { 474 if (func != 0) 475 return; 476 for (i = 0; i < TEGRA_PCIB_MAX_PORTS; i++) { 477 if ((sc->ports[i] != NULL) && 478 (sc->ports[i]->port_idx == slot)) { 479 hndl = sc->ports[i]->cfg_handle; 480 off = reg & 0xFFF; 481 break; 482 } 483 } 484 if (i >= TEGRA_PCIB_MAX_PORTS) 485 return; 486 } else { 487 rv = tegra_pcbib_map_cfg(sc, bus, slot, func, reg); 488 if (rv != 0) 489 return; 490 hndl = sc->cfg_handle; 491 off = PCI_CFG_BASE_REG(reg); 492 } 493 494 switch (bytes) { 495 case 4: 496 bus_space_write_4(sc->bus_tag, hndl, off, val); 497 break; 498 case 2: 499 val2 = bus_space_read_4(sc->bus_tag, hndl, off & ~3); 500 val2 &= ~(0xffff << ((off & 3) << 3)); 501 val2 |= ((val & 0xffff) << ((off & 3) << 3)); 502 bus_space_write_4(sc->bus_tag, hndl, off & ~3, val2); 503 break; 504 case 1: 505 val2 = bus_space_read_4(sc->bus_tag, hndl, off & ~3); 506 val2 &= ~(0xff << ((off & 3) << 3)); 507 val2 |= ((val & 0xff) << ((off & 3) << 3)); 508 bus_space_write_4(sc->bus_tag, hndl, off & ~3, val2); 509 break; 510 } 511 } 512 513 static int tegra_pci_intr(void *arg) 514 { 515 struct tegra_pcib_softc *sc = arg; 516 uint32_t code, signature; 517 518 code = bus_read_4(sc->afi_mem_res, AFI_INTR_CODE) & AFI_INTR_CODE_MASK; 519 signature = bus_read_4(sc->afi_mem_res, AFI_INTR_SIGNATURE); 520 bus_write_4(sc->afi_mem_res, AFI_INTR_CODE, 0); 521 if (code == AFI_INTR_CODE_INT_CODE_SM_MSG) 522 return(FILTER_STRAY); 523 524 printf("tegra_pci_intr: code %x sig %x\n", code, signature); 525 return (FILTER_HANDLED); 526 } 527 528 /* ----------------------------------------------------------------------- 529 * 530 * PCI MSI interface 531 */ 532 static int 533 tegra_pcib_alloc_msi(device_t pci, device_t child, int count, int maxcount, 534 int *irqs) 535 { 536 phandle_t msi_parent; 537 538 /* XXXX ofw_bus_msimap() don't works for Tegra DT. 539 ofw_bus_msimap(ofw_bus_get_node(pci), pci_get_rid(child), &msi_parent, 540 NULL); 541 */ 542 msi_parent = OF_xref_from_node(ofw_bus_get_node(pci)); 543 return (intr_alloc_msi(pci, child, msi_parent, count, maxcount, 544 irqs)); 545 } 546 547 static int 548 tegra_pcib_release_msi(device_t pci, device_t child, int count, int *irqs) 549 { 550 phandle_t msi_parent; 551 552 /* XXXX ofw_bus_msimap() don't works for Tegra DT. 553 ofw_bus_msimap(ofw_bus_get_node(pci), pci_get_rid(child), &msi_parent, 554 NULL); 555 */ 556 msi_parent = OF_xref_from_node(ofw_bus_get_node(pci)); 557 return (intr_release_msi(pci, child, msi_parent, count, irqs)); 558 } 559 560 static int 561 tegra_pcib_map_msi(device_t pci, device_t child, int irq, uint64_t *addr, 562 uint32_t *data) 563 { 564 phandle_t msi_parent; 565 566 /* XXXX ofw_bus_msimap() don't works for Tegra DT. 567 ofw_bus_msimap(ofw_bus_get_node(pci), pci_get_rid(child), &msi_parent, 568 NULL); 569 */ 570 msi_parent = OF_xref_from_node(ofw_bus_get_node(pci)); 571 return (intr_map_msi(pci, child, msi_parent, irq, addr, data)); 572 } 573 574 #ifdef TEGRA_PCIB_MSI_ENABLE 575 576 /* -------------------------------------------------------------------------- 577 * 578 * Interrupts 579 * 580 */ 581 582 static inline void 583 tegra_pcib_isrc_mask(struct tegra_pcib_softc *sc, 584 struct tegra_pcib_irqsrc *tgi, uint32_t val) 585 { 586 uint32_t reg; 587 int offs, bit; 588 589 offs = tgi->irq / AFI_MSI_INTR_IN_REG; 590 bit = 1 << (tgi->irq % AFI_MSI_INTR_IN_REG); 591 592 if (val != 0) 593 AFI_WR4(sc, AFI_MSI_VEC(offs), bit); 594 reg = AFI_RD4(sc, AFI_MSI_EN_VEC(offs)); 595 if (val != 0) 596 reg |= bit; 597 else 598 reg &= ~bit; 599 AFI_WR4(sc, AFI_MSI_EN_VEC(offs), reg); 600 } 601 602 static int 603 tegra_pcib_msi_intr(void *arg) 604 { 605 u_int irq, i, bit, reg; 606 struct tegra_pcib_softc *sc; 607 struct trapframe *tf; 608 struct tegra_pcib_irqsrc *tgi; 609 610 sc = (struct tegra_pcib_softc *)arg; 611 tf = curthread->td_intr_frame; 612 613 for (i = 0; i < AFI_MSI_REGS; i++) { 614 reg = AFI_RD4(sc, AFI_MSI_VEC(i)); 615 /* Handle one vector. */ 616 while (reg != 0) { 617 bit = ffs(reg) - 1; 618 /* Send EOI */ 619 AFI_WR4(sc, AFI_MSI_VEC(i), 1 << bit); 620 irq = i * AFI_MSI_INTR_IN_REG + bit; 621 tgi = &sc->isrcs[irq]; 622 if (intr_isrc_dispatch(&tgi->isrc, tf) != 0) { 623 /* Disable stray. */ 624 tegra_pcib_isrc_mask(sc, tgi, 0); 625 device_printf(sc->dev, 626 "Stray irq %u disabled\n", irq); 627 } 628 reg = AFI_RD4(sc, AFI_MSI_VEC(i)); 629 } 630 } 631 return (FILTER_HANDLED); 632 } 633 634 static int 635 tegra_pcib_msi_attach(struct tegra_pcib_softc *sc) 636 { 637 int error; 638 uint32_t irq; 639 const char *name; 640 641 sc->isrcs = malloc(sizeof(*sc->isrcs) * TEGRA_PCIB_MAX_MSI, M_DEVBUF, 642 M_WAITOK | M_ZERO); 643 644 name = device_get_nameunit(sc->dev); 645 for (irq = 0; irq < TEGRA_PCIB_MAX_MSI; irq++) { 646 sc->isrcs[irq].irq = irq; 647 error = intr_isrc_register(&sc->isrcs[irq].isrc, 648 sc->dev, 0, "%s,%u", name, irq); 649 if (error != 0) 650 return (error); /* XXX deregister ISRCs */ 651 } 652 if (intr_msi_register(sc->dev, 653 OF_xref_from_node(ofw_bus_get_node(sc->dev))) != 0) 654 return (ENXIO); 655 656 return (0); 657 } 658 659 static int 660 tegra_pcib_msi_detach(struct tegra_pcib_softc *sc) 661 { 662 663 /* 664 * There has not been established any procedure yet 665 * how to detach PIC from living system correctly. 666 */ 667 device_printf(sc->dev, "%s: not implemented yet\n", __func__); 668 return (EBUSY); 669 } 670 671 static void 672 tegra_pcib_msi_disable_intr(device_t dev, struct intr_irqsrc *isrc) 673 { 674 struct tegra_pcib_softc *sc; 675 struct tegra_pcib_irqsrc *tgi; 676 677 sc = device_get_softc(dev); 678 tgi = (struct tegra_pcib_irqsrc *)isrc; 679 tegra_pcib_isrc_mask(sc, tgi, 0); 680 } 681 682 static void 683 tegra_pcib_msi_enable_intr(device_t dev, struct intr_irqsrc *isrc) 684 { 685 struct tegra_pcib_softc *sc; 686 struct tegra_pcib_irqsrc *tgi; 687 688 sc = device_get_softc(dev); 689 tgi = (struct tegra_pcib_irqsrc *)isrc; 690 tegra_pcib_isrc_mask(sc, tgi, 1); 691 } 692 693 /* MSI interrupts are edge trigered -> do nothing */ 694 static void 695 tegra_pcib_msi_post_filter(device_t dev, struct intr_irqsrc *isrc) 696 { 697 } 698 699 static void 700 tegra_pcib_msi_post_ithread(device_t dev, struct intr_irqsrc *isrc) 701 { 702 } 703 704 static void 705 tegra_pcib_msi_pre_ithread(device_t dev, struct intr_irqsrc *isrc) 706 { 707 } 708 709 static int 710 tegra_pcib_msi_setup_intr(device_t dev, struct intr_irqsrc *isrc, 711 struct resource *res, struct intr_map_data *data) 712 { 713 struct tegra_pcib_softc *sc; 714 struct tegra_pcib_irqsrc *tgi; 715 716 sc = device_get_softc(dev); 717 tgi = (struct tegra_pcib_irqsrc *)isrc; 718 719 if (data == NULL || data->type != INTR_MAP_DATA_MSI) 720 return (ENOTSUP); 721 722 if (isrc->isrc_handlers == 0) 723 tegra_pcib_msi_enable_intr(dev, isrc); 724 725 return (0); 726 } 727 728 static int 729 tegra_pcib_msi_teardown_intr(device_t dev, struct intr_irqsrc *isrc, 730 struct resource *res, struct intr_map_data *data) 731 { 732 struct tegra_pcib_softc *sc; 733 struct tegra_pcib_irqsrc *tgi; 734 735 sc = device_get_softc(dev); 736 tgi = (struct tegra_pcib_irqsrc *)isrc; 737 738 if (isrc->isrc_handlers == 0) 739 tegra_pcib_isrc_mask(sc, tgi, 0); 740 return (0); 741 } 742 743 static int 744 tegra_pcib_msi_alloc_msi(device_t dev, device_t child, int count, int maxcount, 745 device_t *pic, struct intr_irqsrc **srcs) 746 { 747 struct tegra_pcib_softc *sc; 748 int i, irq, end_irq; 749 bool found; 750 751 KASSERT(powerof2(count), ("%s: bad count", __func__)); 752 KASSERT(powerof2(maxcount), ("%s: bad maxcount", __func__)); 753 754 sc = device_get_softc(dev); 755 mtx_lock(&sc->mtx); 756 757 found = false; 758 for (irq = 0; (irq + count - 1) < TEGRA_PCIB_MAX_MSI; irq++) { 759 /* Start on an aligned interrupt */ 760 if ((irq & (maxcount - 1)) != 0) 761 continue; 762 763 /* Assume we found a valid range until shown otherwise */ 764 found = true; 765 766 /* Check this range is valid */ 767 for (end_irq = irq; end_irq < irq + count; end_irq++) { 768 /* This is already used */ 769 if ((sc->isrcs[end_irq].flags & TEGRA_FLAG_MSI_USED) == 770 TEGRA_FLAG_MSI_USED) { 771 found = false; 772 break; 773 } 774 } 775 776 if (found) 777 break; 778 } 779 780 /* Not enough interrupts were found */ 781 if (!found || irq == (TEGRA_PCIB_MAX_MSI - 1)) { 782 mtx_unlock(&sc->mtx); 783 return (ENXIO); 784 } 785 786 for (i = 0; i < count; i++) { 787 /* Mark the interrupt as used */ 788 sc->isrcs[irq + i].flags |= TEGRA_FLAG_MSI_USED; 789 } 790 mtx_unlock(&sc->mtx); 791 792 for (i = 0; i < count; i++) 793 srcs[i] = (struct intr_irqsrc *)&sc->isrcs[irq + i]; 794 *pic = device_get_parent(dev); 795 return (0); 796 } 797 798 static int 799 tegra_pcib_msi_release_msi(device_t dev, device_t child, int count, 800 struct intr_irqsrc **isrc) 801 { 802 struct tegra_pcib_softc *sc; 803 struct tegra_pcib_irqsrc *ti; 804 int i; 805 806 sc = device_get_softc(dev); 807 mtx_lock(&sc->mtx); 808 for (i = 0; i < count; i++) { 809 ti = (struct tegra_pcib_irqsrc *)isrc[i]; 810 811 KASSERT((ti->flags & TEGRA_FLAG_MSI_USED) == TEGRA_FLAG_MSI_USED, 812 ("%s: Trying to release an unused MSI-X interrupt", 813 __func__)); 814 815 ti->flags &= ~TEGRA_FLAG_MSI_USED; 816 } 817 mtx_unlock(&sc->mtx); 818 return (0); 819 } 820 821 static int 822 tegra_pcib_msi_map_msi(device_t dev, device_t child, struct intr_irqsrc *isrc, 823 uint64_t *addr, uint32_t *data) 824 { 825 struct tegra_pcib_softc *sc = device_get_softc(dev); 826 struct tegra_pcib_irqsrc *ti = (struct tegra_pcib_irqsrc *)isrc; 827 828 *addr = vtophys(sc->msi_page); 829 *data = ti->irq; 830 return (0); 831 } 832 #endif 833 834 /* ------------------------------------------------------------------- */ 835 static bus_size_t 836 tegra_pcib_pex_ctrl(struct tegra_pcib_softc *sc, int port) 837 { 838 if (port >= TEGRA_PCIB_MAX_PORTS) 839 panic("invalid port number: %d\n", port); 840 841 if (port == 0) 842 return (AFI_PEX0_CTRL); 843 else if (port == 1) 844 return (AFI_PEX1_CTRL); 845 else if (port == 2) 846 return (AFI_PEX2_CTRL); 847 else 848 panic("invalid port number: %d\n", port); 849 } 850 851 static int 852 tegra_pcib_enable_fdt_resources(struct tegra_pcib_softc *sc) 853 { 854 int i, rv; 855 856 rv = hwreset_assert(sc->hwreset_pcie_x); 857 if (rv != 0) { 858 device_printf(sc->dev, "Cannot assert 'pcie_x' reset\n"); 859 return (rv); 860 } 861 rv = hwreset_assert(sc->hwreset_afi); 862 if (rv != 0) { 863 device_printf(sc->dev, "Cannot assert 'afi' reset\n"); 864 return (rv); 865 } 866 rv = hwreset_assert(sc->hwreset_pex); 867 if (rv != 0) { 868 device_printf(sc->dev, "Cannot assert 'pex' reset\n"); 869 return (rv); 870 } 871 872 tegra_powergate_power_off(TEGRA_POWERGATE_PCX); 873 874 /* Regulators. */ 875 for (i = 0; i < nitems(sc->regulators); i++) { 876 if (sc->regulators[i] == NULL) 877 continue; 878 rv = regulator_enable(sc->regulators[i]); 879 if (rv != 0) { 880 device_printf(sc->dev, 881 "Cannot enable '%s' regulator\n", 882 sc->soc->regulator_names[i]); 883 return (rv); 884 } 885 } 886 887 rv = tegra_powergate_sequence_power_up(TEGRA_POWERGATE_PCX, 888 sc->clk_pex, sc->hwreset_pex); 889 if (rv != 0) { 890 device_printf(sc->dev, "Cannot enable 'PCX' powergate\n"); 891 return (rv); 892 } 893 894 rv = hwreset_deassert(sc->hwreset_afi); 895 if (rv != 0) { 896 device_printf(sc->dev, "Cannot unreset 'afi' reset\n"); 897 return (rv); 898 } 899 900 rv = clk_enable(sc->clk_afi); 901 if (rv != 0) { 902 device_printf(sc->dev, "Cannot enable 'afi' clock\n"); 903 return (rv); 904 } 905 if (sc->soc->cml_clk) { 906 rv = clk_enable(sc->clk_cml); 907 if (rv != 0) { 908 device_printf(sc->dev, "Cannot enable 'cml' clock\n"); 909 return (rv); 910 } 911 } 912 rv = clk_enable(sc->clk_pll_e); 913 if (rv != 0) { 914 device_printf(sc->dev, "Cannot enable 'pll_e' clock\n"); 915 return (rv); 916 } 917 918 return (0); 919 } 920 921 static struct tegra_pcib_port * 922 tegra_pcib_parse_port(struct tegra_pcib_softc *sc, phandle_t node) 923 { 924 struct tegra_pcib_port *port; 925 uint32_t tmp[5]; 926 char tmpstr[6]; 927 int rv; 928 929 port = malloc(sizeof(struct tegra_pcib_port), M_DEVBUF, M_WAITOK); 930 931 rv = OF_getprop(node, "status", tmpstr, sizeof(tmpstr)); 932 if (rv <= 0 || strcmp(tmpstr, "okay") == 0 || 933 strcmp(tmpstr, "ok") == 0) 934 port->enabled = 1; 935 else 936 port->enabled = 0; 937 938 rv = OF_getencprop(node, "assigned-addresses", tmp, sizeof(tmp)); 939 if (rv != sizeof(tmp)) { 940 device_printf(sc->dev, "Cannot parse assigned-address: %d\n", 941 rv); 942 goto fail; 943 } 944 port->rp_base_addr = tmp[2]; 945 port->rp_size = tmp[4]; 946 port->port_idx = OFW_PCI_PHYS_HI_DEVICE(tmp[0]) - 1; 947 if (port->port_idx >= TEGRA_PCIB_MAX_PORTS) { 948 device_printf(sc->dev, "Invalid port index: %d\n", 949 port->port_idx); 950 goto fail; 951 } 952 /* XXX - TODO: 953 * Implement proper function for parsing pci "reg" property: 954 * - it have PCI bus format 955 * - its relative to matching "assigned-addresses" 956 */ 957 rv = OF_getencprop(node, "reg", tmp, sizeof(tmp)); 958 if (rv != sizeof(tmp)) { 959 device_printf(sc->dev, "Cannot parse reg: %d\n", rv); 960 goto fail; 961 } 962 port->rp_base_addr += tmp[2]; 963 964 rv = OF_getencprop(node, "nvidia,num-lanes", &port->num_lanes, 965 sizeof(port->num_lanes)); 966 if (rv != sizeof(port->num_lanes)) { 967 device_printf(sc->dev, "Cannot parse nvidia,num-lanes: %d\n", 968 rv); 969 goto fail; 970 } 971 if (port->num_lanes > 4) { 972 device_printf(sc->dev, "Invalid nvidia,num-lanes: %d\n", 973 port->num_lanes); 974 goto fail; 975 } 976 977 port->afi_pex_ctrl = tegra_pcib_pex_ctrl(sc, port->port_idx); 978 sc->lanes_cfg |= port->num_lanes << (4 * port->port_idx); 979 980 /* Phy. */ 981 rv = phy_get_by_ofw_name(sc->dev, node, "pcie-0", &port->phy); 982 if (rv != 0) { 983 device_printf(sc->dev, 984 "Cannot get 'pcie-0' phy for port %d\n", 985 port->port_idx); 986 goto fail; 987 } 988 989 return (port); 990 fail: 991 free(port, M_DEVBUF); 992 return (NULL); 993 } 994 995 static int 996 tegra_pcib_parse_fdt_resources(struct tegra_pcib_softc *sc, phandle_t node) 997 { 998 phandle_t child; 999 struct tegra_pcib_port *port; 1000 int i, rv; 1001 1002 /* Regulators. */ 1003 for (i = 0; sc->soc->regulator_names[i] != NULL; i++) { 1004 if (i >= nitems(sc->regulators)) { 1005 device_printf(sc->dev, 1006 "Too many regulators present in DT.\n"); 1007 return (EOVERFLOW); 1008 } 1009 rv = regulator_get_by_ofw_property(sc->dev, 0, 1010 sc->soc->regulator_names[i], sc->regulators + i); 1011 if (rv != 0) { 1012 device_printf(sc->dev, 1013 "Cannot get '%s' regulator\n", 1014 sc->soc->regulator_names[i]); 1015 return (ENXIO); 1016 } 1017 } 1018 1019 /* Resets. */ 1020 rv = hwreset_get_by_ofw_name(sc->dev, 0, "pex", &sc->hwreset_pex); 1021 if (rv != 0) { 1022 device_printf(sc->dev, "Cannot get 'pex' reset\n"); 1023 return (ENXIO); 1024 } 1025 rv = hwreset_get_by_ofw_name(sc->dev, 0, "afi", &sc->hwreset_afi); 1026 if (rv != 0) { 1027 device_printf(sc->dev, "Cannot get 'afi' reset\n"); 1028 return (ENXIO); 1029 } 1030 rv = hwreset_get_by_ofw_name(sc->dev, 0, "pcie_x", &sc->hwreset_pcie_x); 1031 if (rv != 0) { 1032 device_printf(sc->dev, "Cannot get 'pcie_x' reset\n"); 1033 return (ENXIO); 1034 } 1035 1036 /* Clocks. */ 1037 rv = clk_get_by_ofw_name(sc->dev, 0, "pex", &sc->clk_pex); 1038 if (rv != 0) { 1039 device_printf(sc->dev, "Cannot get 'pex' clock\n"); 1040 return (ENXIO); 1041 } 1042 rv = clk_get_by_ofw_name(sc->dev, 0, "afi", &sc->clk_afi); 1043 if (rv != 0) { 1044 device_printf(sc->dev, "Cannot get 'afi' clock\n"); 1045 return (ENXIO); 1046 } 1047 rv = clk_get_by_ofw_name(sc->dev, 0, "pll_e", &sc->clk_pll_e); 1048 if (rv != 0) { 1049 device_printf(sc->dev, "Cannot get 'pll_e' clock\n"); 1050 return (ENXIO); 1051 } 1052 if (sc->soc->cml_clk) { 1053 rv = clk_get_by_ofw_name(sc->dev, 0, "cml", &sc->clk_cml); 1054 if (rv != 0) { 1055 device_printf(sc->dev, "Cannot get 'cml' clock\n"); 1056 return (ENXIO); 1057 } 1058 } 1059 1060 /* Ports */ 1061 sc->num_ports = 0; 1062 for (child = OF_child(node); child != 0; child = OF_peer(child)) { 1063 port = tegra_pcib_parse_port(sc, child); 1064 if (port == NULL) { 1065 device_printf(sc->dev, "Cannot parse PCIe port node\n"); 1066 return (ENXIO); 1067 } 1068 sc->ports[sc->num_ports++] = port; 1069 } 1070 1071 return (0); 1072 } 1073 1074 static int 1075 tegra_pcib_decode_ranges(struct tegra_pcib_softc *sc, 1076 struct ofw_pci_range *ranges, int nranges) 1077 { 1078 int i; 1079 1080 for (i = 2; i < nranges; i++) { 1081 if ((ranges[i].pci_hi & OFW_PCI_PHYS_HI_SPACEMASK) == 1082 OFW_PCI_PHYS_HI_SPACE_IO) { 1083 if (sc->io_range.size != 0) { 1084 device_printf(sc->dev, 1085 "Duplicated IO range found in DT\n"); 1086 return (ENXIO); 1087 } 1088 sc->io_range = ranges[i]; 1089 } 1090 if (((ranges[i].pci_hi & OFW_PCI_PHYS_HI_SPACEMASK) == 1091 OFW_PCI_PHYS_HI_SPACE_MEM32)) { 1092 if (ranges[i].pci_hi & OFW_PCI_PHYS_HI_PREFETCHABLE) { 1093 if (sc->pref_mem_range.size != 0) { 1094 device_printf(sc->dev, 1095 "Duplicated memory range found " 1096 "in DT\n"); 1097 return (ENXIO); 1098 } 1099 sc->pref_mem_range = ranges[i]; 1100 } else { 1101 if (sc->mem_range.size != 0) { 1102 device_printf(sc->dev, 1103 "Duplicated memory range found " 1104 "in DT\n"); 1105 return (ENXIO); 1106 } 1107 sc->mem_range = ranges[i]; 1108 } 1109 } 1110 } 1111 if ((sc->io_range.size == 0) || (sc->mem_range.size == 0) 1112 || (sc->pref_mem_range.size == 0)) { 1113 device_printf(sc->dev, 1114 " Not all required ranges are found in DT\n"); 1115 return (ENXIO); 1116 } 1117 return (0); 1118 } 1119 1120 /* 1121 * Hardware config. 1122 */ 1123 static int 1124 tegra_pcib_wait_for_link(struct tegra_pcib_softc *sc, 1125 struct tegra_pcib_port *port) 1126 { 1127 uint32_t reg; 1128 int i; 1129 1130 /* Setup link detection. */ 1131 reg = tegra_pcib_read_config(sc->dev, 0, port->port_idx, 0, 1132 RP_PRIV_MISC, 4); 1133 reg &= ~RP_PRIV_MISC_PRSNT_MAP_EP_ABSNT; 1134 reg |= RP_PRIV_MISC_PRSNT_MAP_EP_PRSNT; 1135 tegra_pcib_write_config(sc->dev, 0, port->port_idx, 0, 1136 RP_PRIV_MISC, reg, 4); 1137 1138 for (i = TEGRA_PCIE_LINKUP_TIMEOUT; i > 0; i--) { 1139 reg = tegra_pcib_read_config(sc->dev, 0, port->port_idx, 0, 1140 RP_VEND_XP, 4); 1141 if (reg & RP_VEND_XP_DL_UP) 1142 break; 1143 DELAY(1); 1144 } 1145 if (i <= 0) 1146 return (ETIMEDOUT); 1147 1148 for (i = TEGRA_PCIE_LINKUP_TIMEOUT; i > 0; i--) { 1149 reg = tegra_pcib_read_config(sc->dev, 0, port->port_idx, 0, 1150 RP_LINK_CONTROL_STATUS, 4); 1151 if (reg & RP_LINK_CONTROL_STATUS_DL_LINK_ACTIVE) 1152 break; 1153 1154 DELAY(1); 1155 } 1156 if (i <= 0) 1157 return (ETIMEDOUT); 1158 return (0); 1159 } 1160 1161 static void 1162 tegra_pcib_port_enable(struct tegra_pcib_softc *sc, int port_num) 1163 { 1164 struct tegra_pcib_port *port; 1165 uint32_t reg; 1166 int rv; 1167 1168 port = sc->ports[port_num]; 1169 1170 /* Put port to reset. */ 1171 reg = AFI_RD4(sc, port->afi_pex_ctrl); 1172 reg &= ~AFI_PEX_CTRL_RST_L; 1173 AFI_WR4(sc, port->afi_pex_ctrl, reg); 1174 AFI_RD4(sc, port->afi_pex_ctrl); 1175 DELAY(10); 1176 1177 /* Enable clocks. */ 1178 reg |= AFI_PEX_CTRL_REFCLK_EN; 1179 reg |= AFI_PEX_CTRL_CLKREQ_EN; 1180 reg |= AFI_PEX_CTRL_OVERRIDE_EN; 1181 AFI_WR4(sc, port->afi_pex_ctrl, reg); 1182 AFI_RD4(sc, port->afi_pex_ctrl); 1183 DELAY(100); 1184 1185 /* Release reset. */ 1186 reg |= AFI_PEX_CTRL_RST_L; 1187 AFI_WR4(sc, port->afi_pex_ctrl, reg); 1188 1189 if (sc->soc->pca_enable) { 1190 reg = tegra_pcib_read_config(sc->dev, 0, port->port_idx, 0, 1191 RP_VEND_CTL2, 4); 1192 reg |= RP_VEND_CTL2_PCA_ENABLE; 1193 tegra_pcib_write_config(sc->dev, 0, port->port_idx, 0, 1194 RP_VEND_CTL2, reg, 4); 1195 } 1196 1197 rv = tegra_pcib_wait_for_link(sc, port); 1198 if (bootverbose) 1199 device_printf(sc->dev, " port %d (%d lane%s): Link is %s\n", 1200 port->port_idx, port->num_lanes, 1201 port->num_lanes > 1 ? "s": "", 1202 rv == 0 ? "up": "down"); 1203 } 1204 1205 static void 1206 tegra_pcib_port_disable(struct tegra_pcib_softc *sc, uint32_t port_num) 1207 { 1208 struct tegra_pcib_port *port; 1209 uint32_t reg; 1210 1211 port = sc->ports[port_num]; 1212 1213 /* Put port to reset. */ 1214 reg = AFI_RD4(sc, port->afi_pex_ctrl); 1215 reg &= ~AFI_PEX_CTRL_RST_L; 1216 AFI_WR4(sc, port->afi_pex_ctrl, reg); 1217 AFI_RD4(sc, port->afi_pex_ctrl); 1218 DELAY(10); 1219 1220 /* Disable clocks. */ 1221 reg &= ~AFI_PEX_CTRL_CLKREQ_EN; 1222 reg &= ~AFI_PEX_CTRL_REFCLK_EN; 1223 AFI_WR4(sc, port->afi_pex_ctrl, reg); 1224 1225 if (bootverbose) 1226 device_printf(sc->dev, " port %d (%d lane%s): Disabled\n", 1227 port->port_idx, port->num_lanes, 1228 port->num_lanes > 1 ? "s": ""); 1229 } 1230 1231 static void 1232 tegra_pcib_set_bar(struct tegra_pcib_softc *sc, int bar, uint32_t axi, 1233 uint64_t fpci, uint32_t size, int is_memory) 1234 { 1235 uint32_t fpci_reg; 1236 uint32_t axi_reg; 1237 uint32_t size_reg; 1238 1239 axi_reg = axi & ~0xFFF; 1240 size_reg = size >> 12; 1241 fpci_reg = (uint32_t)(fpci >> 8) & ~0xF; 1242 fpci_reg |= is_memory ? 0x1 : 0x0; 1243 AFI_WR4(sc, bars[bar].axi_start, axi_reg); 1244 AFI_WR4(sc, bars[bar].size, size_reg); 1245 AFI_WR4(sc, bars[bar].fpci_start, fpci_reg); 1246 } 1247 1248 static int 1249 tegra_pcib_enable(struct tegra_pcib_softc *sc) 1250 { 1251 int rv; 1252 int i; 1253 uint32_t reg; 1254 1255 rv = tegra_pcib_enable_fdt_resources(sc); 1256 if (rv != 0) { 1257 device_printf(sc->dev, "Cannot enable FDT resources\n"); 1258 return (rv); 1259 } 1260 1261 /* Enable PLLE control. */ 1262 reg = AFI_RD4(sc, AFI_PLLE_CONTROL); 1263 reg &= ~AFI_PLLE_CONTROL_BYPASS_PADS2PLLE_CONTROL; 1264 reg |= AFI_PLLE_CONTROL_PADS2PLLE_CONTROL_EN; 1265 AFI_WR4(sc, AFI_PLLE_CONTROL, reg); 1266 1267 /* Set bias pad. */ 1268 AFI_WR4(sc, AFI_PEXBIAS_CTRL, 0); 1269 1270 /* Configure mode and ports. */ 1271 reg = AFI_RD4(sc, AFI_PCIE_CONFIG); 1272 reg &= ~AFI_PCIE_CONFIG_SM2TMS0_XBAR_CONFIG_MASK; 1273 if (sc->lanes_cfg == 0x14) { 1274 if (bootverbose) 1275 device_printf(sc->dev, 1276 "Using x1,x4 configuration\n"); 1277 reg |= AFI_PCIE_CONFIG_SM2TMS0_XBAR_CONFIG_XBAR4_1; 1278 } else if (sc->lanes_cfg == 0x12) { 1279 if (bootverbose) 1280 device_printf(sc->dev, 1281 "Using x1,x2 configuration\n"); 1282 reg |= AFI_PCIE_CONFIG_SM2TMS0_XBAR_CONFIG_XBAR2_1; 1283 } else { 1284 device_printf(sc->dev, 1285 "Unsupported lanes configuration: 0x%X\n", sc->lanes_cfg); 1286 } 1287 reg |= AFI_PCIE_CONFIG_PCIE_DISABLE_ALL; 1288 for (i = 0; i < TEGRA_PCIB_MAX_PORTS; i++) { 1289 if ((sc->ports[i] != NULL)) 1290 reg &= 1291 ~AFI_PCIE_CONFIG_PCIE_DISABLE(sc->ports[i]->port_idx); 1292 } 1293 AFI_WR4(sc, AFI_PCIE_CONFIG, reg); 1294 1295 /* Enable Gen2 support. */ 1296 reg = AFI_RD4(sc, AFI_FUSE); 1297 reg &= ~AFI_FUSE_PCIE_T0_GEN2_DIS; 1298 AFI_WR4(sc, AFI_FUSE, reg); 1299 1300 for (i = 0; i < TEGRA_PCIB_MAX_PORTS; i++) { 1301 if (sc->ports[i] != NULL) { 1302 rv = phy_enable(sc->ports[i]->phy); 1303 if (rv != 0) { 1304 device_printf(sc->dev, 1305 "Cannot enable phy for port %d\n", 1306 sc->ports[i]->port_idx); 1307 return (rv); 1308 } 1309 } 1310 } 1311 1312 /* Configure PCIe reference clock */ 1313 PADS_WR4(sc, PADS_REFCLK_CFG0, sc->soc->pads_refclk_cfg0); 1314 if (sc->num_ports > 2) 1315 PADS_WR4(sc, PADS_REFCLK_CFG1, sc->soc->pads_refclk_cfg1); 1316 1317 rv = hwreset_deassert(sc->hwreset_pcie_x); 1318 if (rv != 0) { 1319 device_printf(sc->dev, "Cannot unreset 'pci_x' reset\n"); 1320 return (rv); 1321 } 1322 1323 /* Enable config space. */ 1324 reg = AFI_RD4(sc, AFI_CONFIGURATION); 1325 reg |= AFI_CONFIGURATION_EN_FPCI; 1326 AFI_WR4(sc, AFI_CONFIGURATION, reg); 1327 1328 /* Enable AFI errors. */ 1329 reg = 0; 1330 reg |= AFI_AFI_INTR_ENABLE_CODE(AFI_INTR_CODE_INT_CODE_INI_SLVERR); 1331 reg |= AFI_AFI_INTR_ENABLE_CODE(AFI_INTR_CODE_INT_CODE_INI_DECERR); 1332 reg |= AFI_AFI_INTR_ENABLE_CODE(AFI_INTR_CODE_INT_CODE_TGT_SLVERR); 1333 reg |= AFI_AFI_INTR_ENABLE_CODE(AFI_INTR_CODE_INT_CODE_TGT_DECERR); 1334 reg |= AFI_AFI_INTR_ENABLE_CODE(AFI_INTR_CODE_INT_CODE_TGT_WRERR); 1335 reg |= AFI_AFI_INTR_ENABLE_CODE(AFI_INTR_CODE_INT_CODE_SM_MSG); 1336 reg |= AFI_AFI_INTR_ENABLE_CODE(AFI_INTR_CODE_INT_CODE_DFPCI_DECERR); 1337 reg |= AFI_AFI_INTR_ENABLE_CODE(AFI_INTR_CODE_INT_CODE_AXI_DECERR); 1338 reg |= AFI_AFI_INTR_ENABLE_CODE(AFI_INTR_CODE_INT_CODE_FPCI_TIMEOUT); 1339 reg |= AFI_AFI_INTR_ENABLE_CODE(AFI_INTR_CODE_INT_CODE_PE_PRSNT_SENSE); 1340 reg |= AFI_AFI_INTR_ENABLE_CODE(AFI_INTR_CODE_INT_CODE_PE_CLKREQ_SENSE); 1341 reg |= AFI_AFI_INTR_ENABLE_CODE(AFI_INTR_CODE_INT_CODE_CLKCLAMP_SENSE); 1342 reg |= AFI_AFI_INTR_ENABLE_CODE(AFI_INTR_CODE_INT_CODE_RDY4PD_SENSE); 1343 reg |= AFI_AFI_INTR_ENABLE_CODE(AFI_INTR_CODE_INT_CODE_P2P_ERROR); 1344 AFI_WR4(sc, AFI_AFI_INTR_ENABLE, reg); 1345 AFI_WR4(sc, AFI_SM_INTR_ENABLE, 0xffffffff); 1346 1347 /* Enable INT, disable MSI. */ 1348 AFI_WR4(sc, AFI_INTR_MASK, AFI_INTR_MASK_INT_MASK); 1349 1350 /* Mask all FPCI errors. */ 1351 AFI_WR4(sc, AFI_FPCI_ERROR_MASKS, 0); 1352 1353 /* Setup AFI translation windows. */ 1354 /* BAR 0 - type 1 extended configuration. */ 1355 tegra_pcib_set_bar(sc, 0, rman_get_start(sc->cfg_mem_res), 1356 FPCI_MAP_EXT_TYPE1_CONFIG, rman_get_size(sc->cfg_mem_res), 0); 1357 1358 /* BAR 1 - downstream I/O. */ 1359 tegra_pcib_set_bar(sc, 1, sc->io_range.host, FPCI_MAP_IO, 1360 sc->io_range.size, 0); 1361 1362 /* BAR 2 - downstream prefetchable memory 1:1. */ 1363 tegra_pcib_set_bar(sc, 2, sc->pref_mem_range.host, 1364 sc->pref_mem_range.host, sc->pref_mem_range.size, 1); 1365 1366 /* BAR 3 - downstream not prefetchable memory 1:1 .*/ 1367 tegra_pcib_set_bar(sc, 3, sc->mem_range.host, 1368 sc->mem_range.host, sc->mem_range.size, 1); 1369 1370 /* BAR 3-8 clear. */ 1371 tegra_pcib_set_bar(sc, 4, 0, 0, 0, 0); 1372 tegra_pcib_set_bar(sc, 5, 0, 0, 0, 0); 1373 tegra_pcib_set_bar(sc, 6, 0, 0, 0, 0); 1374 tegra_pcib_set_bar(sc, 7, 0, 0, 0, 0); 1375 tegra_pcib_set_bar(sc, 8, 0, 0, 0, 0); 1376 1377 /* MSI BAR - clear. */ 1378 tegra_pcib_set_bar(sc, 9, 0, 0, 0, 0); 1379 return(0); 1380 } 1381 1382 #ifdef TEGRA_PCIB_MSI_ENABLE 1383 static int 1384 tegra_pcib_attach_msi(device_t dev) 1385 { 1386 struct tegra_pcib_softc *sc; 1387 uint32_t reg; 1388 int i, rv; 1389 1390 sc = device_get_softc(dev); 1391 1392 sc->msi_page = kmem_alloc_contig(PAGE_SIZE, M_WAITOK, 0, 1393 BUS_SPACE_MAXADDR, PAGE_SIZE, 0, VM_MEMATTR_DEFAULT); 1394 1395 /* MSI BAR */ 1396 tegra_pcib_set_bar(sc, 9, vtophys(sc->msi_page), vtophys(sc->msi_page), 1397 PAGE_SIZE, 0); 1398 1399 /* Disable and clear all interrupts. */ 1400 for (i = 0; i < AFI_MSI_REGS; i++) { 1401 AFI_WR4(sc, AFI_MSI_EN_VEC(i), 0); 1402 AFI_WR4(sc, AFI_MSI_VEC(i), 0xFFFFFFFF); 1403 } 1404 rv = bus_setup_intr(dev, sc->msi_irq_res, INTR_TYPE_BIO | INTR_MPSAFE, 1405 tegra_pcib_msi_intr, NULL, sc, &sc->msi_intr_cookie); 1406 if (rv != 0) { 1407 device_printf(dev, "cannot setup MSI interrupt handler\n"); 1408 rv = ENXIO; 1409 goto out; 1410 } 1411 1412 if (tegra_pcib_msi_attach(sc) != 0) { 1413 device_printf(dev, "WARNING: unable to attach PIC\n"); 1414 tegra_pcib_msi_detach(sc); 1415 goto out; 1416 } 1417 1418 /* Unmask MSI interrupt. */ 1419 reg = AFI_RD4(sc, AFI_INTR_MASK); 1420 reg |= AFI_INTR_MASK_MSI_MASK; 1421 AFI_WR4(sc, AFI_INTR_MASK, reg); 1422 1423 out: 1424 return (rv); 1425 } 1426 #endif 1427 1428 static int 1429 tegra_pcib_probe(device_t dev) 1430 { 1431 if (!ofw_bus_status_okay(dev)) 1432 return (ENXIO); 1433 1434 if (ofw_bus_search_compatible(dev, compat_data)->ocd_data != 0) { 1435 device_set_desc(dev, "Nvidia Integrated PCI/PCI-E Controller"); 1436 return (BUS_PROBE_DEFAULT); 1437 } 1438 return (ENXIO); 1439 } 1440 1441 static int 1442 tegra_pcib_attach(device_t dev) 1443 { 1444 struct tegra_pcib_softc *sc; 1445 phandle_t node; 1446 int rv; 1447 int rid; 1448 struct tegra_pcib_port *port; 1449 int i; 1450 1451 sc = device_get_softc(dev); 1452 sc->dev = dev; 1453 mtx_init(&sc->mtx, "msi_mtx", NULL, MTX_DEF); 1454 1455 node = ofw_bus_get_node(dev); 1456 sc->soc = (struct pcie_soc *)ofw_bus_search_compatible(dev, 1457 compat_data)->ocd_data; 1458 1459 rv = tegra_pcib_parse_fdt_resources(sc, node); 1460 if (rv != 0) { 1461 device_printf(dev, "Cannot get FDT resources\n"); 1462 return (rv); 1463 } 1464 1465 /* Allocate bus_space resources. */ 1466 rid = 0; 1467 sc->pads_mem_res = bus_alloc_resource_any(dev, SYS_RES_MEMORY, &rid, 1468 RF_ACTIVE); 1469 if (sc->pads_mem_res == NULL) { 1470 device_printf(dev, "Cannot allocate PADS register\n"); 1471 rv = ENXIO; 1472 goto out; 1473 } 1474 /* 1475 * XXX - FIXME 1476 * tag for config space is not filled when RF_ALLOCATED flag is used. 1477 */ 1478 sc->bus_tag = rman_get_bustag(sc->pads_mem_res); 1479 1480 rid = 1; 1481 sc->afi_mem_res = bus_alloc_resource_any(dev, SYS_RES_MEMORY, &rid, 1482 RF_ACTIVE); 1483 if (sc->afi_mem_res == NULL) { 1484 device_printf(dev, "Cannot allocate AFI register\n"); 1485 rv = ENXIO; 1486 goto out; 1487 } 1488 1489 rid = 2; 1490 sc->cfg_mem_res = bus_alloc_resource_any(dev, SYS_RES_MEMORY, &rid, 1491 RF_ALLOCATED); 1492 if (sc->cfg_mem_res == NULL) { 1493 device_printf(dev, "Cannot allocate config space memory\n"); 1494 rv = ENXIO; 1495 goto out; 1496 } 1497 sc->cfg_base_addr = rman_get_start(sc->cfg_mem_res); 1498 1499 /* Map RP slots */ 1500 for (i = 0; i < TEGRA_PCIB_MAX_PORTS; i++) { 1501 if (sc->ports[i] == NULL) 1502 continue; 1503 port = sc->ports[i]; 1504 rv = bus_space_map(sc->bus_tag, port->rp_base_addr, 1505 port->rp_size, 0, &port->cfg_handle); 1506 if (rv != 0) { 1507 device_printf(sc->dev, "Cannot allocate memory for " 1508 "port: %d\n", i); 1509 rv = ENXIO; 1510 goto out; 1511 } 1512 } 1513 1514 /* 1515 * Get PCI interrupt 1516 */ 1517 rid = 0; 1518 sc->irq_res = bus_alloc_resource_any(dev, SYS_RES_IRQ, &rid, 1519 RF_ACTIVE | RF_SHAREABLE); 1520 if (sc->irq_res == NULL) { 1521 device_printf(dev, "Cannot allocate IRQ resources\n"); 1522 rv = ENXIO; 1523 goto out; 1524 } 1525 1526 rid = 1; 1527 sc->msi_irq_res = bus_alloc_resource_any(dev, SYS_RES_IRQ, &rid, 1528 RF_ACTIVE); 1529 if (sc->irq_res == NULL) { 1530 device_printf(dev, "Cannot allocate MSI IRQ resources\n"); 1531 rv = ENXIO; 1532 goto out; 1533 } 1534 1535 sc->ofw_pci.sc_range_mask = 0x3; 1536 rv = ofw_pci_init(dev); 1537 if (rv != 0) 1538 goto out; 1539 1540 rv = tegra_pcib_decode_ranges(sc, sc->ofw_pci.sc_range, 1541 sc->ofw_pci.sc_nrange); 1542 if (rv != 0) 1543 goto out; 1544 1545 if (bus_setup_intr(dev, sc->irq_res, INTR_TYPE_BIO | INTR_MPSAFE, 1546 tegra_pci_intr, NULL, sc, &sc->intr_cookie)) { 1547 device_printf(dev, "cannot setup interrupt handler\n"); 1548 rv = ENXIO; 1549 goto out; 1550 } 1551 1552 /* 1553 * Enable PCIE device. 1554 */ 1555 rv = tegra_pcib_enable(sc); 1556 if (rv != 0) 1557 goto out; 1558 for (i = 0; i < TEGRA_PCIB_MAX_PORTS; i++) { 1559 if (sc->ports[i] == NULL) 1560 continue; 1561 if (sc->ports[i]->enabled) 1562 tegra_pcib_port_enable(sc, i); 1563 else 1564 tegra_pcib_port_disable(sc, i); 1565 } 1566 1567 #ifdef TEGRA_PCIB_MSI_ENABLE 1568 rv = tegra_pcib_attach_msi(dev); 1569 if (rv != 0) 1570 goto out; 1571 #endif 1572 device_add_child(dev, "pci", -1); 1573 1574 return (bus_generic_attach(dev)); 1575 1576 out: 1577 1578 return (rv); 1579 } 1580 1581 static device_method_t tegra_pcib_methods[] = { 1582 /* Device interface */ 1583 DEVMETHOD(device_probe, tegra_pcib_probe), 1584 DEVMETHOD(device_attach, tegra_pcib_attach), 1585 1586 /* Bus interface */ 1587 DEVMETHOD(bus_setup_intr, bus_generic_setup_intr), 1588 DEVMETHOD(bus_teardown_intr, bus_generic_teardown_intr), 1589 1590 /* pcib interface */ 1591 DEVMETHOD(pcib_maxslots, tegra_pcib_maxslots), 1592 DEVMETHOD(pcib_read_config, tegra_pcib_read_config), 1593 DEVMETHOD(pcib_write_config, tegra_pcib_write_config), 1594 DEVMETHOD(pcib_route_interrupt, tegra_pcib_route_interrupt), 1595 DEVMETHOD(pcib_alloc_msi, tegra_pcib_alloc_msi), 1596 DEVMETHOD(pcib_release_msi, tegra_pcib_release_msi), 1597 DEVMETHOD(pcib_map_msi, tegra_pcib_map_msi), 1598 DEVMETHOD(pcib_request_feature, pcib_request_feature_allow), 1599 1600 #ifdef TEGRA_PCIB_MSI_ENABLE 1601 /* MSI/MSI-X */ 1602 DEVMETHOD(msi_alloc_msi, tegra_pcib_msi_alloc_msi), 1603 DEVMETHOD(msi_release_msi, tegra_pcib_msi_release_msi), 1604 DEVMETHOD(msi_map_msi, tegra_pcib_msi_map_msi), 1605 1606 /* Interrupt controller interface */ 1607 DEVMETHOD(pic_disable_intr, tegra_pcib_msi_disable_intr), 1608 DEVMETHOD(pic_enable_intr, tegra_pcib_msi_enable_intr), 1609 DEVMETHOD(pic_setup_intr, tegra_pcib_msi_setup_intr), 1610 DEVMETHOD(pic_teardown_intr, tegra_pcib_msi_teardown_intr), 1611 DEVMETHOD(pic_post_filter, tegra_pcib_msi_post_filter), 1612 DEVMETHOD(pic_post_ithread, tegra_pcib_msi_post_ithread), 1613 DEVMETHOD(pic_pre_ithread, tegra_pcib_msi_pre_ithread), 1614 #endif 1615 1616 /* OFW bus interface */ 1617 DEVMETHOD(ofw_bus_get_compat, ofw_bus_gen_get_compat), 1618 DEVMETHOD(ofw_bus_get_model, ofw_bus_gen_get_model), 1619 DEVMETHOD(ofw_bus_get_name, ofw_bus_gen_get_name), 1620 DEVMETHOD(ofw_bus_get_node, ofw_bus_gen_get_node), 1621 DEVMETHOD(ofw_bus_get_type, ofw_bus_gen_get_type), 1622 1623 DEVMETHOD_END 1624 }; 1625 1626 static devclass_t pcib_devclass; 1627 DEFINE_CLASS_1(pcib, tegra_pcib_driver, tegra_pcib_methods, 1628 sizeof(struct tegra_pcib_softc), ofw_pci_driver); 1629 DRIVER_MODULE(tegra_pcib, simplebus, tegra_pcib_driver, pcib_devclass, 1630 NULL, NULL);
Cache object: f07b5e50ddfc2b0a3705e9015c290fd3
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]