drivers/pci/controller/dwc/pci-exynos.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * PCIe host controller driver for Samsung EXYNOS SoCs
   4  *
   5  * Copyright (C) 2013 Samsung Electronics Co., Ltd.
   6  *              http://www.samsung.com
   7  *
   8  * Author: Jingoo Han <jg1.han@samsung.com>
   9  */
  10
  11 #include <linux/clk.h>
  12 #include <linux/delay.h>
  13 #include <linux/gpio.h>
  14 #include <linux/interrupt.h>
  15 #include <linux/kernel.h>
  16 #include <linux/init.h>
  17 #include <linux/of_device.h>
  18 #include <linux/of_gpio.h>
  19 #include <linux/pci.h>
  20 #include <linux/platform_device.h>
  21 #include <linux/phy/phy.h>
  22 #include <linux/resource.h>
  23 #include <linux/signal.h>
  24 #include <linux/types.h>
  25
  26 #include "pcie-designware.h"
  27
  28 #define to_exynos_pcie(x)       dev_get_drvdata((x)->dev)
  29
  30 /* PCIe ELBI registers */
  31 #define PCIE_IRQ_PULSE                  0x000
  32 #define IRQ_INTA_ASSERT                 BIT(0)
  33 #define IRQ_INTB_ASSERT                 BIT(2)
  34 #define IRQ_INTC_ASSERT                 BIT(4)
  35 #define IRQ_INTD_ASSERT                 BIT(6)
  36 #define PCIE_IRQ_LEVEL                  0x004
  37 #define PCIE_IRQ_SPECIAL                0x008
  38 #define PCIE_IRQ_EN_PULSE               0x00c
  39 #define PCIE_IRQ_EN_LEVEL               0x010
  40 #define IRQ_MSI_ENABLE                  BIT(2)
  41 #define PCIE_IRQ_EN_SPECIAL             0x014
  42 #define PCIE_PWR_RESET                  0x018
  43 #define PCIE_CORE_RESET                 0x01c
  44 #define PCIE_CORE_RESET_ENABLE          BIT(0)
  45 #define PCIE_STICKY_RESET               0x020
  46 #define PCIE_NONSTICKY_RESET            0x024
  47 #define PCIE_APP_INIT_RESET             0x028
  48 #define PCIE_APP_LTSSM_ENABLE           0x02c
  49 #define PCIE_ELBI_RDLH_LINKUP           0x064
  50 #define PCIE_ELBI_LTSSM_ENABLE          0x1
  51 #define PCIE_ELBI_SLV_AWMISC            0x11c
  52 #define PCIE_ELBI_SLV_ARMISC            0x120
  53 #define PCIE_ELBI_SLV_DBI_ENABLE        BIT(21)
  54
  55 struct exynos_pcie_mem_res {
  56         void __iomem *elbi_base;   /* DT 0th resource: PCIe CTRL */
  57 };
  58
  59 struct exynos_pcie_clk_res {
  60         struct clk *clk;
  61         struct clk *bus_clk;
  62 };
  63
  64 struct exynos_pcie {
  65         struct dw_pcie                  *pci;
  66         struct exynos_pcie_mem_res      *mem_res;
  67         struct exynos_pcie_clk_res      *clk_res;
  68         const struct exynos_pcie_ops    *ops;
  69         int                             reset_gpio;
  70
  71         struct phy                      *phy;
  72 };
  73
  74 struct exynos_pcie_ops {
  75         int (*get_mem_resources)(struct platform_device *pdev,
  76                         struct exynos_pcie *ep);
  77         int (*get_clk_resources)(struct exynos_pcie *ep);
  78         int (*init_clk_resources)(struct exynos_pcie *ep);
  79         void (*deinit_clk_resources)(struct exynos_pcie *ep);
  80 };
  81
  82 static int exynos5440_pcie_get_mem_resources(struct platform_device *pdev,
  83                                              struct exynos_pcie *ep)
  84 {
  85         struct dw_pcie *pci = ep->pci;
  86         struct device *dev = pci->dev;
  87         struct resource *res;
  88
  89         ep->mem_res = devm_kzalloc(dev, sizeof(*ep->mem_res), GFP_KERNEL);
  90         if (!ep->mem_res)
  91                 return -ENOMEM;
  92
  93         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
  94         ep->mem_res->elbi_base = devm_ioremap_resource(dev, res);
  95         if (IS_ERR(ep->mem_res->elbi_base))
  96                 return PTR_ERR(ep->mem_res->elbi_base);
  97
  98         return 0;
  99 }
 100
 101 static int exynos5440_pcie_get_clk_resources(struct exynos_pcie *ep)
 102 {
 103         struct dw_pcie *pci = ep->pci;
 104         struct device *dev = pci->dev;
 105
 106         ep->clk_res = devm_kzalloc(dev, sizeof(*ep->clk_res), GFP_KERNEL);
 107         if (!ep->clk_res)
 108                 return -ENOMEM;
 109
 110         ep->clk_res->clk = devm_clk_get(dev, "pcie");
 111         if (IS_ERR(ep->clk_res->clk)) {
 112                 dev_err(dev, "Failed to get pcie rc clock\n");
 113                 return PTR_ERR(ep->clk_res->clk);
 114         }
 115
 116         ep->clk_res->bus_clk = devm_clk_get(dev, "pcie_bus");
 117         if (IS_ERR(ep->clk_res->bus_clk)) {
 118                 dev_err(dev, "Failed to get pcie bus clock\n");
 119                 return PTR_ERR(ep->clk_res->bus_clk);
 120         }
 121
 122         return 0;
 123 }
 124
 125 static int exynos5440_pcie_init_clk_resources(struct exynos_pcie *ep)
 126 {
 127         struct dw_pcie *pci = ep->pci;
 128         struct device *dev = pci->dev;
 129         int ret;
 130
 131         ret = clk_prepare_enable(ep->clk_res->clk);
 132         if (ret) {
 133                 dev_err(dev, "cannot enable pcie rc clock");
 134                 return ret;
 135         }
 136
 137         ret = clk_prepare_enable(ep->clk_res->bus_clk);
 138         if (ret) {
 139                 dev_err(dev, "cannot enable pcie bus clock");
 140                 goto err_bus_clk;
 141         }
 142
 143         return 0;
 144
 145 err_bus_clk:
 146         clk_disable_unprepare(ep->clk_res->clk);
 147
 148         return ret;
 149 }
 150
 151 static void exynos5440_pcie_deinit_clk_resources(struct exynos_pcie *ep)
 152 {
 153         clk_disable_unprepare(ep->clk_res->bus_clk);
 154         clk_disable_unprepare(ep->clk_res->clk);
 155 }
 156
 157 static const struct exynos_pcie_ops exynos5440_pcie_ops = {
 158         .get_mem_resources      = exynos5440_pcie_get_mem_resources,
 159         .get_clk_resources      = exynos5440_pcie_get_clk_resources,
 160         .init_clk_resources     = exynos5440_pcie_init_clk_resources,
 161         .deinit_clk_resources   = exynos5440_pcie_deinit_clk_resources,
 162 };
 163
 164 static void exynos_pcie_writel(void __iomem *base, u32 val, u32 reg)
 165 {
 166         writel(val, base + reg);
 167 }
 168
 169 static u32 exynos_pcie_readl(void __iomem *base, u32 reg)
 170 {
 171         return readl(base + reg);
 172 }
 173
 174 static void exynos_pcie_sideband_dbi_w_mode(struct exynos_pcie *ep, bool on)
 175 {
 176         u32 val;
 177
 178         val = exynos_pcie_readl(ep->mem_res->elbi_base, PCIE_ELBI_SLV_AWMISC);
 179         if (on)
 180                 val |= PCIE_ELBI_SLV_DBI_ENABLE;
 181         else
 182                 val &= ~PCIE_ELBI_SLV_DBI_ENABLE;
 183         exynos_pcie_writel(ep->mem_res->elbi_base, val, PCIE_ELBI_SLV_AWMISC);
 184 }
 185
 186 static void exynos_pcie_sideband_dbi_r_mode(struct exynos_pcie *ep, bool on)
 187 {
 188         u32 val;
 189
 190         val = exynos_pcie_readl(ep->mem_res->elbi_base, PCIE_ELBI_SLV_ARMISC);
 191         if (on)
 192                 val |= PCIE_ELBI_SLV_DBI_ENABLE;
 193         else
 194                 val &= ~PCIE_ELBI_SLV_DBI_ENABLE;
 195         exynos_pcie_writel(ep->mem_res->elbi_base, val, PCIE_ELBI_SLV_ARMISC);
 196 }
 197
 198 static void exynos_pcie_assert_core_reset(struct exynos_pcie *ep)
 199 {
 200         u32 val;
 201
 202         val = exynos_pcie_readl(ep->mem_res->elbi_base, PCIE_CORE_RESET);
 203         val &= ~PCIE_CORE_RESET_ENABLE;
 204         exynos_pcie_writel(ep->mem_res->elbi_base, val, PCIE_CORE_RESET);
 205         exynos_pcie_writel(ep->mem_res->elbi_base, 0, PCIE_PWR_RESET);
 206         exynos_pcie_writel(ep->mem_res->elbi_base, 0, PCIE_STICKY_RESET);
 207         exynos_pcie_writel(ep->mem_res->elbi_base, 0, PCIE_NONSTICKY_RESET);
 208 }
 209
 210 static void exynos_pcie_deassert_core_reset(struct exynos_pcie *ep)
 211 {
 212         u32 val;
 213
 214         val = exynos_pcie_readl(ep->mem_res->elbi_base, PCIE_CORE_RESET);
 215         val |= PCIE_CORE_RESET_ENABLE;
 216
 217         exynos_pcie_writel(ep->mem_res->elbi_base, val, PCIE_CORE_RESET);
 218         exynos_pcie_writel(ep->mem_res->elbi_base, 1, PCIE_STICKY_RESET);
 219         exynos_pcie_writel(ep->mem_res->elbi_base, 1, PCIE_NONSTICKY_RESET);
 220         exynos_pcie_writel(ep->mem_res->elbi_base, 1, PCIE_APP_INIT_RESET);
 221         exynos_pcie_writel(ep->mem_res->elbi_base, 0, PCIE_APP_INIT_RESET);
 222 }
 223
 224 static void exynos_pcie_assert_reset(struct exynos_pcie *ep)
 225 {
 226         struct dw_pcie *pci = ep->pci;
 227         struct device *dev = pci->dev;
 228
 229         if (ep->reset_gpio >= 0)
 230                 devm_gpio_request_one(dev, ep->reset_gpio,
 231                                 GPIOF_OUT_INIT_HIGH, "RESET");
 232 }
 233
 234 static int exynos_pcie_establish_link(struct exynos_pcie *ep)
 235 {
 236         struct dw_pcie *pci = ep->pci;
 237         struct pcie_port *pp = &pci->pp;
 238         struct device *dev = pci->dev;
 239
 240         if (dw_pcie_link_up(pci)) {
 241                 dev_err(dev, "Link already up\n");
 242                 return 0;
 243         }
 244
 245         exynos_pcie_assert_core_reset(ep);
 246
 247         phy_reset(ep->phy);
 248
 249         exynos_pcie_writel(ep->mem_res->elbi_base, 1,
 250                         PCIE_PWR_RESET);
 251
 252         phy_power_on(ep->phy);
 253         phy_init(ep->phy);
 254
 255         exynos_pcie_deassert_core_reset(ep);
 256         dw_pcie_setup_rc(pp);
 257         exynos_pcie_assert_reset(ep);
 258
 259         /* assert LTSSM enable */
 260         exynos_pcie_writel(ep->mem_res->elbi_base, PCIE_ELBI_LTSSM_ENABLE,
 261                           PCIE_APP_LTSSM_ENABLE);
 262
 263         /* check if the link is up or not */
 264         if (!dw_pcie_wait_for_link(pci))
 265                 return 0;
 266
 267         phy_power_off(ep->phy);
 268         return -ETIMEDOUT;
 269 }
 270
 271 static void exynos_pcie_clear_irq_pulse(struct exynos_pcie *ep)
 272 {
 273         u32 val;
 274
 275         val = exynos_pcie_readl(ep->mem_res->elbi_base, PCIE_IRQ_PULSE);
 276         exynos_pcie_writel(ep->mem_res->elbi_base, val, PCIE_IRQ_PULSE);
 277 }
 278
 279 static void exynos_pcie_enable_irq_pulse(struct exynos_pcie *ep)
 280 {
 281         u32 val;
 282
 283         /* enable INTX interrupt */
 284         val = IRQ_INTA_ASSERT | IRQ_INTB_ASSERT |
 285                 IRQ_INTC_ASSERT | IRQ_INTD_ASSERT;
 286         exynos_pcie_writel(ep->mem_res->elbi_base, val, PCIE_IRQ_EN_PULSE);
 287 }
 288
 289 static irqreturn_t exynos_pcie_irq_handler(int irq, void *arg)
 290 {
 291         struct exynos_pcie *ep = arg;
 292
 293         exynos_pcie_clear_irq_pulse(ep);
 294         return IRQ_HANDLED;
 295 }
 296
 297 static void exynos_pcie_msi_init(struct exynos_pcie *ep)
 298 {
 299         struct dw_pcie *pci = ep->pci;
 300         struct pcie_port *pp = &pci->pp;
 301         u32 val;
 302
 303         dw_pcie_msi_init(pp);
 304
 305         /* enable MSI interrupt */
 306         val = exynos_pcie_readl(ep->mem_res->elbi_base, PCIE_IRQ_EN_LEVEL);
 307         val |= IRQ_MSI_ENABLE;
 308         exynos_pcie_writel(ep->mem_res->elbi_base, val, PCIE_IRQ_EN_LEVEL);
 309 }
 310
 311 static void exynos_pcie_enable_interrupts(struct exynos_pcie *ep)
 312 {
 313         exynos_pcie_enable_irq_pulse(ep);
 314
 315         if (IS_ENABLED(CONFIG_PCI_MSI))
 316                 exynos_pcie_msi_init(ep);
 317 }
 318
 319 static u32 exynos_pcie_read_dbi(struct dw_pcie *pci, void __iomem *base,
 320                                 u32 reg, size_t size)
 321 {
 322         struct exynos_pcie *ep = to_exynos_pcie(pci);
 323         u32 val;
 324
 325         exynos_pcie_sideband_dbi_r_mode(ep, true);
 326         dw_pcie_read(base + reg, size, &val);
 327         exynos_pcie_sideband_dbi_r_mode(ep, false);
 328         return val;
 329 }
 330
 331 static void exynos_pcie_write_dbi(struct dw_pcie *pci, void __iomem *base,
 332                                   u32 reg, size_t size, u32 val)
 333 {
 334         struct exynos_pcie *ep = to_exynos_pcie(pci);
 335
 336         exynos_pcie_sideband_dbi_w_mode(ep, true);
 337         dw_pcie_write(base + reg, size, val);
 338         exynos_pcie_sideband_dbi_w_mode(ep, false);
 339 }
 340
 341 static int exynos_pcie_rd_own_conf(struct pcie_port *pp, int where, int size,
 342                                 u32 *val)
 343 {
 344         struct dw_pcie *pci = to_dw_pcie_from_pp(pp);
 345         struct exynos_pcie *ep = to_exynos_pcie(pci);
 346         int ret;
 347
 348         exynos_pcie_sideband_dbi_r_mode(ep, true);
 349         ret = dw_pcie_read(pci->dbi_base + where, size, val);
 350         exynos_pcie_sideband_dbi_r_mode(ep, false);
 351         return ret;
 352 }
 353
 354 static int exynos_pcie_wr_own_conf(struct pcie_port *pp, int where, int size,
 355                                 u32 val)
 356 {
 357         struct dw_pcie *pci = to_dw_pcie_from_pp(pp);
 358         struct exynos_pcie *ep = to_exynos_pcie(pci);
 359         int ret;
 360
 361         exynos_pcie_sideband_dbi_w_mode(ep, true);
 362         ret = dw_pcie_write(pci->dbi_base + where, size, val);
 363         exynos_pcie_sideband_dbi_w_mode(ep, false);
 364         return ret;
 365 }
 366
 367 static int exynos_pcie_link_up(struct dw_pcie *pci)
 368 {
 369         struct exynos_pcie *ep = to_exynos_pcie(pci);
 370         u32 val;
 371
 372         val = exynos_pcie_readl(ep->mem_res->elbi_base, PCIE_ELBI_RDLH_LINKUP);
 373         if (val == PCIE_ELBI_LTSSM_ENABLE)
 374                 return 1;
 375
 376         return 0;
 377 }
 378
 379 static int exynos_pcie_host_init(struct pcie_port *pp)
 380 {
 381         struct dw_pcie *pci = to_dw_pcie_from_pp(pp);
 382         struct exynos_pcie *ep = to_exynos_pcie(pci);
 383
 384         exynos_pcie_establish_link(ep);
 385         exynos_pcie_enable_interrupts(ep);
 386
 387         return 0;
 388 }
 389
 390 static const struct dw_pcie_host_ops exynos_pcie_host_ops = {
 391         .rd_own_conf = exynos_pcie_rd_own_conf,
 392         .wr_own_conf = exynos_pcie_wr_own_conf,
 393         .host_init = exynos_pcie_host_init,
 394 };
 395
 396 static int __init exynos_add_pcie_port(struct exynos_pcie *ep,
 397                                        struct platform_device *pdev)
 398 {
 399         struct dw_pcie *pci = ep->pci;
 400         struct pcie_port *pp = &pci->pp;
 401         struct device *dev = &pdev->dev;
 402         int ret;
 403
 404         pp->irq = platform_get_irq(pdev, 1);
 405         if (pp->irq < 0) {
 406                 dev_err(dev, "failed to get irq\n");
 407                 return pp->irq;
 408         }
 409         ret = devm_request_irq(dev, pp->irq, exynos_pcie_irq_handler,
 410                                 IRQF_SHARED, "exynos-pcie", ep);
 411         if (ret) {
 412                 dev_err(dev, "failed to request irq\n");
 413                 return ret;
 414         }
 415
 416         if (IS_ENABLED(CONFIG_PCI_MSI)) {
 417                 pp->msi_irq = platform_get_irq(pdev, 0);
 418                 if (pp->msi_irq < 0) {
 419                         dev_err(dev, "failed to get msi irq\n");
 420                         return pp->msi_irq;
 421                 }
 422         }
 423
 424         pp->ops = &exynos_pcie_host_ops;
 425
 426         ret = dw_pcie_host_init(pp);
 427         if (ret) {
 428                 dev_err(dev, "failed to initialize host\n");
 429                 return ret;
 430         }
 431
 432         return 0;
 433 }
 434
 435 static const struct dw_pcie_ops dw_pcie_ops = {
 436         .read_dbi = exynos_pcie_read_dbi,
 437         .write_dbi = exynos_pcie_write_dbi,
 438         .link_up = exynos_pcie_link_up,
 439 };
 440
 441 static int __init exynos_pcie_probe(struct platform_device *pdev)
 442 {
 443         struct device *dev = &pdev->dev;
 444         struct dw_pcie *pci;
 445         struct exynos_pcie *ep;
 446         struct device_node *np = dev->of_node;
 447         int ret;
 448
 449         ep = devm_kzalloc(dev, sizeof(*ep), GFP_KERNEL);
 450         if (!ep)
 451                 return -ENOMEM;
 452
 453         pci = devm_kzalloc(dev, sizeof(*pci), GFP_KERNEL);
 454         if (!pci)
 455                 return -ENOMEM;
 456
 457         pci->dev = dev;
 458         pci->ops = &dw_pcie_ops;
 459
 460         ep->pci = pci;
 461         ep->ops = (const struct exynos_pcie_ops *)
 462                 of_device_get_match_data(dev);
 463
 464         ep->reset_gpio = of_get_named_gpio(np, "reset-gpio", 0);
 465
 466         ep->phy = devm_of_phy_get(dev, np, NULL);
 467         if (IS_ERR(ep->phy)) {
 468                 if (PTR_ERR(ep->phy) == -EPROBE_DEFER)
 469                         return PTR_ERR(ep->phy);
 470
 471                 ep->phy = NULL;
 472         }
 473
 474         if (ep->ops && ep->ops->get_mem_resources) {
 475                 ret = ep->ops->get_mem_resources(pdev, ep);
 476                 if (ret)
 477                         return ret;
 478         }
 479
 480         if (ep->ops && ep->ops->get_clk_resources &&
 481                         ep->ops->init_clk_resources) {
 482                 ret = ep->ops->get_clk_resources(ep);
 483                 if (ret)
 484                         return ret;
 485                 ret = ep->ops->init_clk_resources(ep);
 486                 if (ret)
 487                         return ret;
 488         }
 489
 490         platform_set_drvdata(pdev, ep);
 491
 492         ret = exynos_add_pcie_port(ep, pdev);
 493         if (ret < 0)
 494                 goto fail_probe;
 495
 496         return 0;
 497
 498 fail_probe:
 499         phy_exit(ep->phy);
 500
 501         if (ep->ops && ep->ops->deinit_clk_resources)
 502                 ep->ops->deinit_clk_resources(ep);
 503         return ret;
 504 }
 505
 506 static int __exit exynos_pcie_remove(struct platform_device *pdev)
 507 {
 508         struct exynos_pcie *ep = platform_get_drvdata(pdev);
 509
 510         if (ep->ops && ep->ops->deinit_clk_resources)
 511                 ep->ops->deinit_clk_resources(ep);
 512
 513         return 0;
 514 }
 515
 516 static const struct of_device_id exynos_pcie_of_match[] = {
 517         {
 518                 .compatible = "samsung,exynos5440-pcie",
 519                 .data = &exynos5440_pcie_ops
 520         },
 521         {},
 522 };
 523
 524 static struct platform_driver exynos_pcie_driver = {
 525         .remove         = __exit_p(exynos_pcie_remove),
 526         .driver = {
 527                 .name   = "exynos-pcie",
 528                 .of_match_table = exynos_pcie_of_match,
 529         },
 530 };
 531
 532 /* Exynos PCIe driver does not allow module unload */
 533
 534 static int __init exynos_pcie_init(void)
 535 {
 536         return platform_driver_probe(&exynos_pcie_driver, exynos_pcie_probe);
 537 }
 538 subsys_initcall(exynos_pcie_init);