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 * https://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 88 ep->mem_res = devm_kzalloc(dev, sizeof(*ep->mem_res), GFP_KERNEL); 89 if (!ep->mem_res) 90 return -ENOMEM; 91 92 ep->mem_res->elbi_base = devm_platform_ioremap_resource(pdev, 0); 93 if (IS_ERR(ep->mem_res->elbi_base)) 94 return PTR_ERR(ep->mem_res->elbi_base); 95 96 return 0; 97 } 98 99 static int exynos5440_pcie_get_clk_resources(struct exynos_pcie *ep) 100 { 101 struct dw_pcie *pci = ep->pci; 102 struct device *dev = pci->dev; 103 104 ep->clk_res = devm_kzalloc(dev, sizeof(*ep->clk_res), GFP_KERNEL); 105 if (!ep->clk_res) 106 return -ENOMEM; 107 108 ep->clk_res->clk = devm_clk_get(dev, "pcie"); 109 if (IS_ERR(ep->clk_res->clk)) { 110 dev_err(dev, "Failed to get pcie rc clock\n"); 111 return PTR_ERR(ep->clk_res->clk); 112 } 113 114 ep->clk_res->bus_clk = devm_clk_get(dev, "pcie_bus"); 115 if (IS_ERR(ep->clk_res->bus_clk)) { 116 dev_err(dev, "Failed to get pcie bus clock\n"); 117 return PTR_ERR(ep->clk_res->bus_clk); 118 } 119 120 return 0; 121 } 122 123 static int exynos5440_pcie_init_clk_resources(struct exynos_pcie *ep) 124 { 125 struct dw_pcie *pci = ep->pci; 126 struct device *dev = pci->dev; 127 int ret; 128 129 ret = clk_prepare_enable(ep->clk_res->clk); 130 if (ret) { 131 dev_err(dev, "cannot enable pcie rc clock"); 132 return ret; 133 } 134 135 ret = clk_prepare_enable(ep->clk_res->bus_clk); 136 if (ret) { 137 dev_err(dev, "cannot enable pcie bus clock"); 138 goto err_bus_clk; 139 } 140 141 return 0; 142 143 err_bus_clk: 144 clk_disable_unprepare(ep->clk_res->clk); 145 146 return ret; 147 } 148 149 static void exynos5440_pcie_deinit_clk_resources(struct exynos_pcie *ep) 150 { 151 clk_disable_unprepare(ep->clk_res->bus_clk); 152 clk_disable_unprepare(ep->clk_res->clk); 153 } 154 155 static const struct exynos_pcie_ops exynos5440_pcie_ops = { 156 .get_mem_resources = exynos5440_pcie_get_mem_resources, 157 .get_clk_resources = exynos5440_pcie_get_clk_resources, 158 .init_clk_resources = exynos5440_pcie_init_clk_resources, 159 .deinit_clk_resources = exynos5440_pcie_deinit_clk_resources, 160 }; 161 162 static void exynos_pcie_writel(void __iomem *base, u32 val, u32 reg) 163 { 164 writel(val, base + reg); 165 } 166 167 static u32 exynos_pcie_readl(void __iomem *base, u32 reg) 168 { 169 return readl(base + reg); 170 } 171 172 static void exynos_pcie_sideband_dbi_w_mode(struct exynos_pcie *ep, bool on) 173 { 174 u32 val; 175 176 val = exynos_pcie_readl(ep->mem_res->elbi_base, PCIE_ELBI_SLV_AWMISC); 177 if (on) 178 val |= PCIE_ELBI_SLV_DBI_ENABLE; 179 else 180 val &= ~PCIE_ELBI_SLV_DBI_ENABLE; 181 exynos_pcie_writel(ep->mem_res->elbi_base, val, PCIE_ELBI_SLV_AWMISC); 182 } 183 184 static void exynos_pcie_sideband_dbi_r_mode(struct exynos_pcie *ep, bool on) 185 { 186 u32 val; 187 188 val = exynos_pcie_readl(ep->mem_res->elbi_base, PCIE_ELBI_SLV_ARMISC); 189 if (on) 190 val |= PCIE_ELBI_SLV_DBI_ENABLE; 191 else 192 val &= ~PCIE_ELBI_SLV_DBI_ENABLE; 193 exynos_pcie_writel(ep->mem_res->elbi_base, val, PCIE_ELBI_SLV_ARMISC); 194 } 195 196 static void exynos_pcie_assert_core_reset(struct exynos_pcie *ep) 197 { 198 u32 val; 199 200 val = exynos_pcie_readl(ep->mem_res->elbi_base, PCIE_CORE_RESET); 201 val &= ~PCIE_CORE_RESET_ENABLE; 202 exynos_pcie_writel(ep->mem_res->elbi_base, val, PCIE_CORE_RESET); 203 exynos_pcie_writel(ep->mem_res->elbi_base, 0, PCIE_PWR_RESET); 204 exynos_pcie_writel(ep->mem_res->elbi_base, 0, PCIE_STICKY_RESET); 205 exynos_pcie_writel(ep->mem_res->elbi_base, 0, PCIE_NONSTICKY_RESET); 206 } 207 208 static void exynos_pcie_deassert_core_reset(struct exynos_pcie *ep) 209 { 210 u32 val; 211 212 val = exynos_pcie_readl(ep->mem_res->elbi_base, PCIE_CORE_RESET); 213 val |= PCIE_CORE_RESET_ENABLE; 214 215 exynos_pcie_writel(ep->mem_res->elbi_base, val, PCIE_CORE_RESET); 216 exynos_pcie_writel(ep->mem_res->elbi_base, 1, PCIE_STICKY_RESET); 217 exynos_pcie_writel(ep->mem_res->elbi_base, 1, PCIE_NONSTICKY_RESET); 218 exynos_pcie_writel(ep->mem_res->elbi_base, 1, PCIE_APP_INIT_RESET); 219 exynos_pcie_writel(ep->mem_res->elbi_base, 0, PCIE_APP_INIT_RESET); 220 } 221 222 static void exynos_pcie_assert_reset(struct exynos_pcie *ep) 223 { 224 struct dw_pcie *pci = ep->pci; 225 struct device *dev = pci->dev; 226 227 if (ep->reset_gpio >= 0) 228 devm_gpio_request_one(dev, ep->reset_gpio, 229 GPIOF_OUT_INIT_HIGH, "RESET"); 230 } 231 232 static int exynos_pcie_establish_link(struct exynos_pcie *ep) 233 { 234 struct dw_pcie *pci = ep->pci; 235 struct pcie_port *pp = &pci->pp; 236 struct device *dev = pci->dev; 237 238 if (dw_pcie_link_up(pci)) { 239 dev_err(dev, "Link already up\n"); 240 return 0; 241 } 242 243 exynos_pcie_assert_core_reset(ep); 244 245 phy_reset(ep->phy); 246 247 exynos_pcie_writel(ep->mem_res->elbi_base, 1, 248 PCIE_PWR_RESET); 249 250 phy_power_on(ep->phy); 251 phy_init(ep->phy); 252 253 exynos_pcie_deassert_core_reset(ep); 254 dw_pcie_setup_rc(pp); 255 exynos_pcie_assert_reset(ep); 256 257 /* assert LTSSM enable */ 258 exynos_pcie_writel(ep->mem_res->elbi_base, PCIE_ELBI_LTSSM_ENABLE, 259 PCIE_APP_LTSSM_ENABLE); 260 261 /* check if the link is up or not */ 262 if (!dw_pcie_wait_for_link(pci)) 263 return 0; 264 265 phy_power_off(ep->phy); 266 return -ETIMEDOUT; 267 } 268 269 static void exynos_pcie_clear_irq_pulse(struct exynos_pcie *ep) 270 { 271 u32 val; 272 273 val = exynos_pcie_readl(ep->mem_res->elbi_base, PCIE_IRQ_PULSE); 274 exynos_pcie_writel(ep->mem_res->elbi_base, val, PCIE_IRQ_PULSE); 275 } 276 277 static void exynos_pcie_enable_irq_pulse(struct exynos_pcie *ep) 278 { 279 u32 val; 280 281 /* enable INTX interrupt */ 282 val = IRQ_INTA_ASSERT | IRQ_INTB_ASSERT | 283 IRQ_INTC_ASSERT | IRQ_INTD_ASSERT; 284 exynos_pcie_writel(ep->mem_res->elbi_base, val, PCIE_IRQ_EN_PULSE); 285 } 286 287 static irqreturn_t exynos_pcie_irq_handler(int irq, void *arg) 288 { 289 struct exynos_pcie *ep = arg; 290 291 exynos_pcie_clear_irq_pulse(ep); 292 return IRQ_HANDLED; 293 } 294 295 static void exynos_pcie_msi_init(struct exynos_pcie *ep) 296 { 297 struct dw_pcie *pci = ep->pci; 298 struct pcie_port *pp = &pci->pp; 299 u32 val; 300 301 dw_pcie_msi_init(pp); 302 303 /* enable MSI interrupt */ 304 val = exynos_pcie_readl(ep->mem_res->elbi_base, PCIE_IRQ_EN_LEVEL); 305 val |= IRQ_MSI_ENABLE; 306 exynos_pcie_writel(ep->mem_res->elbi_base, val, PCIE_IRQ_EN_LEVEL); 307 } 308 309 static void exynos_pcie_enable_interrupts(struct exynos_pcie *ep) 310 { 311 exynos_pcie_enable_irq_pulse(ep); 312 313 if (IS_ENABLED(CONFIG_PCI_MSI)) 314 exynos_pcie_msi_init(ep); 315 } 316 317 static u32 exynos_pcie_read_dbi(struct dw_pcie *pci, void __iomem *base, 318 u32 reg, size_t size) 319 { 320 struct exynos_pcie *ep = to_exynos_pcie(pci); 321 u32 val; 322 323 exynos_pcie_sideband_dbi_r_mode(ep, true); 324 dw_pcie_read(base + reg, size, &val); 325 exynos_pcie_sideband_dbi_r_mode(ep, false); 326 return val; 327 } 328 329 static void exynos_pcie_write_dbi(struct dw_pcie *pci, void __iomem *base, 330 u32 reg, size_t size, u32 val) 331 { 332 struct exynos_pcie *ep = to_exynos_pcie(pci); 333 334 exynos_pcie_sideband_dbi_w_mode(ep, true); 335 dw_pcie_write(base + reg, size, val); 336 exynos_pcie_sideband_dbi_w_mode(ep, false); 337 } 338 339 static int exynos_pcie_rd_own_conf(struct pci_bus *bus, unsigned int devfn, 340 int where, int size, u32 *val) 341 { 342 struct dw_pcie *pci = to_dw_pcie_from_pp(bus->sysdata); 343 344 if (PCI_SLOT(devfn)) { 345 *val = ~0; 346 return PCIBIOS_DEVICE_NOT_FOUND; 347 } 348 349 *val = dw_pcie_read_dbi(pci, where, size); 350 return PCIBIOS_SUCCESSFUL; 351 } 352 353 static int exynos_pcie_wr_own_conf(struct pci_bus *bus, unsigned int devfn, 354 int where, int size, u32 val) 355 { 356 struct dw_pcie *pci = to_dw_pcie_from_pp(bus->sysdata); 357 358 if (PCI_SLOT(devfn)) 359 return PCIBIOS_DEVICE_NOT_FOUND; 360 361 dw_pcie_write_dbi(pci, where, size, val); 362 return PCIBIOS_SUCCESSFUL; 363 } 364 365 static struct pci_ops exynos_pci_ops = { 366 .read = exynos_pcie_rd_own_conf, 367 .write = exynos_pcie_wr_own_conf, 368 }; 369 370 static int exynos_pcie_link_up(struct dw_pcie *pci) 371 { 372 struct exynos_pcie *ep = to_exynos_pcie(pci); 373 u32 val; 374 375 val = exynos_pcie_readl(ep->mem_res->elbi_base, PCIE_ELBI_RDLH_LINKUP); 376 if (val == PCIE_ELBI_LTSSM_ENABLE) 377 return 1; 378 379 return 0; 380 } 381 382 static int exynos_pcie_host_init(struct pcie_port *pp) 383 { 384 struct dw_pcie *pci = to_dw_pcie_from_pp(pp); 385 struct exynos_pcie *ep = to_exynos_pcie(pci); 386 387 pp->bridge->ops = &exynos_pci_ops; 388 389 exynos_pcie_establish_link(ep); 390 exynos_pcie_enable_interrupts(ep); 391 392 return 0; 393 } 394 395 static const struct dw_pcie_host_ops exynos_pcie_host_ops = { 396 .host_init = exynos_pcie_host_init, 397 }; 398 399 static int __init exynos_add_pcie_port(struct exynos_pcie *ep, 400 struct platform_device *pdev) 401 { 402 struct dw_pcie *pci = ep->pci; 403 struct pcie_port *pp = &pci->pp; 404 struct device *dev = &pdev->dev; 405 int ret; 406 407 pp->irq = platform_get_irq(pdev, 1); 408 if (pp->irq < 0) 409 return pp->irq; 410 411 ret = devm_request_irq(dev, pp->irq, exynos_pcie_irq_handler, 412 IRQF_SHARED, "exynos-pcie", ep); 413 if (ret) { 414 dev_err(dev, "failed to request irq\n"); 415 return ret; 416 } 417 418 if (IS_ENABLED(CONFIG_PCI_MSI)) { 419 pp->msi_irq = platform_get_irq(pdev, 0); 420 if (pp->msi_irq < 0) 421 return pp->msi_irq; 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) != -ENODEV) 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); 539