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