1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Synopsys DesignWare PCIe Endpoint controller driver 4 * 5 * Copyright (C) 2017 Texas Instruments 6 * Author: Kishon Vijay Abraham I <kishon@ti.com> 7 */ 8 9 #include <linux/align.h> 10 #include <linux/bitfield.h> 11 #include <linux/of.h> 12 #include <linux/platform_device.h> 13 14 #include "pcie-designware.h" 15 #include <linux/pci-epc.h> 16 #include <linux/pci-epf.h> 17 18 void dw_pcie_ep_linkup(struct dw_pcie_ep *ep) 19 { 20 struct pci_epc *epc = ep->epc; 21 22 pci_epc_linkup(epc); 23 } 24 EXPORT_SYMBOL_GPL(dw_pcie_ep_linkup); 25 26 void dw_pcie_ep_init_notify(struct dw_pcie_ep *ep) 27 { 28 struct pci_epc *epc = ep->epc; 29 30 pci_epc_init_notify(epc); 31 } 32 EXPORT_SYMBOL_GPL(dw_pcie_ep_init_notify); 33 34 struct dw_pcie_ep_func * 35 dw_pcie_ep_get_func_from_ep(struct dw_pcie_ep *ep, u8 func_no) 36 { 37 struct dw_pcie_ep_func *ep_func; 38 39 list_for_each_entry(ep_func, &ep->func_list, list) { 40 if (ep_func->func_no == func_no) 41 return ep_func; 42 } 43 44 return NULL; 45 } 46 47 static void __dw_pcie_ep_reset_bar(struct dw_pcie *pci, u8 func_no, 48 enum pci_barno bar, int flags) 49 { 50 struct dw_pcie_ep *ep = &pci->ep; 51 u32 reg; 52 53 reg = PCI_BASE_ADDRESS_0 + (4 * bar); 54 dw_pcie_dbi_ro_wr_en(pci); 55 dw_pcie_ep_writel_dbi2(ep, func_no, reg, 0x0); 56 dw_pcie_ep_writel_dbi(ep, func_no, reg, 0x0); 57 if (flags & PCI_BASE_ADDRESS_MEM_TYPE_64) { 58 dw_pcie_ep_writel_dbi2(ep, func_no, reg + 4, 0x0); 59 dw_pcie_ep_writel_dbi(ep, func_no, reg + 4, 0x0); 60 } 61 dw_pcie_dbi_ro_wr_dis(pci); 62 } 63 64 void dw_pcie_ep_reset_bar(struct dw_pcie *pci, enum pci_barno bar) 65 { 66 u8 func_no, funcs; 67 68 funcs = pci->ep.epc->max_functions; 69 70 for (func_no = 0; func_no < funcs; func_no++) 71 __dw_pcie_ep_reset_bar(pci, func_no, bar, 0); 72 } 73 EXPORT_SYMBOL_GPL(dw_pcie_ep_reset_bar); 74 75 static u8 __dw_pcie_ep_find_next_cap(struct dw_pcie_ep *ep, u8 func_no, 76 u8 cap_ptr, u8 cap) 77 { 78 u8 cap_id, next_cap_ptr; 79 u16 reg; 80 81 if (!cap_ptr) 82 return 0; 83 84 reg = dw_pcie_ep_readw_dbi(ep, func_no, cap_ptr); 85 cap_id = (reg & 0x00ff); 86 87 if (cap_id > PCI_CAP_ID_MAX) 88 return 0; 89 90 if (cap_id == cap) 91 return cap_ptr; 92 93 next_cap_ptr = (reg & 0xff00) >> 8; 94 return __dw_pcie_ep_find_next_cap(ep, func_no, next_cap_ptr, cap); 95 } 96 97 static u8 dw_pcie_ep_find_capability(struct dw_pcie_ep *ep, u8 func_no, u8 cap) 98 { 99 u8 next_cap_ptr; 100 u16 reg; 101 102 reg = dw_pcie_ep_readw_dbi(ep, func_no, PCI_CAPABILITY_LIST); 103 next_cap_ptr = (reg & 0x00ff); 104 105 return __dw_pcie_ep_find_next_cap(ep, func_no, next_cap_ptr, cap); 106 } 107 108 static int dw_pcie_ep_write_header(struct pci_epc *epc, u8 func_no, u8 vfunc_no, 109 struct pci_epf_header *hdr) 110 { 111 struct dw_pcie_ep *ep = epc_get_drvdata(epc); 112 struct dw_pcie *pci = to_dw_pcie_from_ep(ep); 113 114 dw_pcie_dbi_ro_wr_en(pci); 115 dw_pcie_ep_writew_dbi(ep, func_no, PCI_VENDOR_ID, hdr->vendorid); 116 dw_pcie_ep_writew_dbi(ep, func_no, PCI_DEVICE_ID, hdr->deviceid); 117 dw_pcie_ep_writeb_dbi(ep, func_no, PCI_REVISION_ID, hdr->revid); 118 dw_pcie_ep_writeb_dbi(ep, func_no, PCI_CLASS_PROG, hdr->progif_code); 119 dw_pcie_ep_writew_dbi(ep, func_no, PCI_CLASS_DEVICE, 120 hdr->subclass_code | hdr->baseclass_code << 8); 121 dw_pcie_ep_writeb_dbi(ep, func_no, PCI_CACHE_LINE_SIZE, 122 hdr->cache_line_size); 123 dw_pcie_ep_writew_dbi(ep, func_no, PCI_SUBSYSTEM_VENDOR_ID, 124 hdr->subsys_vendor_id); 125 dw_pcie_ep_writew_dbi(ep, func_no, PCI_SUBSYSTEM_ID, hdr->subsys_id); 126 dw_pcie_ep_writeb_dbi(ep, func_no, PCI_INTERRUPT_PIN, 127 hdr->interrupt_pin); 128 dw_pcie_dbi_ro_wr_dis(pci); 129 130 return 0; 131 } 132 133 static int dw_pcie_ep_inbound_atu(struct dw_pcie_ep *ep, u8 func_no, int type, 134 dma_addr_t cpu_addr, enum pci_barno bar) 135 { 136 int ret; 137 u32 free_win; 138 struct dw_pcie *pci = to_dw_pcie_from_ep(ep); 139 140 if (!ep->bar_to_atu[bar]) 141 free_win = find_first_zero_bit(ep->ib_window_map, pci->num_ib_windows); 142 else 143 free_win = ep->bar_to_atu[bar]; 144 145 if (free_win >= pci->num_ib_windows) { 146 dev_err(pci->dev, "No free inbound window\n"); 147 return -EINVAL; 148 } 149 150 ret = dw_pcie_prog_ep_inbound_atu(pci, func_no, free_win, type, 151 cpu_addr, bar); 152 if (ret < 0) { 153 dev_err(pci->dev, "Failed to program IB window\n"); 154 return ret; 155 } 156 157 ep->bar_to_atu[bar] = free_win; 158 set_bit(free_win, ep->ib_window_map); 159 160 return 0; 161 } 162 163 static int dw_pcie_ep_outbound_atu(struct dw_pcie_ep *ep, u8 func_no, 164 phys_addr_t phys_addr, 165 u64 pci_addr, size_t size) 166 { 167 struct dw_pcie *pci = to_dw_pcie_from_ep(ep); 168 u32 free_win; 169 int ret; 170 171 free_win = find_first_zero_bit(ep->ob_window_map, pci->num_ob_windows); 172 if (free_win >= pci->num_ob_windows) { 173 dev_err(pci->dev, "No free outbound window\n"); 174 return -EINVAL; 175 } 176 177 ret = dw_pcie_prog_ep_outbound_atu(pci, func_no, free_win, PCIE_ATU_TYPE_MEM, 178 phys_addr, pci_addr, size); 179 if (ret) 180 return ret; 181 182 set_bit(free_win, ep->ob_window_map); 183 ep->outbound_addr[free_win] = phys_addr; 184 185 return 0; 186 } 187 188 static void dw_pcie_ep_clear_bar(struct pci_epc *epc, u8 func_no, u8 vfunc_no, 189 struct pci_epf_bar *epf_bar) 190 { 191 struct dw_pcie_ep *ep = epc_get_drvdata(epc); 192 struct dw_pcie *pci = to_dw_pcie_from_ep(ep); 193 enum pci_barno bar = epf_bar->barno; 194 u32 atu_index = ep->bar_to_atu[bar]; 195 196 __dw_pcie_ep_reset_bar(pci, func_no, bar, epf_bar->flags); 197 198 dw_pcie_disable_atu(pci, PCIE_ATU_REGION_DIR_IB, atu_index); 199 clear_bit(atu_index, ep->ib_window_map); 200 ep->epf_bar[bar] = NULL; 201 ep->bar_to_atu[bar] = 0; 202 } 203 204 static int dw_pcie_ep_set_bar(struct pci_epc *epc, u8 func_no, u8 vfunc_no, 205 struct pci_epf_bar *epf_bar) 206 { 207 struct dw_pcie_ep *ep = epc_get_drvdata(epc); 208 struct dw_pcie *pci = to_dw_pcie_from_ep(ep); 209 enum pci_barno bar = epf_bar->barno; 210 size_t size = epf_bar->size; 211 int flags = epf_bar->flags; 212 int ret, type; 213 u32 reg; 214 215 reg = PCI_BASE_ADDRESS_0 + (4 * bar); 216 217 if (!(flags & PCI_BASE_ADDRESS_SPACE)) 218 type = PCIE_ATU_TYPE_MEM; 219 else 220 type = PCIE_ATU_TYPE_IO; 221 222 ret = dw_pcie_ep_inbound_atu(ep, func_no, type, epf_bar->phys_addr, bar); 223 if (ret) 224 return ret; 225 226 if (ep->epf_bar[bar]) 227 return 0; 228 229 dw_pcie_dbi_ro_wr_en(pci); 230 231 dw_pcie_ep_writel_dbi2(ep, func_no, reg, lower_32_bits(size - 1)); 232 dw_pcie_ep_writel_dbi(ep, func_no, reg, flags); 233 234 if (flags & PCI_BASE_ADDRESS_MEM_TYPE_64) { 235 dw_pcie_ep_writel_dbi2(ep, func_no, reg + 4, upper_32_bits(size - 1)); 236 dw_pcie_ep_writel_dbi(ep, func_no, reg + 4, 0); 237 } 238 239 ep->epf_bar[bar] = epf_bar; 240 dw_pcie_dbi_ro_wr_dis(pci); 241 242 return 0; 243 } 244 245 static int dw_pcie_find_index(struct dw_pcie_ep *ep, phys_addr_t addr, 246 u32 *atu_index) 247 { 248 u32 index; 249 struct dw_pcie *pci = to_dw_pcie_from_ep(ep); 250 251 for (index = 0; index < pci->num_ob_windows; index++) { 252 if (ep->outbound_addr[index] != addr) 253 continue; 254 *atu_index = index; 255 return 0; 256 } 257 258 return -EINVAL; 259 } 260 261 static void dw_pcie_ep_unmap_addr(struct pci_epc *epc, u8 func_no, u8 vfunc_no, 262 phys_addr_t addr) 263 { 264 int ret; 265 u32 atu_index; 266 struct dw_pcie_ep *ep = epc_get_drvdata(epc); 267 struct dw_pcie *pci = to_dw_pcie_from_ep(ep); 268 269 ret = dw_pcie_find_index(ep, addr, &atu_index); 270 if (ret < 0) 271 return; 272 273 dw_pcie_disable_atu(pci, PCIE_ATU_REGION_DIR_OB, atu_index); 274 clear_bit(atu_index, ep->ob_window_map); 275 } 276 277 static int dw_pcie_ep_map_addr(struct pci_epc *epc, u8 func_no, u8 vfunc_no, 278 phys_addr_t addr, u64 pci_addr, size_t size) 279 { 280 int ret; 281 struct dw_pcie_ep *ep = epc_get_drvdata(epc); 282 struct dw_pcie *pci = to_dw_pcie_from_ep(ep); 283 284 ret = dw_pcie_ep_outbound_atu(ep, func_no, addr, pci_addr, size); 285 if (ret) { 286 dev_err(pci->dev, "Failed to enable address\n"); 287 return ret; 288 } 289 290 return 0; 291 } 292 293 static int dw_pcie_ep_get_msi(struct pci_epc *epc, u8 func_no, u8 vfunc_no) 294 { 295 struct dw_pcie_ep *ep = epc_get_drvdata(epc); 296 struct dw_pcie_ep_func *ep_func; 297 u32 val, reg; 298 299 ep_func = dw_pcie_ep_get_func_from_ep(ep, func_no); 300 if (!ep_func || !ep_func->msi_cap) 301 return -EINVAL; 302 303 reg = ep_func->msi_cap + PCI_MSI_FLAGS; 304 val = dw_pcie_ep_readw_dbi(ep, func_no, reg); 305 if (!(val & PCI_MSI_FLAGS_ENABLE)) 306 return -EINVAL; 307 308 val = FIELD_GET(PCI_MSI_FLAGS_QSIZE, val); 309 310 return val; 311 } 312 313 static int dw_pcie_ep_set_msi(struct pci_epc *epc, u8 func_no, u8 vfunc_no, 314 u8 interrupts) 315 { 316 struct dw_pcie_ep *ep = epc_get_drvdata(epc); 317 struct dw_pcie *pci = to_dw_pcie_from_ep(ep); 318 struct dw_pcie_ep_func *ep_func; 319 u32 val, reg; 320 321 ep_func = dw_pcie_ep_get_func_from_ep(ep, func_no); 322 if (!ep_func || !ep_func->msi_cap) 323 return -EINVAL; 324 325 reg = ep_func->msi_cap + PCI_MSI_FLAGS; 326 val = dw_pcie_ep_readw_dbi(ep, func_no, reg); 327 val &= ~PCI_MSI_FLAGS_QMASK; 328 val |= FIELD_PREP(PCI_MSI_FLAGS_QMASK, interrupts); 329 dw_pcie_dbi_ro_wr_en(pci); 330 dw_pcie_ep_writew_dbi(ep, func_no, reg, val); 331 dw_pcie_dbi_ro_wr_dis(pci); 332 333 return 0; 334 } 335 336 static int dw_pcie_ep_get_msix(struct pci_epc *epc, u8 func_no, u8 vfunc_no) 337 { 338 struct dw_pcie_ep *ep = epc_get_drvdata(epc); 339 struct dw_pcie_ep_func *ep_func; 340 u32 val, reg; 341 342 ep_func = dw_pcie_ep_get_func_from_ep(ep, func_no); 343 if (!ep_func || !ep_func->msix_cap) 344 return -EINVAL; 345 346 reg = ep_func->msix_cap + PCI_MSIX_FLAGS; 347 val = dw_pcie_ep_readw_dbi(ep, func_no, reg); 348 if (!(val & PCI_MSIX_FLAGS_ENABLE)) 349 return -EINVAL; 350 351 val &= PCI_MSIX_FLAGS_QSIZE; 352 353 return val; 354 } 355 356 static int dw_pcie_ep_set_msix(struct pci_epc *epc, u8 func_no, u8 vfunc_no, 357 u16 interrupts, enum pci_barno bir, u32 offset) 358 { 359 struct dw_pcie_ep *ep = epc_get_drvdata(epc); 360 struct dw_pcie *pci = to_dw_pcie_from_ep(ep); 361 struct dw_pcie_ep_func *ep_func; 362 u32 val, reg; 363 364 ep_func = dw_pcie_ep_get_func_from_ep(ep, func_no); 365 if (!ep_func || !ep_func->msix_cap) 366 return -EINVAL; 367 368 dw_pcie_dbi_ro_wr_en(pci); 369 370 reg = ep_func->msix_cap + PCI_MSIX_FLAGS; 371 val = dw_pcie_ep_readw_dbi(ep, func_no, reg); 372 val &= ~PCI_MSIX_FLAGS_QSIZE; 373 val |= interrupts; 374 dw_pcie_writew_dbi(pci, reg, val); 375 376 reg = ep_func->msix_cap + PCI_MSIX_TABLE; 377 val = offset | bir; 378 dw_pcie_ep_writel_dbi(ep, func_no, reg, val); 379 380 reg = ep_func->msix_cap + PCI_MSIX_PBA; 381 val = (offset + (interrupts * PCI_MSIX_ENTRY_SIZE)) | bir; 382 dw_pcie_ep_writel_dbi(ep, func_no, reg, val); 383 384 dw_pcie_dbi_ro_wr_dis(pci); 385 386 return 0; 387 } 388 389 static int dw_pcie_ep_raise_irq(struct pci_epc *epc, u8 func_no, u8 vfunc_no, 390 unsigned int type, u16 interrupt_num) 391 { 392 struct dw_pcie_ep *ep = epc_get_drvdata(epc); 393 394 if (!ep->ops->raise_irq) 395 return -EINVAL; 396 397 return ep->ops->raise_irq(ep, func_no, type, interrupt_num); 398 } 399 400 static void dw_pcie_ep_stop(struct pci_epc *epc) 401 { 402 struct dw_pcie_ep *ep = epc_get_drvdata(epc); 403 struct dw_pcie *pci = to_dw_pcie_from_ep(ep); 404 405 dw_pcie_stop_link(pci); 406 } 407 408 static int dw_pcie_ep_start(struct pci_epc *epc) 409 { 410 struct dw_pcie_ep *ep = epc_get_drvdata(epc); 411 struct dw_pcie *pci = to_dw_pcie_from_ep(ep); 412 413 return dw_pcie_start_link(pci); 414 } 415 416 static const struct pci_epc_features* 417 dw_pcie_ep_get_features(struct pci_epc *epc, u8 func_no, u8 vfunc_no) 418 { 419 struct dw_pcie_ep *ep = epc_get_drvdata(epc); 420 421 if (!ep->ops->get_features) 422 return NULL; 423 424 return ep->ops->get_features(ep); 425 } 426 427 static const struct pci_epc_ops epc_ops = { 428 .write_header = dw_pcie_ep_write_header, 429 .set_bar = dw_pcie_ep_set_bar, 430 .clear_bar = dw_pcie_ep_clear_bar, 431 .map_addr = dw_pcie_ep_map_addr, 432 .unmap_addr = dw_pcie_ep_unmap_addr, 433 .set_msi = dw_pcie_ep_set_msi, 434 .get_msi = dw_pcie_ep_get_msi, 435 .set_msix = dw_pcie_ep_set_msix, 436 .get_msix = dw_pcie_ep_get_msix, 437 .raise_irq = dw_pcie_ep_raise_irq, 438 .start = dw_pcie_ep_start, 439 .stop = dw_pcie_ep_stop, 440 .get_features = dw_pcie_ep_get_features, 441 }; 442 443 int dw_pcie_ep_raise_intx_irq(struct dw_pcie_ep *ep, u8 func_no) 444 { 445 struct dw_pcie *pci = to_dw_pcie_from_ep(ep); 446 struct device *dev = pci->dev; 447 448 dev_err(dev, "EP cannot raise INTX IRQs\n"); 449 450 return -EINVAL; 451 } 452 EXPORT_SYMBOL_GPL(dw_pcie_ep_raise_intx_irq); 453 454 int dw_pcie_ep_raise_msi_irq(struct dw_pcie_ep *ep, u8 func_no, 455 u8 interrupt_num) 456 { 457 u32 msg_addr_lower, msg_addr_upper, reg; 458 struct dw_pcie_ep_func *ep_func; 459 struct pci_epc *epc = ep->epc; 460 unsigned int aligned_offset; 461 u16 msg_ctrl, msg_data; 462 bool has_upper; 463 u64 msg_addr; 464 int ret; 465 466 ep_func = dw_pcie_ep_get_func_from_ep(ep, func_no); 467 if (!ep_func || !ep_func->msi_cap) 468 return -EINVAL; 469 470 /* Raise MSI per the PCI Local Bus Specification Revision 3.0, 6.8.1. */ 471 reg = ep_func->msi_cap + PCI_MSI_FLAGS; 472 msg_ctrl = dw_pcie_ep_readw_dbi(ep, func_no, reg); 473 has_upper = !!(msg_ctrl & PCI_MSI_FLAGS_64BIT); 474 reg = ep_func->msi_cap + PCI_MSI_ADDRESS_LO; 475 msg_addr_lower = dw_pcie_ep_readl_dbi(ep, func_no, reg); 476 if (has_upper) { 477 reg = ep_func->msi_cap + PCI_MSI_ADDRESS_HI; 478 msg_addr_upper = dw_pcie_ep_readl_dbi(ep, func_no, reg); 479 reg = ep_func->msi_cap + PCI_MSI_DATA_64; 480 msg_data = dw_pcie_ep_readw_dbi(ep, func_no, reg); 481 } else { 482 msg_addr_upper = 0; 483 reg = ep_func->msi_cap + PCI_MSI_DATA_32; 484 msg_data = dw_pcie_ep_readw_dbi(ep, func_no, reg); 485 } 486 msg_addr = ((u64)msg_addr_upper) << 32 | msg_addr_lower; 487 488 aligned_offset = msg_addr & (epc->mem->window.page_size - 1); 489 msg_addr = ALIGN_DOWN(msg_addr, epc->mem->window.page_size); 490 ret = dw_pcie_ep_map_addr(epc, func_no, 0, ep->msi_mem_phys, msg_addr, 491 epc->mem->window.page_size); 492 if (ret) 493 return ret; 494 495 writel(msg_data | (interrupt_num - 1), ep->msi_mem + aligned_offset); 496 497 dw_pcie_ep_unmap_addr(epc, func_no, 0, ep->msi_mem_phys); 498 499 return 0; 500 } 501 EXPORT_SYMBOL_GPL(dw_pcie_ep_raise_msi_irq); 502 503 int dw_pcie_ep_raise_msix_irq_doorbell(struct dw_pcie_ep *ep, u8 func_no, 504 u16 interrupt_num) 505 { 506 struct dw_pcie *pci = to_dw_pcie_from_ep(ep); 507 struct dw_pcie_ep_func *ep_func; 508 u32 msg_data; 509 510 ep_func = dw_pcie_ep_get_func_from_ep(ep, func_no); 511 if (!ep_func || !ep_func->msix_cap) 512 return -EINVAL; 513 514 msg_data = (func_no << PCIE_MSIX_DOORBELL_PF_SHIFT) | 515 (interrupt_num - 1); 516 517 dw_pcie_writel_dbi(pci, PCIE_MSIX_DOORBELL, msg_data); 518 519 return 0; 520 } 521 522 int dw_pcie_ep_raise_msix_irq(struct dw_pcie_ep *ep, u8 func_no, 523 u16 interrupt_num) 524 { 525 struct dw_pcie *pci = to_dw_pcie_from_ep(ep); 526 struct pci_epf_msix_tbl *msix_tbl; 527 struct dw_pcie_ep_func *ep_func; 528 struct pci_epc *epc = ep->epc; 529 u32 reg, msg_data, vec_ctrl; 530 unsigned int aligned_offset; 531 u32 tbl_offset; 532 u64 msg_addr; 533 int ret; 534 u8 bir; 535 536 ep_func = dw_pcie_ep_get_func_from_ep(ep, func_no); 537 if (!ep_func || !ep_func->msix_cap) 538 return -EINVAL; 539 540 reg = ep_func->msix_cap + PCI_MSIX_TABLE; 541 tbl_offset = dw_pcie_ep_readl_dbi(ep, func_no, reg); 542 bir = FIELD_GET(PCI_MSIX_TABLE_BIR, tbl_offset); 543 tbl_offset &= PCI_MSIX_TABLE_OFFSET; 544 545 msix_tbl = ep->epf_bar[bir]->addr + tbl_offset; 546 msg_addr = msix_tbl[(interrupt_num - 1)].msg_addr; 547 msg_data = msix_tbl[(interrupt_num - 1)].msg_data; 548 vec_ctrl = msix_tbl[(interrupt_num - 1)].vector_ctrl; 549 550 if (vec_ctrl & PCI_MSIX_ENTRY_CTRL_MASKBIT) { 551 dev_dbg(pci->dev, "MSI-X entry ctrl set\n"); 552 return -EPERM; 553 } 554 555 aligned_offset = msg_addr & (epc->mem->window.page_size - 1); 556 msg_addr = ALIGN_DOWN(msg_addr, epc->mem->window.page_size); 557 ret = dw_pcie_ep_map_addr(epc, func_no, 0, ep->msi_mem_phys, msg_addr, 558 epc->mem->window.page_size); 559 if (ret) 560 return ret; 561 562 writel(msg_data, ep->msi_mem + aligned_offset); 563 564 dw_pcie_ep_unmap_addr(epc, func_no, 0, ep->msi_mem_phys); 565 566 return 0; 567 } 568 569 void dw_pcie_ep_exit(struct dw_pcie_ep *ep) 570 { 571 struct dw_pcie *pci = to_dw_pcie_from_ep(ep); 572 struct pci_epc *epc = ep->epc; 573 574 dw_pcie_edma_remove(pci); 575 576 pci_epc_mem_free_addr(epc, ep->msi_mem_phys, ep->msi_mem, 577 epc->mem->window.page_size); 578 579 pci_epc_mem_exit(epc); 580 581 if (ep->ops->deinit) 582 ep->ops->deinit(ep); 583 } 584 EXPORT_SYMBOL_GPL(dw_pcie_ep_exit); 585 586 static unsigned int dw_pcie_ep_find_ext_capability(struct dw_pcie *pci, int cap) 587 { 588 u32 header; 589 int pos = PCI_CFG_SPACE_SIZE; 590 591 while (pos) { 592 header = dw_pcie_readl_dbi(pci, pos); 593 if (PCI_EXT_CAP_ID(header) == cap) 594 return pos; 595 596 pos = PCI_EXT_CAP_NEXT(header); 597 if (!pos) 598 break; 599 } 600 601 return 0; 602 } 603 604 int dw_pcie_ep_init_complete(struct dw_pcie_ep *ep) 605 { 606 struct dw_pcie *pci = to_dw_pcie_from_ep(ep); 607 unsigned int offset, ptm_cap_base; 608 unsigned int nbars; 609 u8 hdr_type; 610 u32 reg; 611 int i; 612 613 hdr_type = dw_pcie_readb_dbi(pci, PCI_HEADER_TYPE) & 614 PCI_HEADER_TYPE_MASK; 615 if (hdr_type != PCI_HEADER_TYPE_NORMAL) { 616 dev_err(pci->dev, 617 "PCIe controller is not set to EP mode (hdr_type:0x%x)!\n", 618 hdr_type); 619 return -EIO; 620 } 621 622 offset = dw_pcie_ep_find_ext_capability(pci, PCI_EXT_CAP_ID_REBAR); 623 ptm_cap_base = dw_pcie_ep_find_ext_capability(pci, PCI_EXT_CAP_ID_PTM); 624 625 dw_pcie_dbi_ro_wr_en(pci); 626 627 if (offset) { 628 reg = dw_pcie_readl_dbi(pci, offset + PCI_REBAR_CTRL); 629 nbars = (reg & PCI_REBAR_CTRL_NBAR_MASK) >> 630 PCI_REBAR_CTRL_NBAR_SHIFT; 631 632 /* 633 * PCIe r6.0, sec 7.8.6.2 require us to support at least one 634 * size in the range from 1 MB to 512 GB. Advertise support 635 * for 1 MB BAR size only. 636 */ 637 for (i = 0; i < nbars; i++, offset += PCI_REBAR_CTRL) 638 dw_pcie_writel_dbi(pci, offset + PCI_REBAR_CAP, BIT(4)); 639 } 640 641 /* 642 * PTM responder capability can be disabled only after disabling 643 * PTM root capability. 644 */ 645 if (ptm_cap_base) { 646 dw_pcie_dbi_ro_wr_en(pci); 647 reg = dw_pcie_readl_dbi(pci, ptm_cap_base + PCI_PTM_CAP); 648 reg &= ~PCI_PTM_CAP_ROOT; 649 dw_pcie_writel_dbi(pci, ptm_cap_base + PCI_PTM_CAP, reg); 650 651 reg = dw_pcie_readl_dbi(pci, ptm_cap_base + PCI_PTM_CAP); 652 reg &= ~(PCI_PTM_CAP_RES | PCI_PTM_GRANULARITY_MASK); 653 dw_pcie_writel_dbi(pci, ptm_cap_base + PCI_PTM_CAP, reg); 654 dw_pcie_dbi_ro_wr_dis(pci); 655 } 656 657 dw_pcie_setup(pci); 658 dw_pcie_dbi_ro_wr_dis(pci); 659 660 return 0; 661 } 662 EXPORT_SYMBOL_GPL(dw_pcie_ep_init_complete); 663 664 int dw_pcie_ep_init(struct dw_pcie_ep *ep) 665 { 666 int ret; 667 void *addr; 668 u8 func_no; 669 struct resource *res; 670 struct pci_epc *epc; 671 struct dw_pcie *pci = to_dw_pcie_from_ep(ep); 672 struct device *dev = pci->dev; 673 struct platform_device *pdev = to_platform_device(dev); 674 struct device_node *np = dev->of_node; 675 const struct pci_epc_features *epc_features; 676 struct dw_pcie_ep_func *ep_func; 677 678 INIT_LIST_HEAD(&ep->func_list); 679 680 ret = dw_pcie_get_resources(pci); 681 if (ret) 682 return ret; 683 684 res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "addr_space"); 685 if (!res) 686 return -EINVAL; 687 688 ep->phys_base = res->start; 689 ep->addr_size = resource_size(res); 690 691 if (ep->ops->pre_init) 692 ep->ops->pre_init(ep); 693 694 dw_pcie_version_detect(pci); 695 696 dw_pcie_iatu_detect(pci); 697 698 ep->ib_window_map = devm_bitmap_zalloc(dev, pci->num_ib_windows, 699 GFP_KERNEL); 700 if (!ep->ib_window_map) 701 return -ENOMEM; 702 703 ep->ob_window_map = devm_bitmap_zalloc(dev, pci->num_ob_windows, 704 GFP_KERNEL); 705 if (!ep->ob_window_map) 706 return -ENOMEM; 707 708 addr = devm_kcalloc(dev, pci->num_ob_windows, sizeof(phys_addr_t), 709 GFP_KERNEL); 710 if (!addr) 711 return -ENOMEM; 712 ep->outbound_addr = addr; 713 714 epc = devm_pci_epc_create(dev, &epc_ops); 715 if (IS_ERR(epc)) { 716 dev_err(dev, "Failed to create epc device\n"); 717 return PTR_ERR(epc); 718 } 719 720 ep->epc = epc; 721 epc_set_drvdata(epc, ep); 722 723 ret = of_property_read_u8(np, "max-functions", &epc->max_functions); 724 if (ret < 0) 725 epc->max_functions = 1; 726 727 for (func_no = 0; func_no < epc->max_functions; func_no++) { 728 ep_func = devm_kzalloc(dev, sizeof(*ep_func), GFP_KERNEL); 729 if (!ep_func) 730 return -ENOMEM; 731 732 ep_func->func_no = func_no; 733 ep_func->msi_cap = dw_pcie_ep_find_capability(ep, func_no, 734 PCI_CAP_ID_MSI); 735 ep_func->msix_cap = dw_pcie_ep_find_capability(ep, func_no, 736 PCI_CAP_ID_MSIX); 737 738 list_add_tail(&ep_func->list, &ep->func_list); 739 } 740 741 if (ep->ops->init) 742 ep->ops->init(ep); 743 744 ret = pci_epc_mem_init(epc, ep->phys_base, ep->addr_size, 745 ep->page_size); 746 if (ret < 0) { 747 dev_err(dev, "Failed to initialize address space\n"); 748 goto err_ep_deinit; 749 } 750 751 ep->msi_mem = pci_epc_mem_alloc_addr(epc, &ep->msi_mem_phys, 752 epc->mem->window.page_size); 753 if (!ep->msi_mem) { 754 ret = -ENOMEM; 755 dev_err(dev, "Failed to reserve memory for MSI/MSI-X\n"); 756 goto err_exit_epc_mem; 757 } 758 759 ret = dw_pcie_edma_detect(pci); 760 if (ret) 761 goto err_free_epc_mem; 762 763 if (ep->ops->get_features) { 764 epc_features = ep->ops->get_features(ep); 765 if (epc_features->core_init_notifier) 766 return 0; 767 } 768 769 ret = dw_pcie_ep_init_complete(ep); 770 if (ret) 771 goto err_remove_edma; 772 773 return 0; 774 775 err_remove_edma: 776 dw_pcie_edma_remove(pci); 777 778 err_free_epc_mem: 779 pci_epc_mem_free_addr(epc, ep->msi_mem_phys, ep->msi_mem, 780 epc->mem->window.page_size); 781 782 err_exit_epc_mem: 783 pci_epc_mem_exit(epc); 784 785 err_ep_deinit: 786 if (ep->ops->deinit) 787 ep->ops->deinit(ep); 788 789 return ret; 790 } 791 EXPORT_SYMBOL_GPL(dw_pcie_ep_init); 792