drivers/pci/controller/dwc/pcie-designware-ep.c

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