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