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