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