drivers/pci/pcie_mediatek.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * MediaTek PCIe host controller driver.
   4  *
   5  * Copyright (c) 2017-2019 MediaTek Inc.
   6  * Author: Ryder Lee <ryder.lee@mediatek.com>
   7  *         Honghui Zhang <honghui.zhang@mediatek.com>
   8  */
   9
  10 #include <common.h>
  11 #include <clk.h>
  12 #include <dm.h>
  13 #include <generic-phy.h>
  14 #include <pci.h>
  15 #include <reset.h>
  16 #include <asm/io.h>
  17 #include <dm/devres.h>
  18 #include <linux/iopoll.h>
  19 #include <linux/list.h>
  20
  21 /* PCIe shared registers */
  22 #define PCIE_SYS_CFG            0x00
  23 #define PCIE_INT_ENABLE         0x0c
  24 #define PCIE_CFG_ADDR           0x20
  25 #define PCIE_CFG_DATA           0x24
  26
  27 /* PCIe per port registers */
  28 #define PCIE_BAR0_SETUP         0x10
  29 #define PCIE_CLASS              0x34
  30 #define PCIE_LINK_STATUS        0x50
  31
  32 #define PCIE_PORT_INT_EN(x)     BIT(20 + (x))
  33 #define PCIE_PORT_PERST(x)      BIT(1 + (x))
  34 #define PCIE_PORT_LINKUP        BIT(0)
  35 #define PCIE_BAR_MAP_MAX        GENMASK(31, 16)
  36
  37 #define PCIE_BAR_ENABLE         BIT(0)
  38 #define PCIE_REVISION_ID        BIT(0)
  39 #define PCIE_CLASS_CODE         (0x60400 << 8)
  40 #define PCIE_CONF_REG(regn)     (((regn) & GENMASK(7, 2)) | \
  41                                 ((((regn) >> 8) & GENMASK(3, 0)) << 24))
  42 #define PCIE_CONF_ADDR(regn, bdf) \
  43                                 (PCIE_CONF_REG(regn) | (bdf))
  44
  45 /* MediaTek specific configuration registers */
  46 #define PCIE_FTS_NUM            0x70c
  47 #define PCIE_FTS_NUM_MASK       GENMASK(15, 8)
  48 #define PCIE_FTS_NUM_L0(x)      ((x) & 0xff << 8)
  49
  50 #define PCIE_FC_CREDIT          0x73c
  51 #define PCIE_FC_CREDIT_MASK     (GENMASK(31, 31) | GENMASK(28, 16))
  52 #define PCIE_FC_CREDIT_VAL(x)   ((x) << 16)
  53
  54 struct mtk_pcie_port {
  55         void __iomem *base;
  56         struct list_head list;
  57         struct mtk_pcie *pcie;
  58         struct reset_ctl reset;
  59         struct clk sys_ck;
  60         struct phy phy;
  61         u32 slot;
  62 };
  63
  64 struct mtk_pcie {
  65         void __iomem *base;
  66         struct clk free_ck;
  67         struct list_head ports;
  68 };
  69
  70 static int mtk_pcie_config_address(const struct udevice *udev, pci_dev_t bdf,
  71                                    uint offset, void **paddress)
  72 {
  73         struct mtk_pcie *pcie = dev_get_priv(udev);
  74
  75         writel(PCIE_CONF_ADDR(offset, bdf), pcie->base + PCIE_CFG_ADDR);
  76         *paddress = pcie->base + PCIE_CFG_DATA + (offset & 3);
  77
  78         return 0;
  79 }
  80
  81 static int mtk_pcie_read_config(const struct udevice *bus, pci_dev_t bdf,
  82                                 uint offset, ulong *valuep,
  83                                 enum pci_size_t size)
  84 {
  85         return pci_generic_mmap_read_config(bus, mtk_pcie_config_address,
  86                                             bdf, offset, valuep, size);
  87 }
  88
  89 static int mtk_pcie_write_config(struct udevice *bus, pci_dev_t bdf,
  90                                  uint offset, ulong value,
  91                                  enum pci_size_t size)
  92 {
  93         return pci_generic_mmap_write_config(bus, mtk_pcie_config_address,
  94                                              bdf, offset, value, size);
  95 }
  96
  97 static const struct dm_pci_ops mtk_pcie_ops = {
  98         .read_config    = mtk_pcie_read_config,
  99         .write_config   = mtk_pcie_write_config,
 100 };
 101
 102 static void mtk_pcie_port_free(struct mtk_pcie_port *port)
 103 {
 104         list_del(&port->list);
 105         free(port);
 106 }
 107
 108 static int mtk_pcie_startup_port(struct mtk_pcie_port *port)
 109 {
 110         struct mtk_pcie *pcie = port->pcie;
 111         u32 slot = PCI_DEV(port->slot << 11);
 112         u32 val;
 113         int err;
 114
 115         /* assert port PERST_N */
 116         setbits_le32(pcie->base + PCIE_SYS_CFG, PCIE_PORT_PERST(port->slot));
 117         /* de-assert port PERST_N */
 118         clrbits_le32(pcie->base + PCIE_SYS_CFG, PCIE_PORT_PERST(port->slot));
 119
 120         /* 100ms timeout value should be enough for Gen1/2 training */
 121         err = readl_poll_timeout(port->base + PCIE_LINK_STATUS, val,
 122                                  !!(val & PCIE_PORT_LINKUP), 100000);
 123         if (err)
 124                 return -ETIMEDOUT;
 125
 126         /* disable interrupt */
 127         clrbits_le32(pcie->base + PCIE_INT_ENABLE,
 128                      PCIE_PORT_INT_EN(port->slot));
 129
 130         /* map to all DDR region. We need to set it before cfg operation. */
 131         writel(PCIE_BAR_MAP_MAX | PCIE_BAR_ENABLE,
 132                port->base + PCIE_BAR0_SETUP);
 133
 134         /* configure class code and revision ID */
 135         writel(PCIE_CLASS_CODE | PCIE_REVISION_ID, port->base + PCIE_CLASS);
 136
 137         /* configure FC credit */
 138         writel(PCIE_CONF_ADDR(PCIE_FC_CREDIT, slot),
 139                pcie->base + PCIE_CFG_ADDR);
 140         clrsetbits_le32(pcie->base + PCIE_CFG_DATA, PCIE_FC_CREDIT_MASK,
 141                         PCIE_FC_CREDIT_VAL(0x806c));
 142
 143         /* configure RC FTS number to 250 when it leaves L0s */
 144         writel(PCIE_CONF_ADDR(PCIE_FTS_NUM, slot), pcie->base + PCIE_CFG_ADDR);
 145         clrsetbits_le32(pcie->base + PCIE_CFG_DATA, PCIE_FTS_NUM_MASK,
 146                         PCIE_FTS_NUM_L0(0x50));
 147
 148         return 0;
 149 }
 150
 151 static void mtk_pcie_enable_port(struct mtk_pcie_port *port)
 152 {
 153         int err;
 154
 155         err = clk_enable(&port->sys_ck);
 156         if (err)
 157                 goto exit;
 158
 159         err = reset_assert(&port->reset);
 160         if (err)
 161                 goto exit;
 162
 163         err = reset_deassert(&port->reset);
 164         if (err)
 165                 goto exit;
 166
 167         err = generic_phy_init(&port->phy);
 168         if (err)
 169                 goto exit;
 170
 171         err = generic_phy_power_on(&port->phy);
 172         if (err)
 173                 goto exit;
 174
 175         if (!mtk_pcie_startup_port(port))
 176                 return;
 177
 178         pr_err("Port%d link down\n", port->slot);
 179 exit:
 180         mtk_pcie_port_free(port);
 181 }
 182
 183 static int mtk_pcie_parse_port(struct udevice *dev, u32 slot)
 184 {
 185         struct mtk_pcie *pcie = dev_get_priv(dev);
 186         struct mtk_pcie_port *port;
 187         char name[10];
 188         int err;
 189
 190         port = devm_kzalloc(dev, sizeof(*port), GFP_KERNEL);
 191         if (!port)
 192                 return -ENOMEM;
 193
 194         snprintf(name, sizeof(name), "port%d", slot);
 195         port->base = dev_remap_addr_name(dev, name);
 196         if (!port->base)
 197                 return -ENOENT;
 198
 199         snprintf(name, sizeof(name), "sys_ck%d", slot);
 200         err = clk_get_by_name(dev, name, &port->sys_ck);
 201         if (err)
 202                 return err;
 203
 204         err = reset_get_by_index(dev, slot, &port->reset);
 205         if (err)
 206                 return err;
 207
 208         err = generic_phy_get_by_index(dev, slot, &port->phy);
 209         if (err)
 210                 return err;
 211
 212         port->slot = slot;
 213         port->pcie = pcie;
 214
 215         INIT_LIST_HEAD(&port->list);
 216         list_add_tail(&port->list, &pcie->ports);
 217
 218         return 0;
 219 }
 220
 221 static int mtk_pcie_probe(struct udevice *dev)
 222 {
 223         struct mtk_pcie *pcie = dev_get_priv(dev);
 224         struct mtk_pcie_port *port, *tmp;
 225         ofnode subnode;
 226         int err;
 227
 228         INIT_LIST_HEAD(&pcie->ports);
 229
 230         pcie->base = dev_remap_addr_name(dev, "subsys");
 231         if (!pcie->base)
 232                 return -ENOENT;
 233
 234         err = clk_get_by_name(dev, "free_ck", &pcie->free_ck);
 235         if (err)
 236                 return err;
 237
 238         /* enable top level clock */
 239         err = clk_enable(&pcie->free_ck);
 240         if (err)
 241                 return err;
 242
 243         dev_for_each_subnode(subnode, dev) {
 244                 struct fdt_pci_addr addr;
 245                 u32 slot = 0;
 246
 247                 if (!ofnode_is_available(subnode))
 248                         continue;
 249
 250                 err = ofnode_read_pci_addr(subnode, 0, "reg", &addr);
 251                 if (err)
 252                         return err;
 253
 254                 slot = PCI_DEV(addr.phys_hi);
 255
 256                 err = mtk_pcie_parse_port(dev, slot);
 257                 if (err)
 258                         return err;
 259         }
 260
 261         /* enable each port, and then check link status */
 262         list_for_each_entry_safe(port, tmp, &pcie->ports, list)
 263                 mtk_pcie_enable_port(port);
 264
 265         return 0;
 266 }
 267
 268 static const struct udevice_id mtk_pcie_ids[] = {
 269         { .compatible = "mediatek,mt7623-pcie", },
 270         { }
 271 };
 272
 273 U_BOOT_DRIVER(pcie_mediatek) = {
 274         .name   = "pcie_mediatek",
 275         .id     = UCLASS_PCI,
 276         .of_match = mtk_pcie_ids,
 277         .ops    = &mtk_pcie_ops,
 278         .probe  = mtk_pcie_probe,
 279         .priv_auto_alloc_size = sizeof(struct mtk_pcie),
 280 };