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