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