drivers/pci/controller/pcie-mt7621.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * BRIEF MODULE DESCRIPTION
   4  *     PCI init for Ralink RT2880 solution
   5  *
   6  * Copyright 2007 Ralink Inc. ([email protected])
   7  *
   8  * May 2007 Bruce Chang
   9  * Initial Release
  10  *
  11  * May 2009 Bruce Chang
  12  * support RT2880/RT3883 PCIe
  13  *
  14  * May 2011 Bruce Chang
  15  * support RT6855/MT7620 PCIe
  16  */
  17
  18 #include <linux/bitops.h>
  19 #include <linux/clk.h>
  20 #include <linux/delay.h>
  21 #include <linux/gpio/consumer.h>
  22 #include <linux/module.h>
  23 #include <linux/of.h>
  24 #include <linux/of_address.h>
  25 #include <linux/of_pci.h>
  26 #include <linux/of_platform.h>
  27 #include <linux/pci.h>
  28 #include <linux/phy/phy.h>
  29 #include <linux/platform_device.h>
  30 #include <linux/reset.h>
  31 #include <linux/sys_soc.h>
  32
  33 /* MediaTek-specific configuration registers */
  34 #define PCIE_FTS_NUM                    0x70c
  35 #define PCIE_FTS_NUM_MASK               GENMASK(15, 8)
  36 #define PCIE_FTS_NUM_L0(x)              (((x) & 0xff) << 8)
  37
  38 /* Host-PCI bridge registers */
  39 #define RALINK_PCI_PCICFG_ADDR          0x0000
  40 #define RALINK_PCI_PCIMSK_ADDR          0x000c
  41 #define RALINK_PCI_CONFIG_ADDR          0x0020
  42 #define RALINK_PCI_CONFIG_DATA          0x0024
  43 #define RALINK_PCI_MEMBASE              0x0028
  44 #define RALINK_PCI_IOBASE               0x002c
  45
  46 /* PCIe RC control registers */
  47 #define RALINK_PCI_ID                   0x0030
  48 #define RALINK_PCI_CLASS                0x0034
  49 #define RALINK_PCI_SUBID                0x0038
  50 #define RALINK_PCI_STATUS               0x0050
  51
  52 /* Some definition values */
  53 #define PCIE_REVISION_ID                BIT(0)
  54 #define PCIE_CLASS_CODE                 (0x60400 << 8)
  55 #define PCIE_BAR_MAP_MAX                GENMASK(30, 16)
  56 #define PCIE_BAR_ENABLE                 BIT(0)
  57 #define PCIE_PORT_INT_EN(x)             BIT(20 + (x))
  58 #define PCIE_PORT_LINKUP                BIT(0)
  59 #define PCIE_PORT_CNT                   3
  60
  61 #define PERST_DELAY_MS                  100
  62
  63 /**
  64  * struct mt7621_pcie_port - PCIe port information
  65  * @base: I/O mapped register base
  66  * @list: port list
  67  * @pcie: pointer to PCIe host info
  68  * @clk: pointer to the port clock gate
  69  * @phy: pointer to PHY control block
  70  * @pcie_rst: pointer to port reset control
  71  * @gpio_rst: gpio reset
  72  * @slot: port slot
  73  * @enabled: indicates if port is enabled
  74  */
  75 struct mt7621_pcie_port {
  76         void __iomem *base;
  77         struct list_head list;
  78         struct mt7621_pcie *pcie;
  79         struct clk *clk;
  80         struct phy *phy;
  81         struct reset_control *pcie_rst;
  82         struct gpio_desc *gpio_rst;
  83         u32 slot;
  84         bool enabled;
  85 };
  86
  87 /**
  88  * struct mt7621_pcie - PCIe host information
  89  * @base: IO Mapped Register Base
  90  * @dev: Pointer to PCIe device
  91  * @ports: pointer to PCIe port information
  92  * @resets_inverted: depends on chip revision
  93  * reset lines are inverted.
  94  */
  95 struct mt7621_pcie {
  96         struct device *dev;
  97         void __iomem *base;
  98         struct list_head ports;
  99         bool resets_inverted;
 100 };
 101
 102 static inline u32 pcie_read(struct mt7621_pcie *pcie, u32 reg)
 103 {
 104         return readl_relaxed(pcie->base + reg);
 105 }
 106
 107 static inline void pcie_write(struct mt7621_pcie *pcie, u32 val, u32 reg)
 108 {
 109         writel_relaxed(val, pcie->base + reg);
 110 }
 111
 112 static inline u32 pcie_port_read(struct mt7621_pcie_port *port, u32 reg)
 113 {
 114         return readl_relaxed(port->base + reg);
 115 }
 116
 117 static inline void pcie_port_write(struct mt7621_pcie_port *port,
 118                                    u32 val, u32 reg)
 119 {
 120         writel_relaxed(val, port->base + reg);
 121 }
 122
 123 static inline u32 mt7621_pcie_get_cfgaddr(unsigned int bus, unsigned int slot,
 124                                          unsigned int func, unsigned int where)
 125 {
 126         return (((where & 0xf00) >> 8) << 24) | (bus << 16) | (slot << 11) |
 127                 (func << 8) | (where & 0xfc) | 0x80000000;
 128 }
 129
 130 static void __iomem *mt7621_pcie_map_bus(struct pci_bus *bus,
 131                                          unsigned int devfn, int where)
 132 {
 133         struct mt7621_pcie *pcie = bus->sysdata;
 134         u32 address = mt7621_pcie_get_cfgaddr(bus->number, PCI_SLOT(devfn),
 135                                              PCI_FUNC(devfn), where);
 136
 137         writel_relaxed(address, pcie->base + RALINK_PCI_CONFIG_ADDR);
 138
 139         return pcie->base + RALINK_PCI_CONFIG_DATA + (where & 3);
 140 }
 141
 142 static struct pci_ops mt7621_pcie_ops = {
 143         .map_bus        = mt7621_pcie_map_bus,
 144         .read           = pci_generic_config_read,
 145         .write          = pci_generic_config_write,
 146 };
 147
 148 static u32 read_config(struct mt7621_pcie *pcie, unsigned int dev, u32 reg)
 149 {
 150         u32 address = mt7621_pcie_get_cfgaddr(0, dev, 0, reg);
 151
 152         pcie_write(pcie, address, RALINK_PCI_CONFIG_ADDR);
 153         return pcie_read(pcie, RALINK_PCI_CONFIG_DATA);
 154 }
 155
 156 static void write_config(struct mt7621_pcie *pcie, unsigned int dev,
 157                          u32 reg, u32 val)
 158 {
 159         u32 address = mt7621_pcie_get_cfgaddr(0, dev, 0, reg);
 160
 161         pcie_write(pcie, address, RALINK_PCI_CONFIG_ADDR);
 162         pcie_write(pcie, val, RALINK_PCI_CONFIG_DATA);
 163 }
 164
 165 static inline void mt7621_rst_gpio_pcie_assert(struct mt7621_pcie_port *port)
 166 {
 167         if (port->gpio_rst)
 168                 gpiod_set_value(port->gpio_rst, 1);
 169 }
 170
 171 static inline void mt7621_rst_gpio_pcie_deassert(struct mt7621_pcie_port *port)
 172 {
 173         if (port->gpio_rst)
 174                 gpiod_set_value(port->gpio_rst, 0);
 175 }
 176
 177 static inline bool mt7621_pcie_port_is_linkup(struct mt7621_pcie_port *port)
 178 {
 179         return (pcie_port_read(port, RALINK_PCI_STATUS) & PCIE_PORT_LINKUP) != 0;
 180 }
 181
 182 static inline void mt7621_control_assert(struct mt7621_pcie_port *port)
 183 {
 184         struct mt7621_pcie *pcie = port->pcie;
 185
 186         if (pcie->resets_inverted)
 187                 reset_control_assert(port->pcie_rst);
 188         else
 189                 reset_control_deassert(port->pcie_rst);
 190 }
 191
 192 static inline void mt7621_control_deassert(struct mt7621_pcie_port *port)
 193 {
 194         struct mt7621_pcie *pcie = port->pcie;
 195
 196         if (pcie->resets_inverted)
 197                 reset_control_deassert(port->pcie_rst);
 198         else
 199                 reset_control_assert(port->pcie_rst);
 200 }
 201
 202 static int mt7621_pcie_parse_port(struct mt7621_pcie *pcie,
 203                                   struct device_node *node,
 204                                   int slot)
 205 {
 206         struct mt7621_pcie_port *port;
 207         struct device *dev = pcie->dev;
 208         struct platform_device *pdev = to_platform_device(dev);
 209         char name[10];
 210         int err;
 211
 212         port = devm_kzalloc(dev, sizeof(*port), GFP_KERNEL);
 213         if (!port)
 214                 return -ENOMEM;
 215
 216         port->base = devm_platform_ioremap_resource(pdev, slot + 1);
 217         if (IS_ERR(port->base))
 218                 return PTR_ERR(port->base);
 219
 220         port->clk = devm_get_clk_from_child(dev, node, NULL);
 221         if (IS_ERR(port->clk)) {
 222                 dev_err(dev, "failed to get pcie%d clock\n", slot);
 223                 return PTR_ERR(port->clk);
 224         }
 225
 226         port->pcie_rst = of_reset_control_get_exclusive(node, NULL);
 227         if (PTR_ERR(port->pcie_rst) == -EPROBE_DEFER) {
 228                 dev_err(dev, "failed to get pcie%d reset control\n", slot);
 229                 return PTR_ERR(port->pcie_rst);
 230         }
 231
 232         snprintf(name, sizeof(name), "pcie-phy%d", slot);
 233         port->phy = devm_of_phy_get(dev, node, name);
 234         if (IS_ERR(port->phy)) {
 235                 dev_err(dev, "failed to get pcie-phy%d\n", slot);
 236                 err = PTR_ERR(port->phy);
 237                 goto remove_reset;
 238         }
 239
 240         port->gpio_rst = devm_gpiod_get_index_optional(dev, "reset", slot,
 241                                                        GPIOD_OUT_LOW);
 242         if (IS_ERR(port->gpio_rst)) {
 243                 dev_err(dev, "failed to get GPIO for PCIe%d\n", slot);
 244                 err = PTR_ERR(port->gpio_rst);
 245                 goto remove_reset;
 246         }
 247
 248         port->slot = slot;
 249         port->pcie = pcie;
 250
 251         INIT_LIST_HEAD(&port->list);
 252         list_add_tail(&port->list, &pcie->ports);
 253
 254         return 0;
 255
 256 remove_reset:
 257         reset_control_put(port->pcie_rst);
 258         return err;
 259 }
 260
 261 static int mt7621_pcie_parse_dt(struct mt7621_pcie *pcie)
 262 {
 263         struct device *dev = pcie->dev;
 264         struct platform_device *pdev = to_platform_device(dev);
 265         struct device_node *node = dev->of_node, *child;
 266         int err;
 267
 268         pcie->base = devm_platform_ioremap_resource(pdev, 0);
 269         if (IS_ERR(pcie->base))
 270                 return PTR_ERR(pcie->base);
 271
 272         for_each_available_child_of_node(node, child) {
 273                 int slot;
 274
 275                 err = of_pci_get_devfn(child);
 276                 if (err < 0) {
 277                         of_node_put(child);
 278                         dev_err(dev, "failed to parse devfn: %d\n", err);
 279                         return err;
 280                 }
 281
 282                 slot = PCI_SLOT(err);
 283
 284                 err = mt7621_pcie_parse_port(pcie, child, slot);
 285                 if (err) {
 286                         of_node_put(child);
 287                         return err;
 288                 }
 289         }
 290
 291         return 0;
 292 }
 293
 294 static int mt7621_pcie_init_port(struct mt7621_pcie_port *port)
 295 {
 296         struct mt7621_pcie *pcie = port->pcie;
 297         struct device *dev = pcie->dev;
 298         u32 slot = port->slot;
 299         int err;
 300
 301         err = phy_init(port->phy);
 302         if (err) {
 303                 dev_err(dev, "failed to initialize port%d phy\n", slot);
 304                 return err;
 305         }
 306
 307         err = phy_power_on(port->phy);
 308         if (err) {
 309                 dev_err(dev, "failed to power on port%d phy\n", slot);
 310                 phy_exit(port->phy);
 311                 return err;
 312         }
 313
 314         port->enabled = true;
 315
 316         return 0;
 317 }
 318
 319 static void mt7621_pcie_reset_assert(struct mt7621_pcie *pcie)
 320 {
 321         struct mt7621_pcie_port *port;
 322
 323         list_for_each_entry(port, &pcie->ports, list) {
 324                 /* PCIe RC reset assert */
 325                 mt7621_control_assert(port);
 326
 327                 /* PCIe EP reset assert */
 328                 mt7621_rst_gpio_pcie_assert(port);
 329         }
 330
 331         msleep(PERST_DELAY_MS);
 332 }
 333
 334 static void mt7621_pcie_reset_rc_deassert(struct mt7621_pcie *pcie)
 335 {
 336         struct mt7621_pcie_port *port;
 337
 338         list_for_each_entry(port, &pcie->ports, list)
 339                 mt7621_control_deassert(port);
 340 }
 341
 342 static void mt7621_pcie_reset_ep_deassert(struct mt7621_pcie *pcie)
 343 {
 344         struct mt7621_pcie_port *port;
 345
 346         list_for_each_entry(port, &pcie->ports, list)
 347                 mt7621_rst_gpio_pcie_deassert(port);
 348
 349         msleep(PERST_DELAY_MS);
 350 }
 351
 352 static int mt7621_pcie_init_ports(struct mt7621_pcie *pcie)
 353 {
 354         struct device *dev = pcie->dev;
 355         struct mt7621_pcie_port *port, *tmp;
 356         u8 num_disabled = 0;
 357         int err;
 358
 359         mt7621_pcie_reset_assert(pcie);
 360         mt7621_pcie_reset_rc_deassert(pcie);
 361
 362         list_for_each_entry_safe(port, tmp, &pcie->ports, list) {
 363                 u32 slot = port->slot;
 364
 365                 if (slot == 1) {
 366                         port->enabled = true;
 367                         continue;
 368                 }
 369
 370                 err = mt7621_pcie_init_port(port);
 371                 if (err) {
 372                         dev_err(dev, "initializing port %d failed\n", slot);
 373                         list_del(&port->list);
 374                 }
 375         }
 376
 377         mt7621_pcie_reset_ep_deassert(pcie);
 378
 379         tmp = NULL;
 380         list_for_each_entry(port, &pcie->ports, list) {
 381                 u32 slot = port->slot;
 382
 383                 if (!mt7621_pcie_port_is_linkup(port)) {
 384                         dev_err(dev, "pcie%d no card, disable it (RST & CLK)\n",
 385                                 slot);
 386                         mt7621_control_assert(port);
 387                         port->enabled = false;
 388                         num_disabled++;
 389
 390                         if (slot == 0) {
 391                                 tmp = port;
 392                                 continue;
 393                         }
 394
 395                         if (slot == 1 && tmp && !tmp->enabled)
 396                                 phy_power_off(tmp->phy);
 397                 }
 398         }
 399
 400         return (num_disabled != PCIE_PORT_CNT) ? 0 : -ENODEV;
 401 }
 402
 403 static void mt7621_pcie_enable_port(struct mt7621_pcie_port *port)
 404 {
 405         struct mt7621_pcie *pcie = port->pcie;
 406         u32 slot = port->slot;
 407         u32 val;
 408
 409         /* enable pcie interrupt */
 410         val = pcie_read(pcie, RALINK_PCI_PCIMSK_ADDR);
 411         val |= PCIE_PORT_INT_EN(slot);
 412         pcie_write(pcie, val, RALINK_PCI_PCIMSK_ADDR);
 413
 414         /* map 2G DDR region */
 415         pcie_port_write(port, PCIE_BAR_MAP_MAX | PCIE_BAR_ENABLE,
 416                         PCI_BASE_ADDRESS_0);
 417
 418         /* configure class code and revision ID */
 419         pcie_port_write(port, PCIE_CLASS_CODE | PCIE_REVISION_ID,
 420                         RALINK_PCI_CLASS);
 421
 422         /* configure RC FTS number to 250 when it leaves L0s */
 423         val = read_config(pcie, slot, PCIE_FTS_NUM);
 424         val &= ~PCIE_FTS_NUM_MASK;
 425         val |= PCIE_FTS_NUM_L0(0x50);
 426         write_config(pcie, slot, PCIE_FTS_NUM, val);
 427 }
 428
 429 static int mt7621_pcie_enable_ports(struct pci_host_bridge *host)
 430 {
 431         struct mt7621_pcie *pcie = pci_host_bridge_priv(host);
 432         struct device *dev = pcie->dev;
 433         struct mt7621_pcie_port *port;
 434         struct resource_entry *entry;
 435         int err;
 436
 437         entry = resource_list_first_type(&host->windows, IORESOURCE_IO);
 438         if (!entry) {
 439                 dev_err(dev, "cannot get io resource\n");
 440                 return -EINVAL;
 441         }
 442
 443         /* Setup MEMWIN and IOWIN */
 444         pcie_write(pcie, 0xffffffff, RALINK_PCI_MEMBASE);
 445         pcie_write(pcie, entry->res->start - entry->offset, RALINK_PCI_IOBASE);
 446
 447         list_for_each_entry(port, &pcie->ports, list) {
 448                 if (port->enabled) {
 449                         err = clk_prepare_enable(port->clk);
 450                         if (err) {
 451                                 dev_err(dev, "enabling clk pcie%d\n",
 452                                         port->slot);
 453                                 return err;
 454                         }
 455
 456                         mt7621_pcie_enable_port(port);
 457                         dev_info(dev, "PCIE%d enabled\n", port->slot);
 458                 }
 459         }
 460
 461         return 0;
 462 }
 463
 464 static int mt7621_pcie_register_host(struct pci_host_bridge *host)
 465 {
 466         struct mt7621_pcie *pcie = pci_host_bridge_priv(host);
 467
 468         host->ops = &mt7621_pcie_ops;
 469         host->sysdata = pcie;
 470         return pci_host_probe(host);
 471 }
 472
 473 static const struct soc_device_attribute mt7621_pcie_quirks_match[] = {
 474         { .soc_id = "mt7621", .revision = "E2" }
 475 };
 476
 477 static int mt7621_pcie_probe(struct platform_device *pdev)
 478 {
 479         struct device *dev = &pdev->dev;
 480         const struct soc_device_attribute *attr;
 481         struct mt7621_pcie_port *port;
 482         struct mt7621_pcie *pcie;
 483         struct pci_host_bridge *bridge;
 484         int err;
 485
 486         if (!dev->of_node)
 487                 return -ENODEV;
 488
 489         bridge = devm_pci_alloc_host_bridge(dev, sizeof(*pcie));
 490         if (!bridge)
 491                 return -ENOMEM;
 492
 493         pcie = pci_host_bridge_priv(bridge);
 494         pcie->dev = dev;
 495         platform_set_drvdata(pdev, pcie);
 496         INIT_LIST_HEAD(&pcie->ports);
 497
 498         attr = soc_device_match(mt7621_pcie_quirks_match);
 499         if (attr)
 500                 pcie->resets_inverted = true;
 501
 502         err = mt7621_pcie_parse_dt(pcie);
 503         if (err) {
 504                 dev_err(dev, "parsing DT failed\n");
 505                 return err;
 506         }
 507
 508         err = mt7621_pcie_init_ports(pcie);
 509         if (err) {
 510                 dev_err(dev, "nothing connected in virtual bridges\n");
 511                 return 0;
 512         }
 513
 514         err = mt7621_pcie_enable_ports(bridge);
 515         if (err) {
 516                 dev_err(dev, "error enabling pcie ports\n");
 517                 goto remove_resets;
 518         }
 519
 520         return mt7621_pcie_register_host(bridge);
 521
 522 remove_resets:
 523         list_for_each_entry(port, &pcie->ports, list)
 524                 reset_control_put(port->pcie_rst);
 525
 526         return err;
 527 }
 528
 529 static int mt7621_pcie_remove(struct platform_device *pdev)
 530 {
 531         struct mt7621_pcie *pcie = platform_get_drvdata(pdev);
 532         struct mt7621_pcie_port *port;
 533
 534         list_for_each_entry(port, &pcie->ports, list)
 535                 reset_control_put(port->pcie_rst);
 536
 537         return 0;
 538 }
 539
 540 static const struct of_device_id mt7621_pcie_ids[] = {
 541         { .compatible = "mediatek,mt7621-pci" },
 542         {},
 543 };
 544 MODULE_DEVICE_TABLE(of, mt7621_pcie_ids);
 545
 546 static struct platform_driver mt7621_pcie_driver = {
 547         .probe = mt7621_pcie_probe,
 548         .remove = mt7621_pcie_remove,
 549         .driver = {
 550                 .name = "mt7621-pci",
 551                 .of_match_table = mt7621_pcie_ids,
 552         },
 553 };
 554 builtin_platform_driver(mt7621_pcie_driver);
 555
 556 MODULE_LICENSE("GPL v2");