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 /** 19 * dw_pcie_ep_linkup - Notify EPF drivers about Link Up event 20 * @ep: DWC EP device 21 */ 22 void dw_pcie_ep_linkup(struct dw_pcie_ep *ep) 23 { 24 struct pci_epc *epc = ep->epc; 25 26 pci_epc_linkup(epc); 27 } 28 EXPORT_SYMBOL_GPL(dw_pcie_ep_linkup); 29 30 /** 31 * dw_pcie_ep_init_notify - Notify EPF drivers about EPC initialization complete 32 * @ep: DWC EP device 33 */ 34 void dw_pcie_ep_init_notify(struct dw_pcie_ep *ep) 35 { 36 struct pci_epc *epc = ep->epc; 37 38 pci_epc_init_notify(epc); 39 } 40 EXPORT_SYMBOL_GPL(dw_pcie_ep_init_notify); 41 42 /** 43 * dw_pcie_ep_get_func_from_ep - Get the struct dw_pcie_ep_func corresponding to 44 * the endpoint function 45 * @ep: DWC EP device 46 * @func_no: Function number of the endpoint device 47 * 48 * Return: struct dw_pcie_ep_func if success, NULL otherwise. 49 */ 50 struct dw_pcie_ep_func * 51 dw_pcie_ep_get_func_from_ep(struct dw_pcie_ep *ep, u8 func_no) 52 { 53 struct dw_pcie_ep_func *ep_func; 54 55 list_for_each_entry(ep_func, &ep->func_list, list) { 56 if (ep_func->func_no == func_no) 57 return ep_func; 58 } 59 60 return NULL; 61 } 62 63 static void __dw_pcie_ep_reset_bar(struct dw_pcie *pci, u8 func_no, 64 enum pci_barno bar, int flags) 65 { 66 struct dw_pcie_ep *ep = &pci->ep; 67 u32 reg; 68 69 reg = PCI_BASE_ADDRESS_0 + (4 * bar); 70 dw_pcie_dbi_ro_wr_en(pci); 71 dw_pcie_ep_writel_dbi2(ep, func_no, reg, 0x0); 72 dw_pcie_ep_writel_dbi(ep, func_no, reg, 0x0); 73 if (flags & PCI_BASE_ADDRESS_MEM_TYPE_64) { 74 dw_pcie_ep_writel_dbi2(ep, func_no, reg + 4, 0x0); 75 dw_pcie_ep_writel_dbi(ep, func_no, reg + 4, 0x0); 76 } 77 dw_pcie_dbi_ro_wr_dis(pci); 78 } 79 80 /** 81 * dw_pcie_ep_reset_bar - Reset endpoint BAR 82 * @pci: DWC PCI device 83 * @bar: BAR number of the endpoint 84 */ 85 void dw_pcie_ep_reset_bar(struct dw_pcie *pci, enum pci_barno bar) 86 { 87 u8 func_no, funcs; 88 89 funcs = pci->ep.epc->max_functions; 90 91 for (func_no = 0; func_no < funcs; func_no++) 92 __dw_pcie_ep_reset_bar(pci, func_no, bar, 0); 93 } 94 EXPORT_SYMBOL_GPL(dw_pcie_ep_reset_bar); 95 96 static u8 __dw_pcie_ep_find_next_cap(struct dw_pcie_ep *ep, u8 func_no, 97 u8 cap_ptr, u8 cap) 98 { 99 u8 cap_id, next_cap_ptr; 100 u16 reg; 101 102 if (!cap_ptr) 103 return 0; 104 105 reg = dw_pcie_ep_readw_dbi(ep, func_no, cap_ptr); 106 cap_id = (reg & 0x00ff); 107 108 if (cap_id > PCI_CAP_ID_MAX) 109 return 0; 110 111 if (cap_id == cap) 112 return cap_ptr; 113 114 next_cap_ptr = (reg & 0xff00) >> 8; 115 return __dw_pcie_ep_find_next_cap(ep, func_no, next_cap_ptr, cap); 116 } 117 118 static u8 dw_pcie_ep_find_capability(struct dw_pcie_ep *ep, u8 func_no, u8 cap) 119 { 120 u8 next_cap_ptr; 121 u16 reg; 122 123 reg = dw_pcie_ep_readw_dbi(ep, func_no, 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 135 dw_pcie_dbi_ro_wr_en(pci); 136 dw_pcie_ep_writew_dbi(ep, func_no, PCI_VENDOR_ID, hdr->vendorid); 137 dw_pcie_ep_writew_dbi(ep, func_no, PCI_DEVICE_ID, hdr->deviceid); 138 dw_pcie_ep_writeb_dbi(ep, func_no, PCI_REVISION_ID, hdr->revid); 139 dw_pcie_ep_writeb_dbi(ep, func_no, PCI_CLASS_PROG, hdr->progif_code); 140 dw_pcie_ep_writew_dbi(ep, func_no, PCI_CLASS_DEVICE, 141 hdr->subclass_code | hdr->baseclass_code << 8); 142 dw_pcie_ep_writeb_dbi(ep, func_no, PCI_CACHE_LINE_SIZE, 143 hdr->cache_line_size); 144 dw_pcie_ep_writew_dbi(ep, func_no, PCI_SUBSYSTEM_VENDOR_ID, 145 hdr->subsys_vendor_id); 146 dw_pcie_ep_writew_dbi(ep, func_no, PCI_SUBSYSTEM_ID, hdr->subsys_id); 147 dw_pcie_ep_writeb_dbi(ep, func_no, PCI_INTERRUPT_PIN, 148 hdr->interrupt_pin); 149 dw_pcie_dbi_ro_wr_dis(pci); 150 151 return 0; 152 } 153 154 static int dw_pcie_ep_inbound_atu(struct dw_pcie_ep *ep, u8 func_no, int type, 155 dma_addr_t cpu_addr, enum pci_barno bar) 156 { 157 int ret; 158 u32 free_win; 159 struct dw_pcie *pci = to_dw_pcie_from_ep(ep); 160 161 if (!ep->bar_to_atu[bar]) 162 free_win = find_first_zero_bit(ep->ib_window_map, pci->num_ib_windows); 163 else 164 free_win = ep->bar_to_atu[bar]; 165 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_ep_inbound_atu(pci, func_no, free_win, type, 172 cpu_addr, bar); 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 struct dw_pcie *pci = to_dw_pcie_from_ep(ep); 189 u32 free_win; 190 int ret; 191 192 free_win = find_first_zero_bit(ep->ob_window_map, pci->num_ob_windows); 193 if (free_win >= pci->num_ob_windows) { 194 dev_err(pci->dev, "No free outbound window\n"); 195 return -EINVAL; 196 } 197 198 ret = dw_pcie_prog_ep_outbound_atu(pci, func_no, free_win, PCIE_ATU_TYPE_MEM, 199 phys_addr, pci_addr, size); 200 if (ret) 201 return ret; 202 203 set_bit(free_win, ep->ob_window_map); 204 ep->outbound_addr[free_win] = phys_addr; 205 206 return 0; 207 } 208 209 static void dw_pcie_ep_clear_bar(struct pci_epc *epc, u8 func_no, u8 vfunc_no, 210 struct pci_epf_bar *epf_bar) 211 { 212 struct dw_pcie_ep *ep = epc_get_drvdata(epc); 213 struct dw_pcie *pci = to_dw_pcie_from_ep(ep); 214 enum pci_barno bar = epf_bar->barno; 215 u32 atu_index = ep->bar_to_atu[bar]; 216 217 __dw_pcie_ep_reset_bar(pci, func_no, bar, epf_bar->flags); 218 219 dw_pcie_disable_atu(pci, PCIE_ATU_REGION_DIR_IB, atu_index); 220 clear_bit(atu_index, ep->ib_window_map); 221 ep->epf_bar[bar] = NULL; 222 ep->bar_to_atu[bar] = 0; 223 } 224 225 static int dw_pcie_ep_set_bar(struct pci_epc *epc, u8 func_no, u8 vfunc_no, 226 struct pci_epf_bar *epf_bar) 227 { 228 struct dw_pcie_ep *ep = epc_get_drvdata(epc); 229 struct dw_pcie *pci = to_dw_pcie_from_ep(ep); 230 enum pci_barno bar = epf_bar->barno; 231 size_t size = epf_bar->size; 232 int flags = epf_bar->flags; 233 int ret, type; 234 u32 reg; 235 236 reg = PCI_BASE_ADDRESS_0 + (4 * bar); 237 238 if (!(flags & PCI_BASE_ADDRESS_SPACE)) 239 type = PCIE_ATU_TYPE_MEM; 240 else 241 type = PCIE_ATU_TYPE_IO; 242 243 ret = dw_pcie_ep_inbound_atu(ep, func_no, type, epf_bar->phys_addr, bar); 244 if (ret) 245 return ret; 246 247 if (ep->epf_bar[bar]) 248 return 0; 249 250 dw_pcie_dbi_ro_wr_en(pci); 251 252 dw_pcie_ep_writel_dbi2(ep, func_no, reg, lower_32_bits(size - 1)); 253 dw_pcie_ep_writel_dbi(ep, func_no, reg, flags); 254 255 if (flags & PCI_BASE_ADDRESS_MEM_TYPE_64) { 256 dw_pcie_ep_writel_dbi2(ep, func_no, reg + 4, upper_32_bits(size - 1)); 257 dw_pcie_ep_writel_dbi(ep, func_no, reg + 4, 0); 258 } 259 260 ep->epf_bar[bar] = epf_bar; 261 dw_pcie_dbi_ro_wr_dis(pci); 262 263 return 0; 264 } 265 266 static int dw_pcie_find_index(struct dw_pcie_ep *ep, phys_addr_t addr, 267 u32 *atu_index) 268 { 269 u32 index; 270 struct dw_pcie *pci = to_dw_pcie_from_ep(ep); 271 272 for (index = 0; index < pci->num_ob_windows; index++) { 273 if (ep->outbound_addr[index] != addr) 274 continue; 275 *atu_index = index; 276 return 0; 277 } 278 279 return -EINVAL; 280 } 281 282 static void dw_pcie_ep_unmap_addr(struct pci_epc *epc, u8 func_no, u8 vfunc_no, 283 phys_addr_t addr) 284 { 285 int ret; 286 u32 atu_index; 287 struct dw_pcie_ep *ep = epc_get_drvdata(epc); 288 struct dw_pcie *pci = to_dw_pcie_from_ep(ep); 289 290 ret = dw_pcie_find_index(ep, addr, &atu_index); 291 if (ret < 0) 292 return; 293 294 dw_pcie_disable_atu(pci, PCIE_ATU_REGION_DIR_OB, atu_index); 295 clear_bit(atu_index, ep->ob_window_map); 296 } 297 298 static int dw_pcie_ep_map_addr(struct pci_epc *epc, u8 func_no, u8 vfunc_no, 299 phys_addr_t addr, u64 pci_addr, size_t size) 300 { 301 int ret; 302 struct dw_pcie_ep *ep = epc_get_drvdata(epc); 303 struct dw_pcie *pci = to_dw_pcie_from_ep(ep); 304 305 ret = dw_pcie_ep_outbound_atu(ep, func_no, addr, pci_addr, size); 306 if (ret) { 307 dev_err(pci->dev, "Failed to enable address\n"); 308 return ret; 309 } 310 311 return 0; 312 } 313 314 static int dw_pcie_ep_get_msi(struct pci_epc *epc, u8 func_no, u8 vfunc_no) 315 { 316 struct dw_pcie_ep *ep = epc_get_drvdata(epc); 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 if (!(val & PCI_MSI_FLAGS_ENABLE)) 327 return -EINVAL; 328 329 val = FIELD_GET(PCI_MSI_FLAGS_QSIZE, val); 330 331 return val; 332 } 333 334 static int dw_pcie_ep_set_msi(struct pci_epc *epc, u8 func_no, u8 vfunc_no, 335 u8 interrupts) 336 { 337 struct dw_pcie_ep *ep = epc_get_drvdata(epc); 338 struct dw_pcie *pci = to_dw_pcie_from_ep(ep); 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->msi_cap) 344 return -EINVAL; 345 346 reg = ep_func->msi_cap + PCI_MSI_FLAGS; 347 val = dw_pcie_ep_readw_dbi(ep, func_no, reg); 348 val &= ~PCI_MSI_FLAGS_QMASK; 349 val |= FIELD_PREP(PCI_MSI_FLAGS_QMASK, interrupts); 350 dw_pcie_dbi_ro_wr_en(pci); 351 dw_pcie_ep_writew_dbi(ep, func_no, reg, val); 352 dw_pcie_dbi_ro_wr_dis(pci); 353 354 return 0; 355 } 356 357 static int dw_pcie_ep_get_msix(struct pci_epc *epc, u8 func_no, u8 vfunc_no) 358 { 359 struct dw_pcie_ep *ep = epc_get_drvdata(epc); 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 reg = ep_func->msix_cap + PCI_MSIX_FLAGS; 368 val = dw_pcie_ep_readw_dbi(ep, func_no, reg); 369 if (!(val & PCI_MSIX_FLAGS_ENABLE)) 370 return -EINVAL; 371 372 val &= PCI_MSIX_FLAGS_QSIZE; 373 374 return val; 375 } 376 377 static int dw_pcie_ep_set_msix(struct pci_epc *epc, u8 func_no, u8 vfunc_no, 378 u16 interrupts, enum pci_barno bir, u32 offset) 379 { 380 struct dw_pcie_ep *ep = epc_get_drvdata(epc); 381 struct dw_pcie *pci = to_dw_pcie_from_ep(ep); 382 struct dw_pcie_ep_func *ep_func; 383 u32 val, reg; 384 385 ep_func = dw_pcie_ep_get_func_from_ep(ep, func_no); 386 if (!ep_func || !ep_func->msix_cap) 387 return -EINVAL; 388 389 dw_pcie_dbi_ro_wr_en(pci); 390 391 reg = ep_func->msix_cap + PCI_MSIX_FLAGS; 392 val = dw_pcie_ep_readw_dbi(ep, func_no, reg); 393 val &= ~PCI_MSIX_FLAGS_QSIZE; 394 val |= interrupts; 395 dw_pcie_writew_dbi(pci, reg, val); 396 397 reg = ep_func->msix_cap + PCI_MSIX_TABLE; 398 val = offset | bir; 399 dw_pcie_ep_writel_dbi(ep, func_no, reg, val); 400 401 reg = ep_func->msix_cap + PCI_MSIX_PBA; 402 val = (offset + (interrupts * PCI_MSIX_ENTRY_SIZE)) | bir; 403 dw_pcie_ep_writel_dbi(ep, func_no, reg, val); 404 405 dw_pcie_dbi_ro_wr_dis(pci); 406 407 return 0; 408 } 409 410 static int dw_pcie_ep_raise_irq(struct pci_epc *epc, u8 func_no, u8 vfunc_no, 411 unsigned int type, u16 interrupt_num) 412 { 413 struct dw_pcie_ep *ep = epc_get_drvdata(epc); 414 415 if (!ep->ops->raise_irq) 416 return -EINVAL; 417 418 return ep->ops->raise_irq(ep, func_no, type, interrupt_num); 419 } 420 421 static void dw_pcie_ep_stop(struct pci_epc *epc) 422 { 423 struct dw_pcie_ep *ep = epc_get_drvdata(epc); 424 struct dw_pcie *pci = to_dw_pcie_from_ep(ep); 425 426 dw_pcie_stop_link(pci); 427 } 428 429 static int dw_pcie_ep_start(struct pci_epc *epc) 430 { 431 struct dw_pcie_ep *ep = epc_get_drvdata(epc); 432 struct dw_pcie *pci = to_dw_pcie_from_ep(ep); 433 434 return dw_pcie_start_link(pci); 435 } 436 437 static const struct pci_epc_features* 438 dw_pcie_ep_get_features(struct pci_epc *epc, u8 func_no, u8 vfunc_no) 439 { 440 struct dw_pcie_ep *ep = epc_get_drvdata(epc); 441 442 if (!ep->ops->get_features) 443 return NULL; 444 445 return ep->ops->get_features(ep); 446 } 447 448 static const struct pci_epc_ops epc_ops = { 449 .write_header = dw_pcie_ep_write_header, 450 .set_bar = dw_pcie_ep_set_bar, 451 .clear_bar = dw_pcie_ep_clear_bar, 452 .map_addr = dw_pcie_ep_map_addr, 453 .unmap_addr = dw_pcie_ep_unmap_addr, 454 .set_msi = dw_pcie_ep_set_msi, 455 .get_msi = dw_pcie_ep_get_msi, 456 .set_msix = dw_pcie_ep_set_msix, 457 .get_msix = dw_pcie_ep_get_msix, 458 .raise_irq = dw_pcie_ep_raise_irq, 459 .start = dw_pcie_ep_start, 460 .stop = dw_pcie_ep_stop, 461 .get_features = dw_pcie_ep_get_features, 462 }; 463 464 /** 465 * dw_pcie_ep_raise_intx_irq - Raise INTx IRQ to the host 466 * @ep: DWC EP device 467 * @func_no: Function number of the endpoint 468 * 469 * Return: 0 if success, errono otherwise. 470 */ 471 int dw_pcie_ep_raise_intx_irq(struct dw_pcie_ep *ep, u8 func_no) 472 { 473 struct dw_pcie *pci = to_dw_pcie_from_ep(ep); 474 struct device *dev = pci->dev; 475 476 dev_err(dev, "EP cannot raise INTX IRQs\n"); 477 478 return -EINVAL; 479 } 480 EXPORT_SYMBOL_GPL(dw_pcie_ep_raise_intx_irq); 481 482 /** 483 * dw_pcie_ep_raise_msi_irq - Raise MSI IRQ to the host 484 * @ep: DWC EP device 485 * @func_no: Function number of the endpoint 486 * @interrupt_num: Interrupt number to be raised 487 * 488 * Return: 0 if success, errono otherwise. 489 */ 490 int dw_pcie_ep_raise_msi_irq(struct dw_pcie_ep *ep, u8 func_no, 491 u8 interrupt_num) 492 { 493 u32 msg_addr_lower, msg_addr_upper, reg; 494 struct dw_pcie_ep_func *ep_func; 495 struct pci_epc *epc = ep->epc; 496 unsigned int aligned_offset; 497 u16 msg_ctrl, msg_data; 498 bool has_upper; 499 u64 msg_addr; 500 int ret; 501 502 ep_func = dw_pcie_ep_get_func_from_ep(ep, func_no); 503 if (!ep_func || !ep_func->msi_cap) 504 return -EINVAL; 505 506 /* Raise MSI per the PCI Local Bus Specification Revision 3.0, 6.8.1. */ 507 reg = ep_func->msi_cap + PCI_MSI_FLAGS; 508 msg_ctrl = dw_pcie_ep_readw_dbi(ep, func_no, reg); 509 has_upper = !!(msg_ctrl & PCI_MSI_FLAGS_64BIT); 510 reg = ep_func->msi_cap + PCI_MSI_ADDRESS_LO; 511 msg_addr_lower = dw_pcie_ep_readl_dbi(ep, func_no, reg); 512 if (has_upper) { 513 reg = ep_func->msi_cap + PCI_MSI_ADDRESS_HI; 514 msg_addr_upper = dw_pcie_ep_readl_dbi(ep, func_no, reg); 515 reg = ep_func->msi_cap + PCI_MSI_DATA_64; 516 msg_data = dw_pcie_ep_readw_dbi(ep, func_no, reg); 517 } else { 518 msg_addr_upper = 0; 519 reg = ep_func->msi_cap + PCI_MSI_DATA_32; 520 msg_data = dw_pcie_ep_readw_dbi(ep, func_no, reg); 521 } 522 msg_addr = ((u64)msg_addr_upper) << 32 | msg_addr_lower; 523 524 aligned_offset = msg_addr & (epc->mem->window.page_size - 1); 525 msg_addr = ALIGN_DOWN(msg_addr, epc->mem->window.page_size); 526 ret = dw_pcie_ep_map_addr(epc, func_no, 0, ep->msi_mem_phys, msg_addr, 527 epc->mem->window.page_size); 528 if (ret) 529 return ret; 530 531 writel(msg_data | (interrupt_num - 1), ep->msi_mem + aligned_offset); 532 533 dw_pcie_ep_unmap_addr(epc, func_no, 0, ep->msi_mem_phys); 534 535 return 0; 536 } 537 EXPORT_SYMBOL_GPL(dw_pcie_ep_raise_msi_irq); 538 539 /** 540 * dw_pcie_ep_raise_msix_irq_doorbell - Raise MSI-X to the host using Doorbell 541 * method 542 * @ep: DWC EP device 543 * @func_no: Function number of the endpoint device 544 * @interrupt_num: Interrupt number to be raised 545 * 546 * Return: 0 if success, errno otherwise. 547 */ 548 int dw_pcie_ep_raise_msix_irq_doorbell(struct dw_pcie_ep *ep, u8 func_no, 549 u16 interrupt_num) 550 { 551 struct dw_pcie *pci = to_dw_pcie_from_ep(ep); 552 struct dw_pcie_ep_func *ep_func; 553 u32 msg_data; 554 555 ep_func = dw_pcie_ep_get_func_from_ep(ep, func_no); 556 if (!ep_func || !ep_func->msix_cap) 557 return -EINVAL; 558 559 msg_data = (func_no << PCIE_MSIX_DOORBELL_PF_SHIFT) | 560 (interrupt_num - 1); 561 562 dw_pcie_writel_dbi(pci, PCIE_MSIX_DOORBELL, msg_data); 563 564 return 0; 565 } 566 567 /** 568 * dw_pcie_ep_raise_msix_irq - Raise MSI-X to the host 569 * @ep: DWC EP device 570 * @func_no: Function number of the endpoint device 571 * @interrupt_num: Interrupt number to be raised 572 * 573 * Return: 0 if success, errno otherwise. 574 */ 575 int dw_pcie_ep_raise_msix_irq(struct dw_pcie_ep *ep, u8 func_no, 576 u16 interrupt_num) 577 { 578 struct dw_pcie *pci = to_dw_pcie_from_ep(ep); 579 struct pci_epf_msix_tbl *msix_tbl; 580 struct dw_pcie_ep_func *ep_func; 581 struct pci_epc *epc = ep->epc; 582 u32 reg, msg_data, vec_ctrl; 583 unsigned int aligned_offset; 584 u32 tbl_offset; 585 u64 msg_addr; 586 int ret; 587 u8 bir; 588 589 ep_func = dw_pcie_ep_get_func_from_ep(ep, func_no); 590 if (!ep_func || !ep_func->msix_cap) 591 return -EINVAL; 592 593 reg = ep_func->msix_cap + PCI_MSIX_TABLE; 594 tbl_offset = dw_pcie_ep_readl_dbi(ep, func_no, reg); 595 bir = FIELD_GET(PCI_MSIX_TABLE_BIR, tbl_offset); 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 /** 623 * dw_pcie_ep_cleanup - Cleanup DWC EP resources after fundamental reset 624 * @ep: DWC EP device 625 * 626 * Cleans up the DWC EP specific resources like eDMA etc... after fundamental 627 * reset like PERST#. Note that this API is only applicable for drivers 628 * supporting PERST# or any other methods of fundamental reset. 629 */ 630 void dw_pcie_ep_cleanup(struct dw_pcie_ep *ep) 631 { 632 struct dw_pcie *pci = to_dw_pcie_from_ep(ep); 633 634 dw_pcie_edma_remove(pci); 635 ep->epc->init_complete = false; 636 } 637 EXPORT_SYMBOL_GPL(dw_pcie_ep_cleanup); 638 639 /** 640 * dw_pcie_ep_deinit - Deinitialize the endpoint device 641 * @ep: DWC EP device 642 * 643 * Deinitialize the endpoint device. EPC device is not destroyed since that will 644 * be taken care by Devres. 645 */ 646 void dw_pcie_ep_deinit(struct dw_pcie_ep *ep) 647 { 648 struct pci_epc *epc = ep->epc; 649 650 dw_pcie_ep_cleanup(ep); 651 652 pci_epc_mem_free_addr(epc, ep->msi_mem_phys, ep->msi_mem, 653 epc->mem->window.page_size); 654 655 pci_epc_mem_exit(epc); 656 } 657 EXPORT_SYMBOL_GPL(dw_pcie_ep_deinit); 658 659 static unsigned int dw_pcie_ep_find_ext_capability(struct dw_pcie *pci, int cap) 660 { 661 u32 header; 662 int pos = PCI_CFG_SPACE_SIZE; 663 664 while (pos) { 665 header = dw_pcie_readl_dbi(pci, pos); 666 if (PCI_EXT_CAP_ID(header) == cap) 667 return pos; 668 669 pos = PCI_EXT_CAP_NEXT(header); 670 if (!pos) 671 break; 672 } 673 674 return 0; 675 } 676 677 /** 678 * dw_pcie_ep_init_registers - Initialize DWC EP specific registers 679 * @ep: DWC EP device 680 * 681 * Initialize the registers (CSRs) specific to DWC EP. This API should be called 682 * only when the endpoint receives an active refclk (either from host or 683 * generated locally). 684 */ 685 int dw_pcie_ep_init_registers(struct dw_pcie_ep *ep) 686 { 687 struct dw_pcie *pci = to_dw_pcie_from_ep(ep); 688 struct dw_pcie_ep_func *ep_func; 689 struct device *dev = pci->dev; 690 struct pci_epc *epc = ep->epc; 691 unsigned int offset, ptm_cap_base; 692 unsigned int nbars; 693 u8 hdr_type; 694 u8 func_no; 695 int i, ret; 696 void *addr; 697 u32 reg; 698 699 hdr_type = dw_pcie_readb_dbi(pci, PCI_HEADER_TYPE) & 700 PCI_HEADER_TYPE_MASK; 701 if (hdr_type != PCI_HEADER_TYPE_NORMAL) { 702 dev_err(pci->dev, 703 "PCIe controller is not set to EP mode (hdr_type:0x%x)!\n", 704 hdr_type); 705 return -EIO; 706 } 707 708 dw_pcie_version_detect(pci); 709 710 dw_pcie_iatu_detect(pci); 711 712 ret = dw_pcie_edma_detect(pci); 713 if (ret) 714 return ret; 715 716 if (!ep->ib_window_map) { 717 ep->ib_window_map = devm_bitmap_zalloc(dev, pci->num_ib_windows, 718 GFP_KERNEL); 719 if (!ep->ib_window_map) 720 goto err_remove_edma; 721 } 722 723 if (!ep->ob_window_map) { 724 ep->ob_window_map = devm_bitmap_zalloc(dev, pci->num_ob_windows, 725 GFP_KERNEL); 726 if (!ep->ob_window_map) 727 goto err_remove_edma; 728 } 729 730 if (!ep->outbound_addr) { 731 addr = devm_kcalloc(dev, pci->num_ob_windows, sizeof(phys_addr_t), 732 GFP_KERNEL); 733 if (!addr) 734 goto err_remove_edma; 735 ep->outbound_addr = addr; 736 } 737 738 for (func_no = 0; func_no < epc->max_functions; func_no++) { 739 740 ep_func = dw_pcie_ep_get_func_from_ep(ep, func_no); 741 if (ep_func) 742 continue; 743 744 ep_func = devm_kzalloc(dev, sizeof(*ep_func), GFP_KERNEL); 745 if (!ep_func) 746 goto err_remove_edma; 747 748 ep_func->func_no = func_no; 749 ep_func->msi_cap = dw_pcie_ep_find_capability(ep, func_no, 750 PCI_CAP_ID_MSI); 751 ep_func->msix_cap = dw_pcie_ep_find_capability(ep, func_no, 752 PCI_CAP_ID_MSIX); 753 754 list_add_tail(&ep_func->list, &ep->func_list); 755 } 756 757 if (ep->ops->init) 758 ep->ops->init(ep); 759 760 offset = dw_pcie_ep_find_ext_capability(pci, PCI_EXT_CAP_ID_REBAR); 761 ptm_cap_base = dw_pcie_ep_find_ext_capability(pci, PCI_EXT_CAP_ID_PTM); 762 763 dw_pcie_dbi_ro_wr_en(pci); 764 765 if (offset) { 766 reg = dw_pcie_readl_dbi(pci, offset + PCI_REBAR_CTRL); 767 nbars = (reg & PCI_REBAR_CTRL_NBAR_MASK) >> 768 PCI_REBAR_CTRL_NBAR_SHIFT; 769 770 /* 771 * PCIe r6.0, sec 7.8.6.2 require us to support at least one 772 * size in the range from 1 MB to 512 GB. Advertise support 773 * for 1 MB BAR size only. 774 */ 775 for (i = 0; i < nbars; i++, offset += PCI_REBAR_CTRL) 776 dw_pcie_writel_dbi(pci, offset + PCI_REBAR_CAP, BIT(4)); 777 } 778 779 /* 780 * PTM responder capability can be disabled only after disabling 781 * PTM root capability. 782 */ 783 if (ptm_cap_base) { 784 dw_pcie_dbi_ro_wr_en(pci); 785 reg = dw_pcie_readl_dbi(pci, ptm_cap_base + PCI_PTM_CAP); 786 reg &= ~PCI_PTM_CAP_ROOT; 787 dw_pcie_writel_dbi(pci, ptm_cap_base + PCI_PTM_CAP, reg); 788 789 reg = dw_pcie_readl_dbi(pci, ptm_cap_base + PCI_PTM_CAP); 790 reg &= ~(PCI_PTM_CAP_RES | PCI_PTM_GRANULARITY_MASK); 791 dw_pcie_writel_dbi(pci, ptm_cap_base + PCI_PTM_CAP, reg); 792 dw_pcie_dbi_ro_wr_dis(pci); 793 } 794 795 dw_pcie_setup(pci); 796 dw_pcie_dbi_ro_wr_dis(pci); 797 798 return 0; 799 800 err_remove_edma: 801 dw_pcie_edma_remove(pci); 802 803 return ret; 804 } 805 EXPORT_SYMBOL_GPL(dw_pcie_ep_init_registers); 806 807 /** 808 * dw_pcie_ep_init - Initialize the endpoint device 809 * @ep: DWC EP device 810 * 811 * Initialize the endpoint device. Allocate resources and create the EPC 812 * device with the endpoint framework. 813 * 814 * Return: 0 if success, errno otherwise. 815 */ 816 int dw_pcie_ep_init(struct dw_pcie_ep *ep) 817 { 818 int ret; 819 struct resource *res; 820 struct pci_epc *epc; 821 struct dw_pcie *pci = to_dw_pcie_from_ep(ep); 822 struct device *dev = pci->dev; 823 struct platform_device *pdev = to_platform_device(dev); 824 struct device_node *np = dev->of_node; 825 826 INIT_LIST_HEAD(&ep->func_list); 827 828 ret = dw_pcie_get_resources(pci); 829 if (ret) 830 return ret; 831 832 res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "addr_space"); 833 if (!res) 834 return -EINVAL; 835 836 ep->phys_base = res->start; 837 ep->addr_size = resource_size(res); 838 839 if (ep->ops->pre_init) 840 ep->ops->pre_init(ep); 841 842 epc = devm_pci_epc_create(dev, &epc_ops); 843 if (IS_ERR(epc)) { 844 dev_err(dev, "Failed to create epc device\n"); 845 return PTR_ERR(epc); 846 } 847 848 ep->epc = epc; 849 epc_set_drvdata(epc, ep); 850 851 ret = of_property_read_u8(np, "max-functions", &epc->max_functions); 852 if (ret < 0) 853 epc->max_functions = 1; 854 855 ret = pci_epc_mem_init(epc, ep->phys_base, ep->addr_size, 856 ep->page_size); 857 if (ret < 0) { 858 dev_err(dev, "Failed to initialize address space\n"); 859 return ret; 860 } 861 862 ep->msi_mem = pci_epc_mem_alloc_addr(epc, &ep->msi_mem_phys, 863 epc->mem->window.page_size); 864 if (!ep->msi_mem) { 865 ret = -ENOMEM; 866 dev_err(dev, "Failed to reserve memory for MSI/MSI-X\n"); 867 goto err_exit_epc_mem; 868 } 869 870 return 0; 871 872 err_exit_epc_mem: 873 pci_epc_mem_exit(epc); 874 875 return ret; 876 } 877 EXPORT_SYMBOL_GPL(dw_pcie_ep_init); 878