drivers/pci/controller/pcie-cadence-host.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 // Copyright (c) 2017 Cadence
   3 // Cadence PCIe host controller driver.
   4 // Author: Cyrille Pitchen <cyrille.pitchen@free-electrons.com>
   5
   6 #include <linux/kernel.h>
   7 #include <linux/of_address.h>
   8 #include <linux/of_pci.h>
   9 #include <linux/platform_device.h>
  10 #include <linux/pm_runtime.h>
  11
  12 #include "pcie-cadence.h"
  13
  14 /**
  15  * struct cdns_pcie_rc - private data for this PCIe Root Complex driver
  16  * @pcie: Cadence PCIe controller
  17  * @dev: pointer to PCIe device
  18  * @cfg_res: start/end offsets in the physical system memory to map PCI
  19  *           configuration space accesses
  20  * @bus_range: first/last buses behind the PCIe host controller
  21  * @cfg_base: IO mapped window to access the PCI configuration space of a
  22  *            single function at a time
  23  * @max_regions: maximum number of regions supported by the hardware
  24  * @no_bar_nbits: Number of bits to keep for inbound (PCIe -> CPU) address
  25  *                translation (nbits sets into the "no BAR match" register)
  26  * @vendor_id: PCI vendor ID
  27  * @device_id: PCI device ID
  28  */
  29 struct cdns_pcie_rc {
  30         struct cdns_pcie        pcie;
  31         struct device           *dev;
  32         struct resource         *cfg_res;
  33         struct resource         *bus_range;
  34         void __iomem            *cfg_base;
  35         u32                     max_regions;
  36         u32                     no_bar_nbits;
  37         u16                     vendor_id;
  38         u16                     device_id;
  39 };
  40
  41 static void __iomem *cdns_pci_map_bus(struct pci_bus *bus, unsigned int devfn,
  42                                       int where)
  43 {
  44         struct pci_host_bridge *bridge = pci_find_host_bridge(bus);
  45         struct cdns_pcie_rc *rc = pci_host_bridge_priv(bridge);
  46         struct cdns_pcie *pcie = &rc->pcie;
  47         unsigned int busn = bus->number;
  48         u32 addr0, desc0;
  49
  50         if (busn == rc->bus_range->start) {
  51                 /*
  52                  * Only the root port (devfn == 0) is connected to this bus.
  53                  * All other PCI devices are behind some bridge hence on another
  54                  * bus.
  55                  */
  56                 if (devfn)
  57                         return NULL;
  58
  59                 return pcie->reg_base + (where & 0xfff);
  60         }
  61         /* Check that the link is up */
  62         if (!(cdns_pcie_readl(pcie, CDNS_PCIE_LM_BASE) & 0x1))
  63                 return NULL;
  64         /* Clear AXI link-down status */
  65         cdns_pcie_writel(pcie, CDNS_PCIE_AT_LINKDOWN, 0x0);
  66
  67         /* Update Output registers for AXI region 0. */
  68         addr0 = CDNS_PCIE_AT_OB_REGION_PCI_ADDR0_NBITS(12) |
  69                 CDNS_PCIE_AT_OB_REGION_PCI_ADDR0_DEVFN(devfn) |
  70                 CDNS_PCIE_AT_OB_REGION_PCI_ADDR0_BUS(busn);
  71         cdns_pcie_writel(pcie, CDNS_PCIE_AT_OB_REGION_PCI_ADDR0(0), addr0);
  72
  73         /* Configuration Type 0 or Type 1 access. */
  74         desc0 = CDNS_PCIE_AT_OB_REGION_DESC0_HARDCODED_RID |
  75                 CDNS_PCIE_AT_OB_REGION_DESC0_DEVFN(0);
  76         /*
  77          * The bus number was already set once for all in desc1 by
  78          * cdns_pcie_host_init_address_translation().
  79          */
  80         if (busn == rc->bus_range->start + 1)
  81                 desc0 |= CDNS_PCIE_AT_OB_REGION_DESC0_TYPE_CONF_TYPE0;
  82         else
  83                 desc0 |= CDNS_PCIE_AT_OB_REGION_DESC0_TYPE_CONF_TYPE1;
  84         cdns_pcie_writel(pcie, CDNS_PCIE_AT_OB_REGION_DESC0(0), desc0);
  85
  86         return rc->cfg_base + (where & 0xfff);
  87 }
  88
  89 static struct pci_ops cdns_pcie_host_ops = {
  90         .map_bus        = cdns_pci_map_bus,
  91         .read           = pci_generic_config_read,
  92         .write          = pci_generic_config_write,
  93 };
  94
  95 static const struct of_device_id cdns_pcie_host_of_match[] = {
  96         { .compatible = "cdns,cdns-pcie-host" },
  97
  98         { },
  99 };
 100
 101 static int cdns_pcie_host_init_root_port(struct cdns_pcie_rc *rc)
 102 {
 103         struct cdns_pcie *pcie = &rc->pcie;
 104         u32 value, ctrl;
 105         u32 id;
 106
 107         /*
 108          * Set the root complex BAR configuration register:
 109          * - disable both BAR0 and BAR1.
 110          * - enable Prefetchable Memory Base and Limit registers in type 1
 111          *   config space (64 bits).
 112          * - enable IO Base and Limit registers in type 1 config
 113          *   space (32 bits).
 114          */
 115         ctrl = CDNS_PCIE_LM_BAR_CFG_CTRL_DISABLED;
 116         value = CDNS_PCIE_LM_RC_BAR_CFG_BAR0_CTRL(ctrl) |
 117                 CDNS_PCIE_LM_RC_BAR_CFG_BAR1_CTRL(ctrl) |
 118                 CDNS_PCIE_LM_RC_BAR_CFG_PREFETCH_MEM_ENABLE |
 119                 CDNS_PCIE_LM_RC_BAR_CFG_PREFETCH_MEM_64BITS |
 120                 CDNS_PCIE_LM_RC_BAR_CFG_IO_ENABLE |
 121                 CDNS_PCIE_LM_RC_BAR_CFG_IO_32BITS;
 122         cdns_pcie_writel(pcie, CDNS_PCIE_LM_RC_BAR_CFG, value);
 123
 124         /* Set root port configuration space */
 125         if (rc->vendor_id != 0xffff) {
 126                 id = CDNS_PCIE_LM_ID_VENDOR(rc->vendor_id) |
 127                         CDNS_PCIE_LM_ID_SUBSYS(rc->vendor_id);
 128                 cdns_pcie_writel(pcie, CDNS_PCIE_LM_ID, id);
 129         }
 130
 131         if (rc->device_id != 0xffff)
 132                 cdns_pcie_rp_writew(pcie, PCI_DEVICE_ID, rc->device_id);
 133
 134         cdns_pcie_rp_writeb(pcie, PCI_CLASS_REVISION, 0);
 135         cdns_pcie_rp_writeb(pcie, PCI_CLASS_PROG, 0);
 136         cdns_pcie_rp_writew(pcie, PCI_CLASS_DEVICE, PCI_CLASS_BRIDGE_PCI);
 137
 138         return 0;
 139 }
 140
 141 static int cdns_pcie_host_init_address_translation(struct cdns_pcie_rc *rc)
 142 {
 143         struct cdns_pcie *pcie = &rc->pcie;
 144         struct resource *cfg_res = rc->cfg_res;
 145         struct resource *mem_res = pcie->mem_res;
 146         struct resource *bus_range = rc->bus_range;
 147         struct device *dev = rc->dev;
 148         struct device_node *np = dev->of_node;
 149         struct of_pci_range_parser parser;
 150         struct of_pci_range range;
 151         u32 addr0, addr1, desc1;
 152         u64 cpu_addr;
 153         int r, err;
 154
 155         /*
 156          * Reserve region 0 for PCI configure space accesses:
 157          * OB_REGION_PCI_ADDR0 and OB_REGION_DESC0 are updated dynamically by
 158          * cdns_pci_map_bus(), other region registers are set here once for all.
 159          */
 160         addr1 = 0; /* Should be programmed to zero. */
 161         desc1 = CDNS_PCIE_AT_OB_REGION_DESC1_BUS(bus_range->start);
 162         cdns_pcie_writel(pcie, CDNS_PCIE_AT_OB_REGION_PCI_ADDR1(0), addr1);
 163         cdns_pcie_writel(pcie, CDNS_PCIE_AT_OB_REGION_DESC1(0), desc1);
 164
 165         cpu_addr = cfg_res->start - mem_res->start;
 166         addr0 = CDNS_PCIE_AT_OB_REGION_CPU_ADDR0_NBITS(12) |
 167                 (lower_32_bits(cpu_addr) & GENMASK(31, 8));
 168         addr1 = upper_32_bits(cpu_addr);
 169         cdns_pcie_writel(pcie, CDNS_PCIE_AT_OB_REGION_CPU_ADDR0(0), addr0);
 170         cdns_pcie_writel(pcie, CDNS_PCIE_AT_OB_REGION_CPU_ADDR1(0), addr1);
 171
 172         err = of_pci_range_parser_init(&parser, np);
 173         if (err)
 174                 return err;
 175
 176         r = 1;
 177         for_each_of_pci_range(&parser, &range) {
 178                 bool is_io;
 179
 180                 if (r >= rc->max_regions)
 181                         break;
 182
 183                 if ((range.flags & IORESOURCE_TYPE_BITS) == IORESOURCE_MEM)
 184                         is_io = false;
 185                 else if ((range.flags & IORESOURCE_TYPE_BITS) == IORESOURCE_IO)
 186                         is_io = true;
 187                 else
 188                         continue;
 189
 190                 cdns_pcie_set_outbound_region(pcie, 0, r, is_io,
 191                                               range.cpu_addr,
 192                                               range.pci_addr,
 193                                               range.size);
 194                 r++;
 195         }
 196
 197         /*
 198          * Set Root Port no BAR match Inbound Translation registers:
 199          * needed for MSI and DMA.
 200          * Root Port BAR0 and BAR1 are disabled, hence no need to set their
 201          * inbound translation registers.
 202          */
 203         addr0 = CDNS_PCIE_AT_IB_RP_BAR_ADDR0_NBITS(rc->no_bar_nbits);
 204         addr1 = 0;
 205         cdns_pcie_writel(pcie, CDNS_PCIE_AT_IB_RP_BAR_ADDR0(RP_NO_BAR), addr0);
 206         cdns_pcie_writel(pcie, CDNS_PCIE_AT_IB_RP_BAR_ADDR1(RP_NO_BAR), addr1);
 207
 208         return 0;
 209 }
 210
 211 static int cdns_pcie_host_init(struct device *dev,
 212                                struct list_head *resources,
 213                                struct cdns_pcie_rc *rc)
 214 {
 215         struct resource *bus_range = NULL;
 216         int err;
 217
 218         /* Parse our PCI ranges and request their resources */
 219         err = pci_parse_request_of_pci_ranges(dev, resources, &bus_range);
 220         if (err)
 221                 return err;
 222
 223         rc->bus_range = bus_range;
 224         rc->pcie.bus = bus_range->start;
 225
 226         err = cdns_pcie_host_init_root_port(rc);
 227         if (err)
 228                 goto err_out;
 229
 230         err = cdns_pcie_host_init_address_translation(rc);
 231         if (err)
 232                 goto err_out;
 233
 234         return 0;
 235
 236  err_out:
 237         pci_free_resource_list(resources);
 238         return err;
 239 }
 240
 241 static int cdns_pcie_host_probe(struct platform_device *pdev)
 242 {
 243         const char *type;
 244         struct device *dev = &pdev->dev;
 245         struct device_node *np = dev->of_node;
 246         struct pci_host_bridge *bridge;
 247         struct list_head resources;
 248         struct cdns_pcie_rc *rc;
 249         struct cdns_pcie *pcie;
 250         struct resource *res;
 251         int ret;
 252         int phy_count;
 253
 254         bridge = devm_pci_alloc_host_bridge(dev, sizeof(*rc));
 255         if (!bridge)
 256                 return -ENOMEM;
 257
 258         rc = pci_host_bridge_priv(bridge);
 259         rc->dev = dev;
 260
 261         pcie = &rc->pcie;
 262         pcie->is_rc = true;
 263
 264         rc->max_regions = 32;
 265         of_property_read_u32(np, "cdns,max-outbound-regions", &rc->max_regions);
 266
 267         rc->no_bar_nbits = 32;
 268         of_property_read_u32(np, "cdns,no-bar-match-nbits", &rc->no_bar_nbits);
 269
 270         rc->vendor_id = 0xffff;
 271         of_property_read_u16(np, "vendor-id", &rc->vendor_id);
 272
 273         rc->device_id = 0xffff;
 274         of_property_read_u16(np, "device-id", &rc->device_id);
 275
 276         type = of_get_property(np, "device_type", NULL);
 277         if (!type || strcmp(type, "pci")) {
 278                 dev_err(dev, "invalid \"device_type\" %s\n", type);
 279                 return -EINVAL;
 280         }
 281
 282         res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "reg");
 283         pcie->reg_base = devm_ioremap_resource(dev, res);
 284         if (IS_ERR(pcie->reg_base)) {
 285                 dev_err(dev, "missing \"reg\"\n");
 286                 return PTR_ERR(pcie->reg_base);
 287         }
 288
 289         res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "cfg");
 290         rc->cfg_base = devm_pci_remap_cfg_resource(dev, res);
 291         if (IS_ERR(rc->cfg_base)) {
 292                 dev_err(dev, "missing \"cfg\"\n");
 293                 return PTR_ERR(rc->cfg_base);
 294         }
 295         rc->cfg_res = res;
 296
 297         res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "mem");
 298         if (!res) {
 299                 dev_err(dev, "missing \"mem\"\n");
 300                 return -EINVAL;
 301         }
 302         pcie->mem_res = res;
 303
 304         ret = cdns_pcie_init_phy(dev, pcie);
 305         if (ret) {
 306                 dev_err(dev, "failed to init phy\n");
 307                 return ret;
 308         }
 309         platform_set_drvdata(pdev, pcie);
 310
 311         pm_runtime_enable(dev);
 312         ret = pm_runtime_get_sync(dev);
 313         if (ret < 0) {
 314                 dev_err(dev, "pm_runtime_get_sync() failed\n");
 315                 goto err_get_sync;
 316         }
 317
 318         ret = cdns_pcie_host_init(dev, &resources, rc);
 319         if (ret)
 320                 goto err_init;
 321
 322         list_splice_init(&resources, &bridge->windows);
 323         bridge->dev.parent = dev;
 324         bridge->busnr = pcie->bus;
 325         bridge->ops = &cdns_pcie_host_ops;
 326         bridge->map_irq = of_irq_parse_and_map_pci;
 327         bridge->swizzle_irq = pci_common_swizzle;
 328
 329         ret = pci_host_probe(bridge);
 330         if (ret < 0)
 331                 goto err_host_probe;
 332
 333         return 0;
 334
 335  err_host_probe:
 336         pci_free_resource_list(&resources);
 337
 338  err_init:
 339         pm_runtime_put_sync(dev);
 340
 341  err_get_sync:
 342         pm_runtime_disable(dev);
 343         cdns_pcie_disable_phy(pcie);
 344         phy_count = pcie->phy_count;
 345         while (phy_count--)
 346                 device_link_del(pcie->link[phy_count]);
 347
 348         return ret;
 349 }
 350
 351 static void cdns_pcie_shutdown(struct platform_device *pdev)
 352 {
 353         struct device *dev = &pdev->dev;
 354         struct cdns_pcie *pcie = dev_get_drvdata(dev);
 355         int ret;
 356
 357         ret = pm_runtime_put_sync(dev);
 358         if (ret < 0)
 359                 dev_dbg(dev, "pm_runtime_put_sync failed\n");
 360
 361         pm_runtime_disable(dev);
 362         cdns_pcie_disable_phy(pcie);
 363 }
 364
 365 static struct platform_driver cdns_pcie_host_driver = {
 366         .driver = {
 367                 .name = "cdns-pcie-host",
 368                 .of_match_table = cdns_pcie_host_of_match,
 369                 .pm     = &cdns_pcie_pm_ops,
 370         },
 371         .probe = cdns_pcie_host_probe,
 372         .shutdown = cdns_pcie_shutdown,
 373 };
 374 builtin_platform_driver(cdns_pcie_host_driver);