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 <[email protected]>
   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
  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
  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 *
  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
  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
  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
  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
  86 static u8 __dw_pcie_ep_find_next_cap(struct dw_pcie_ep *ep, u8 func_no,
  87                 u8 cap_ptr, u8 cap)
  88 {
  89         struct dw_pcie *pci = to_dw_pcie_from_ep(ep);
  90         unsigned int func_offset = 0;
  91         u8 cap_id, next_cap_ptr;
  92         u16 reg;
  93
  94         if (!cap_ptr)
  95                 return 0;
  96
  97         func_offset = dw_pcie_ep_func_select(ep, func_no);
  98
  99         reg = dw_pcie_readw_dbi(pci, func_offset + cap_ptr);
 100         cap_id = (reg & 0x00ff);
 101
 102         if (cap_id > PCI_CAP_ID_MAX)
 103                 return 0;
 104
 105         if (cap_id == cap)
 106                 return cap_ptr;
 107
 108         next_cap_ptr = (reg & 0xff00) >> 8;
 109         return __dw_pcie_ep_find_next_cap(ep, func_no, next_cap_ptr, cap);
 110 }
 111
 112 static u8 dw_pcie_ep_find_capability(struct dw_pcie_ep *ep, u8 func_no, u8 cap)
 113 {
 114         struct dw_pcie *pci = to_dw_pcie_from_ep(ep);
 115         unsigned int func_offset = 0;
 116         u8 next_cap_ptr;
 117         u16 reg;
 118
 119         func_offset = dw_pcie_ep_func_select(ep, func_no);
 120
 121         reg = dw_pcie_readw_dbi(pci, func_offset + PCI_CAPABILITY_LIST);
 122         next_cap_ptr = (reg & 0x00ff);
 123
 124         return __dw_pcie_ep_find_next_cap(ep, func_no, next_cap_ptr, cap);
 125 }
 126
 127 static int dw_pcie_ep_write_header(struct pci_epc *epc, u8 func_no, 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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*
 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
 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
 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
 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
 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
 613 void dw_pcie_ep_exit(struct dw_pcie_ep *ep)
 614 {
 615         struct pci_epc *epc = ep->epc;
 616
 617         pci_epc_mem_free_addr(epc, ep->msi_mem_phys, ep->msi_mem,
 618                               epc->mem->window.page_size);
 619
 620         pci_epc_mem_exit(epc);
 621 }
 622
 623 static unsigned int dw_pcie_ep_find_ext_capability(struct dw_pcie *pci, int cap)
 624 {
 625         u32 header;
 626         int pos = PCI_CFG_SPACE_SIZE;
 627
 628         while (pos) {
 629                 header = dw_pcie_readl_dbi(pci, pos);
 630                 if (PCI_EXT_CAP_ID(header) == cap)
 631                         return pos;
 632
 633                 pos = PCI_EXT_CAP_NEXT(header);
 634                 if (!pos)
 635                         break;
 636         }
 637
 638         return 0;
 639 }
 640
 641 int dw_pcie_ep_init_complete(struct dw_pcie_ep *ep)
 642 {
 643         struct dw_pcie *pci = to_dw_pcie_from_ep(ep);
 644         unsigned int offset, ptm_cap_base;
 645         unsigned int nbars;
 646         u8 hdr_type;
 647         u32 reg;
 648         int i;
 649
 650         hdr_type = dw_pcie_readb_dbi(pci, PCI_HEADER_TYPE) &
 651                    PCI_HEADER_TYPE_MASK;
 652         if (hdr_type != PCI_HEADER_TYPE_NORMAL) {
 653                 dev_err(pci->dev,
 654                         "PCIe controller is not set to EP mode (hdr_type:0x%x)!\n",
 655                         hdr_type);
 656                 return -EIO;
 657         }
 658
 659         offset = dw_pcie_ep_find_ext_capability(pci, PCI_EXT_CAP_ID_REBAR);
 660         ptm_cap_base = dw_pcie_ep_find_ext_capability(pci, PCI_EXT_CAP_ID_PTM);
 661
 662         dw_pcie_dbi_ro_wr_en(pci);
 663
 664         if (offset) {
 665                 reg = dw_pcie_readl_dbi(pci, offset + PCI_REBAR_CTRL);
 666                 nbars = (reg & PCI_REBAR_CTRL_NBAR_MASK) >>
 667                         PCI_REBAR_CTRL_NBAR_SHIFT;
 668
 669                 for (i = 0; i < nbars; i++, offset += PCI_REBAR_CTRL)
 670                         dw_pcie_writel_dbi(pci, offset + PCI_REBAR_CAP, 0x0);
 671         }
 672
 673         /*
 674          * PTM responder capability can be disabled only after disabling
 675          * PTM root capability.
 676          */
 677         if (ptm_cap_base) {
 678                 dw_pcie_dbi_ro_wr_en(pci);
 679                 reg = dw_pcie_readl_dbi(pci, ptm_cap_base + PCI_PTM_CAP);
 680                 reg &= ~PCI_PTM_CAP_ROOT;
 681                 dw_pcie_writel_dbi(pci, ptm_cap_base + PCI_PTM_CAP, reg);
 682
 683                 reg = dw_pcie_readl_dbi(pci, ptm_cap_base + PCI_PTM_CAP);
 684                 reg &= ~(PCI_PTM_CAP_RES | PCI_PTM_GRANULARITY_MASK);
 685                 dw_pcie_writel_dbi(pci, ptm_cap_base + PCI_PTM_CAP, reg);
 686                 dw_pcie_dbi_ro_wr_dis(pci);
 687         }
 688
 689         dw_pcie_setup(pci);
 690         dw_pcie_dbi_ro_wr_dis(pci);
 691
 692         return 0;
 693 }
 694 EXPORT_SYMBOL_GPL(dw_pcie_ep_init_complete);
 695
 696 int dw_pcie_ep_init(struct dw_pcie_ep *ep)
 697 {
 698         int ret;
 699         void *addr;
 700         u8 func_no;
 701         struct resource *res;
 702         struct pci_epc *epc;
 703         struct dw_pcie *pci = to_dw_pcie_from_ep(ep);
 704         struct device *dev = pci->dev;
 705         struct platform_device *pdev = to_platform_device(dev);
 706         struct device_node *np = dev->of_node;
 707         const struct pci_epc_features *epc_features;
 708         struct dw_pcie_ep_func *ep_func;
 709
 710         INIT_LIST_HEAD(&ep->func_list);
 711
 712         ret = dw_pcie_get_resources(pci);
 713         if (ret)
 714                 return ret;
 715
 716         res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "addr_space");
 717         if (!res)
 718                 return -EINVAL;
 719
 720         ep->phys_base = res->start;
 721         ep->addr_size = resource_size(res);
 722
 723         dw_pcie_version_detect(pci);
 724
 725         dw_pcie_iatu_detect(pci);
 726
 727         ep->ib_window_map = devm_bitmap_zalloc(dev, pci->num_ib_windows,
 728                                                GFP_KERNEL);
 729         if (!ep->ib_window_map)
 730                 return -ENOMEM;
 731
 732         ep->ob_window_map = devm_bitmap_zalloc(dev, pci->num_ob_windows,
 733                                                GFP_KERNEL);
 734         if (!ep->ob_window_map)
 735                 return -ENOMEM;
 736
 737         addr = devm_kcalloc(dev, pci->num_ob_windows, sizeof(phys_addr_t),
 738                             GFP_KERNEL);
 739         if (!addr)
 740                 return -ENOMEM;
 741         ep->outbound_addr = addr;
 742
 743         epc = devm_pci_epc_create(dev, &epc_ops);
 744         if (IS_ERR(epc)) {
 745                 dev_err(dev, "Failed to create epc device\n");
 746                 return PTR_ERR(epc);
 747         }
 748
 749         ep->epc = epc;
 750         epc_set_drvdata(epc, ep);
 751
 752         ret = of_property_read_u8(np, "max-functions", &epc->max_functions);
 753         if (ret < 0)
 754                 epc->max_functions = 1;
 755
 756         for (func_no = 0; func_no < epc->max_functions; func_no++) {
 757                 ep_func = devm_kzalloc(dev, sizeof(*ep_func), GFP_KERNEL);
 758                 if (!ep_func)
 759                         return -ENOMEM;
 760
 761                 ep_func->func_no = func_no;
 762                 ep_func->msi_cap = dw_pcie_ep_find_capability(ep, func_no,
 763                                                               PCI_CAP_ID_MSI);
 764                 ep_func->msix_cap = dw_pcie_ep_find_capability(ep, func_no,
 765                                                                PCI_CAP_ID_MSIX);
 766
 767                 list_add_tail(&ep_func->list, &ep->func_list);
 768         }
 769
 770         if (ep->ops->ep_init)
 771                 ep->ops->ep_init(ep);
 772
 773         ret = pci_epc_mem_init(epc, ep->phys_base, ep->addr_size,
 774                                ep->page_size);
 775         if (ret < 0) {
 776                 dev_err(dev, "Failed to initialize address space\n");
 777                 return ret;
 778         }
 779
 780         ep->msi_mem = pci_epc_mem_alloc_addr(epc, &ep->msi_mem_phys,
 781                                              epc->mem->window.page_size);
 782         if (!ep->msi_mem) {
 783                 ret = -ENOMEM;
 784                 dev_err(dev, "Failed to reserve memory for MSI/MSI-X\n");
 785                 goto err_exit_epc_mem;
 786         }
 787
 788         if (ep->ops->get_features) {
 789                 epc_features = ep->ops->get_features(ep);
 790                 if (epc_features->core_init_notifier)
 791                         return 0;
 792         }
 793
 794         ret = dw_pcie_ep_init_complete(ep);
 795         if (ret)
 796                 goto err_free_epc_mem;
 797
 798         return 0;
 799
 800 err_free_epc_mem:
 801         pci_epc_mem_free_addr(epc, ep->msi_mem_phys, ep->msi_mem,
 802                               epc->mem->window.page_size);
 803
 804 err_exit_epc_mem:
 805         pci_epc_mem_exit(epc);
 806
 807         return ret;
 808 }
 809 EXPORT_SYMBOL_GPL(dw_pcie_ep_init);