1 /* 2 * Copyright 2014-2015 Freescale Semiconductor, Inc. 3 * Layerscape PCIe driver 4 * 5 * SPDX-License-Identifier: GPL-2.0+ 6 */ 7 8 #include <common.h> 9 #include <asm/arch/fsl_serdes.h> 10 #include <pci.h> 11 #include <asm/io.h> 12 #include <errno.h> 13 #include <malloc.h> 14 #ifndef CONFIG_LS102XA 15 #include <asm/arch/fdt.h> 16 #include <asm/arch/soc.h> 17 #else 18 #include <asm/arch/immap_ls102xa.h> 19 #endif 20 #include "pcie_layerscape.h" 21 22 #ifdef CONFIG_LS102XA 23 /* PEX1/2 Misc Ports Status Register */ 24 #define LTSSM_STATE_SHIFT 20 25 26 static int ls_pcie_link_state(struct ls_pcie *pcie) 27 { 28 u32 state; 29 struct ccsr_scfg *scfg = (struct ccsr_scfg *)CONFIG_SYS_FSL_SCFG_ADDR; 30 31 state = in_be32(&scfg->pexmscportsr[pcie->idx]); 32 state = (state >> LTSSM_STATE_SHIFT) & LTSSM_STATE_MASK; 33 if (state < LTSSM_PCIE_L0) { 34 debug("....PCIe link error. LTSSM=0x%02x.\n", state); 35 return 0; 36 } 37 38 return 1; 39 } 40 #else 41 static int ls_pcie_link_state(struct ls_pcie *pcie) 42 { 43 u32 state; 44 45 state = pex_lut_in32(pcie->dbi + PCIE_LUT_BASE + PCIE_LUT_DBG) & 46 LTSSM_STATE_MASK; 47 if (state < LTSSM_PCIE_L0) { 48 debug("....PCIe link error. LTSSM=0x%02x.\n", state); 49 return 0; 50 } 51 52 return 1; 53 } 54 #endif 55 56 static int ls_pcie_link_up(struct ls_pcie *pcie) 57 { 58 int state; 59 u32 cap; 60 61 state = ls_pcie_link_state(pcie); 62 if (state) 63 return state; 64 65 /* Try to download speed to gen1 */ 66 cap = readl(pcie->dbi + PCIE_LINK_CAP); 67 writel((cap & (~PCIE_LINK_SPEED_MASK)) | 1, pcie->dbi + PCIE_LINK_CAP); 68 /* 69 * Notice: the following delay has critical impact on link training 70 * if too short (<30ms) the link doesn't get up. 71 */ 72 mdelay(100); 73 state = ls_pcie_link_state(pcie); 74 if (state) 75 return state; 76 77 writel(cap, pcie->dbi + PCIE_LINK_CAP); 78 79 return 0; 80 } 81 82 static void ls_pcie_cfg0_set_busdev(struct ls_pcie *pcie, u32 busdev) 83 { 84 writel(PCIE_ATU_REGION_OUTBOUND | PCIE_ATU_REGION_INDEX0, 85 pcie->dbi + PCIE_ATU_VIEWPORT); 86 writel(busdev, pcie->dbi + PCIE_ATU_LOWER_TARGET); 87 } 88 89 static void ls_pcie_cfg1_set_busdev(struct ls_pcie *pcie, u32 busdev) 90 { 91 writel(PCIE_ATU_REGION_OUTBOUND | PCIE_ATU_REGION_INDEX1, 92 pcie->dbi + PCIE_ATU_VIEWPORT); 93 writel(busdev, pcie->dbi + PCIE_ATU_LOWER_TARGET); 94 } 95 96 static void ls_pcie_iatu_outbound_set(struct ls_pcie *pcie, int idx, int type, 97 u64 phys, u64 bus_addr, pci_size_t size) 98 { 99 writel(PCIE_ATU_REGION_OUTBOUND | idx, pcie->dbi + PCIE_ATU_VIEWPORT); 100 writel((u32)phys, pcie->dbi + PCIE_ATU_LOWER_BASE); 101 writel(phys >> 32, pcie->dbi + PCIE_ATU_UPPER_BASE); 102 writel(phys + size - 1, pcie->dbi + PCIE_ATU_LIMIT); 103 writel((u32)bus_addr, pcie->dbi + PCIE_ATU_LOWER_TARGET); 104 writel(bus_addr >> 32, pcie->dbi + PCIE_ATU_UPPER_TARGET); 105 writel(type, pcie->dbi + PCIE_ATU_CR1); 106 writel(PCIE_ATU_ENABLE, pcie->dbi + PCIE_ATU_CR2); 107 } 108 109 /* Use bar match mode and MEM type as default */ 110 static void ls_pcie_iatu_inbound_set(struct ls_pcie *pcie, int idx, 111 int bar, u64 phys) 112 { 113 writel(PCIE_ATU_REGION_INBOUND | idx, pcie->dbi + PCIE_ATU_VIEWPORT); 114 writel((u32)phys, pcie->dbi + PCIE_ATU_LOWER_TARGET); 115 writel(phys >> 32, pcie->dbi + PCIE_ATU_UPPER_TARGET); 116 writel(PCIE_ATU_TYPE_MEM, pcie->dbi + PCIE_ATU_CR1); 117 writel(PCIE_ATU_ENABLE | PCIE_ATU_BAR_MODE_ENABLE | 118 PCIE_ATU_BAR_NUM(bar), pcie->dbi + PCIE_ATU_CR2); 119 } 120 121 static void ls_pcie_setup_atu(struct ls_pcie *pcie, struct ls_pcie_info *info) 122 { 123 #ifdef DEBUG 124 int i; 125 #endif 126 127 /* ATU 0 : OUTBOUND : CFG0 */ 128 ls_pcie_iatu_outbound_set(pcie, PCIE_ATU_REGION_INDEX0, 129 PCIE_ATU_TYPE_CFG0, 130 info->cfg0_phys, 131 0, 132 info->cfg0_size); 133 /* ATU 1 : OUTBOUND : CFG1 */ 134 ls_pcie_iatu_outbound_set(pcie, PCIE_ATU_REGION_INDEX1, 135 PCIE_ATU_TYPE_CFG1, 136 info->cfg1_phys, 137 0, 138 info->cfg1_size); 139 /* ATU 2 : OUTBOUND : MEM */ 140 ls_pcie_iatu_outbound_set(pcie, PCIE_ATU_REGION_INDEX2, 141 PCIE_ATU_TYPE_MEM, 142 info->mem_phys, 143 info->mem_bus, 144 info->mem_size); 145 /* ATU 3 : OUTBOUND : IO */ 146 ls_pcie_iatu_outbound_set(pcie, PCIE_ATU_REGION_INDEX3, 147 PCIE_ATU_TYPE_IO, 148 info->io_phys, 149 info->io_bus, 150 info->io_size); 151 152 #ifdef DEBUG 153 for (i = 0; i <= PCIE_ATU_REGION_INDEX3; i++) { 154 writel(PCIE_ATU_REGION_OUTBOUND | i, 155 pcie->dbi + PCIE_ATU_VIEWPORT); 156 debug("iATU%d:\n", i); 157 debug("\tLOWER PHYS 0x%08x\n", 158 readl(pcie->dbi + PCIE_ATU_LOWER_BASE)); 159 debug("\tUPPER PHYS 0x%08x\n", 160 readl(pcie->dbi + PCIE_ATU_UPPER_BASE)); 161 debug("\tLOWER BUS 0x%08x\n", 162 readl(pcie->dbi + PCIE_ATU_LOWER_TARGET)); 163 debug("\tUPPER BUS 0x%08x\n", 164 readl(pcie->dbi + PCIE_ATU_UPPER_TARGET)); 165 debug("\tLIMIT 0x%08x\n", 166 readl(pcie->dbi + PCIE_ATU_LIMIT)); 167 debug("\tCR1 0x%08x\n", 168 readl(pcie->dbi + PCIE_ATU_CR1)); 169 debug("\tCR2 0x%08x\n", 170 readl(pcie->dbi + PCIE_ATU_CR2)); 171 } 172 #endif 173 } 174 175 int pci_skip_dev(struct pci_controller *hose, pci_dev_t dev) 176 { 177 /* Do not skip controller */ 178 return 0; 179 } 180 181 static int ls_pcie_addr_valid(struct pci_controller *hose, pci_dev_t d) 182 { 183 if (PCI_DEV(d) > 0) 184 return -EINVAL; 185 186 /* Controller does not support multi-function in RC mode */ 187 if ((PCI_BUS(d) == hose->first_busno) && (PCI_FUNC(d) > 0)) 188 return -EINVAL; 189 190 return 0; 191 } 192 193 static int ls_pcie_read_config(struct pci_controller *hose, pci_dev_t d, 194 int where, u32 *val) 195 { 196 struct ls_pcie *pcie = hose->priv_data; 197 u32 busdev, *addr; 198 199 if (ls_pcie_addr_valid(hose, d)) { 200 *val = 0xffffffff; 201 return 0; 202 } 203 204 if (PCI_BUS(d) == hose->first_busno) { 205 addr = pcie->dbi + (where & ~0x3); 206 } else { 207 busdev = PCIE_ATU_BUS(PCI_BUS(d)) | 208 PCIE_ATU_DEV(PCI_DEV(d)) | 209 PCIE_ATU_FUNC(PCI_FUNC(d)); 210 211 if (PCI_BUS(d) == hose->first_busno + 1) { 212 ls_pcie_cfg0_set_busdev(pcie, busdev); 213 addr = pcie->va_cfg0 + (where & ~0x3); 214 } else { 215 ls_pcie_cfg1_set_busdev(pcie, busdev); 216 addr = pcie->va_cfg1 + (where & ~0x3); 217 } 218 } 219 220 *val = readl(addr); 221 222 return 0; 223 } 224 225 static int ls_pcie_write_config(struct pci_controller *hose, pci_dev_t d, 226 int where, u32 val) 227 { 228 struct ls_pcie *pcie = hose->priv_data; 229 u32 busdev, *addr; 230 231 if (ls_pcie_addr_valid(hose, d)) 232 return -EINVAL; 233 234 if (PCI_BUS(d) == hose->first_busno) { 235 addr = pcie->dbi + (where & ~0x3); 236 } else { 237 busdev = PCIE_ATU_BUS(PCI_BUS(d)) | 238 PCIE_ATU_DEV(PCI_DEV(d)) | 239 PCIE_ATU_FUNC(PCI_FUNC(d)); 240 241 if (PCI_BUS(d) == hose->first_busno + 1) { 242 ls_pcie_cfg0_set_busdev(pcie, busdev); 243 addr = pcie->va_cfg0 + (where & ~0x3); 244 } else { 245 ls_pcie_cfg1_set_busdev(pcie, busdev); 246 addr = pcie->va_cfg1 + (where & ~0x3); 247 } 248 } 249 250 writel(val, addr); 251 252 return 0; 253 } 254 255 static void ls_pcie_setup_ctrl(struct ls_pcie *pcie, 256 struct ls_pcie_info *info) 257 { 258 struct pci_controller *hose = &pcie->hose; 259 pci_dev_t dev = PCI_BDF(hose->first_busno, 0, 0); 260 261 ls_pcie_setup_atu(pcie, info); 262 263 pci_hose_write_config_dword(hose, dev, PCI_BASE_ADDRESS_0, 0); 264 265 /* program correct class for RC */ 266 writel(1, pcie->dbi + PCIE_DBI_RO_WR_EN); 267 pci_hose_write_config_word(hose, dev, PCI_CLASS_DEVICE, 268 PCI_CLASS_BRIDGE_PCI); 269 #ifndef CONFIG_LS102XA 270 writel(0, pcie->dbi + PCIE_DBI_RO_WR_EN); 271 #endif 272 } 273 274 static void ls_pcie_ep_setup_atu(struct ls_pcie *pcie, 275 struct ls_pcie_info *info) 276 { 277 u64 phys = CONFIG_SYS_PCI_EP_MEMORY_BASE; 278 279 /* ATU 0 : INBOUND : map BAR0 */ 280 ls_pcie_iatu_inbound_set(pcie, PCIE_ATU_REGION_INDEX0, 0, phys); 281 /* ATU 1 : INBOUND : map BAR1 */ 282 phys += PCIE_BAR1_SIZE; 283 ls_pcie_iatu_inbound_set(pcie, PCIE_ATU_REGION_INDEX1, 1, phys); 284 /* ATU 2 : INBOUND : map BAR2 */ 285 phys += PCIE_BAR2_SIZE; 286 ls_pcie_iatu_inbound_set(pcie, PCIE_ATU_REGION_INDEX2, 2, phys); 287 /* ATU 3 : INBOUND : map BAR4 */ 288 phys = CONFIG_SYS_PCI_EP_MEMORY_BASE + PCIE_BAR4_SIZE; 289 ls_pcie_iatu_inbound_set(pcie, PCIE_ATU_REGION_INDEX3, 4, phys); 290 291 /* ATU 0 : OUTBOUND : map 4G MEM */ 292 ls_pcie_iatu_outbound_set(pcie, PCIE_ATU_REGION_INDEX0, 293 PCIE_ATU_TYPE_MEM, 294 info->phys_base, 295 0, 296 4 * 1024 * 1024 * 1024ULL); 297 } 298 299 /* BAR0 and BAR1 are 32bit BAR2 and BAR4 are 64bit */ 300 static void ls_pcie_ep_setup_bar(void *bar_base, int bar, u32 size) 301 { 302 if (size < 4 * 1024) 303 return; 304 305 switch (bar) { 306 case 0: 307 writel(size - 1, bar_base + PCI_BASE_ADDRESS_0); 308 break; 309 case 1: 310 writel(size - 1, bar_base + PCI_BASE_ADDRESS_1); 311 break; 312 case 2: 313 writel(size - 1, bar_base + PCI_BASE_ADDRESS_2); 314 writel(0, bar_base + PCI_BASE_ADDRESS_3); 315 break; 316 case 4: 317 writel(size - 1, bar_base + PCI_BASE_ADDRESS_4); 318 writel(0, bar_base + PCI_BASE_ADDRESS_5); 319 break; 320 default: 321 break; 322 } 323 } 324 325 static void ls_pcie_ep_setup_bars(void *bar_base) 326 { 327 /* BAR0 - 32bit - 4K configuration */ 328 ls_pcie_ep_setup_bar(bar_base, 0, PCIE_BAR0_SIZE); 329 /* BAR1 - 32bit - 8K MSIX*/ 330 ls_pcie_ep_setup_bar(bar_base, 1, PCIE_BAR1_SIZE); 331 /* BAR2 - 64bit - 4K MEM desciptor */ 332 ls_pcie_ep_setup_bar(bar_base, 2, PCIE_BAR2_SIZE); 333 /* BAR4 - 64bit - 1M MEM*/ 334 ls_pcie_ep_setup_bar(bar_base, 4, PCIE_BAR4_SIZE); 335 } 336 337 static void ls_pcie_setup_ep(struct ls_pcie *pcie, struct ls_pcie_info *info) 338 { 339 struct pci_controller *hose = &pcie->hose; 340 pci_dev_t dev = PCI_BDF(hose->first_busno, 0, 0); 341 int sriov; 342 343 sriov = pci_hose_find_ext_capability(hose, dev, PCI_EXT_CAP_ID_SRIOV); 344 if (sriov) { 345 int pf, vf; 346 347 for (pf = 0; pf < PCIE_PF_NUM; pf++) { 348 for (vf = 0; vf <= PCIE_VF_NUM; vf++) { 349 #ifndef CONFIG_LS102XA 350 writel(PCIE_LCTRL0_VAL(pf, vf), 351 pcie->dbi + PCIE_LUT_BASE + 352 PCIE_LUT_LCTRL0); 353 #endif 354 ls_pcie_ep_setup_bars(pcie->dbi); 355 ls_pcie_ep_setup_atu(pcie, info); 356 } 357 } 358 359 /* Disable CFG2 */ 360 #ifndef CONFIG_LS102XA 361 writel(0, pcie->dbi + PCIE_LUT_BASE + PCIE_LUT_LCTRL0); 362 #endif 363 } else { 364 ls_pcie_ep_setup_bars(pcie->dbi + PCIE_NO_SRIOV_BAR_BASE); 365 ls_pcie_ep_setup_atu(pcie, info); 366 } 367 } 368 369 int ls_pcie_init_ctrl(int busno, enum srds_prtcl dev, struct ls_pcie_info *info) 370 { 371 struct ls_pcie *pcie; 372 struct pci_controller *hose; 373 int num = dev - PCIE1; 374 pci_dev_t pdev = PCI_BDF(busno, 0, 0); 375 int i, linkup, ep_mode; 376 u8 header_type; 377 u16 temp16; 378 379 if (!is_serdes_configured(dev)) { 380 printf("PCIe%d: disabled\n", num + 1); 381 return busno; 382 } 383 384 pcie = malloc(sizeof(*pcie)); 385 if (!pcie) 386 return busno; 387 memset(pcie, 0, sizeof(*pcie)); 388 389 hose = &pcie->hose; 390 hose->priv_data = pcie; 391 hose->first_busno = busno; 392 pcie->idx = num; 393 pcie->dbi = map_physmem(info->regs, PCIE_DBI_SIZE, MAP_NOCACHE); 394 pcie->va_cfg0 = map_physmem(info->cfg0_phys, 395 info->cfg0_size, 396 MAP_NOCACHE); 397 pcie->va_cfg1 = map_physmem(info->cfg1_phys, 398 info->cfg1_size, 399 MAP_NOCACHE); 400 pcie->next_lut_index = 0; 401 402 /* outbound memory */ 403 pci_set_region(&hose->regions[0], 404 (pci_size_t)info->mem_bus, 405 (phys_size_t)info->mem_phys, 406 (pci_size_t)info->mem_size, 407 PCI_REGION_MEM); 408 409 /* outbound io */ 410 pci_set_region(&hose->regions[1], 411 (pci_size_t)info->io_bus, 412 (phys_size_t)info->io_phys, 413 (pci_size_t)info->io_size, 414 PCI_REGION_IO); 415 416 /* System memory space */ 417 pci_set_region(&hose->regions[2], 418 CONFIG_SYS_PCI_MEMORY_BUS, 419 CONFIG_SYS_PCI_MEMORY_PHYS, 420 CONFIG_SYS_PCI_MEMORY_SIZE, 421 PCI_REGION_SYS_MEMORY); 422 423 hose->region_count = 3; 424 425 for (i = 0; i < hose->region_count; i++) 426 debug("PCI reg:%d %016llx:%016llx %016llx %08lx\n", 427 i, 428 (u64)hose->regions[i].phys_start, 429 (u64)hose->regions[i].bus_start, 430 (u64)hose->regions[i].size, 431 hose->regions[i].flags); 432 433 pci_set_ops(hose, 434 pci_hose_read_config_byte_via_dword, 435 pci_hose_read_config_word_via_dword, 436 ls_pcie_read_config, 437 pci_hose_write_config_byte_via_dword, 438 pci_hose_write_config_word_via_dword, 439 ls_pcie_write_config); 440 441 pci_hose_read_config_byte(hose, pdev, PCI_HEADER_TYPE, &header_type); 442 ep_mode = (header_type & 0x7f) == PCI_HEADER_TYPE_NORMAL; 443 printf("PCIe%u: %s ", info->pci_num, 444 ep_mode ? "Endpoint" : "Root Complex"); 445 446 if (ep_mode) 447 ls_pcie_setup_ep(pcie, info); 448 else 449 ls_pcie_setup_ctrl(pcie, info); 450 451 linkup = ls_pcie_link_up(pcie); 452 453 if (!linkup) { 454 /* Let the user know there's no PCIe link */ 455 printf("no link, regs @ 0x%lx\n", info->regs); 456 hose->last_busno = hose->first_busno; 457 return busno; 458 } 459 460 /* Print the negotiated PCIe link width */ 461 pci_hose_read_config_word(hose, pdev, PCIE_LINK_STA, &temp16); 462 printf("x%d gen%d, regs @ 0x%lx\n", (temp16 & 0x3f0) >> 4, 463 (temp16 & 0xf), info->regs); 464 465 if (ep_mode) 466 return busno; 467 468 pci_register_hose(hose); 469 470 hose->last_busno = pci_hose_scan(hose); 471 472 printf("PCIe%x: Bus %02x - %02x\n", 473 info->pci_num, hose->first_busno, hose->last_busno); 474 475 return hose->last_busno + 1; 476 } 477 478 int ls_pcie_init_board(int busno) 479 { 480 struct ls_pcie_info info; 481 482 #ifdef CONFIG_PCIE1 483 SET_LS_PCIE_INFO(info, 1); 484 busno = ls_pcie_init_ctrl(busno, PCIE1, &info); 485 #endif 486 487 #ifdef CONFIG_PCIE2 488 SET_LS_PCIE_INFO(info, 2); 489 busno = ls_pcie_init_ctrl(busno, PCIE2, &info); 490 #endif 491 492 #ifdef CONFIG_PCIE3 493 SET_LS_PCIE_INFO(info, 3); 494 busno = ls_pcie_init_ctrl(busno, PCIE3, &info); 495 #endif 496 497 #ifdef CONFIG_PCIE4 498 SET_LS_PCIE_INFO(info, 4); 499 busno = ls_pcie_init_ctrl(busno, PCIE4, &info); 500 #endif 501 502 return busno; 503 } 504 505 void pci_init_board(void) 506 { 507 ls_pcie_init_board(0); 508 } 509