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