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