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