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