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