1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * PCIe host controller driver for Samsung Exynos SoCs 4 * 5 * Copyright (C) 2013-2020 Samsung Electronics Co., Ltd. 6 * https://www.samsung.com 7 * 8 * Author: Jingoo Han <jg1.han@samsung.com> 9 * Jaehoon Chung <jh80.chung@samsung.com> 10 */ 11 12 #include <linux/clk.h> 13 #include <linux/delay.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/pci.h> 19 #include <linux/platform_device.h> 20 #include <linux/phy/phy.h> 21 #include <linux/regulator/consumer.h> 22 23 #include "pcie-designware.h" 24 25 #define to_exynos_pcie(x) dev_get_drvdata((x)->dev) 26 27 /* PCIe ELBI registers */ 28 #define PCIE_IRQ_PULSE 0x000 29 #define IRQ_INTA_ASSERT BIT(0) 30 #define IRQ_INTB_ASSERT BIT(2) 31 #define IRQ_INTC_ASSERT BIT(4) 32 #define IRQ_INTD_ASSERT BIT(6) 33 #define PCIE_IRQ_LEVEL 0x004 34 #define PCIE_IRQ_SPECIAL 0x008 35 #define PCIE_IRQ_EN_PULSE 0x00c 36 #define PCIE_IRQ_EN_LEVEL 0x010 37 #define PCIE_IRQ_EN_SPECIAL 0x014 38 #define PCIE_SW_WAKE 0x018 39 #define PCIE_BUS_EN BIT(1) 40 #define PCIE_CORE_RESET 0x01c 41 #define PCIE_CORE_RESET_ENABLE BIT(0) 42 #define PCIE_STICKY_RESET 0x020 43 #define PCIE_NONSTICKY_RESET 0x024 44 #define PCIE_APP_INIT_RESET 0x028 45 #define PCIE_APP_LTSSM_ENABLE 0x02c 46 #define PCIE_ELBI_RDLH_LINKUP 0x074 47 #define PCIE_ELBI_XMLH_LINKUP BIT(4) 48 #define PCIE_ELBI_LTSSM_ENABLE 0x1 49 #define PCIE_ELBI_SLV_AWMISC 0x11c 50 #define PCIE_ELBI_SLV_ARMISC 0x120 51 #define PCIE_ELBI_SLV_DBI_ENABLE BIT(21) 52 53 struct exynos_pcie { 54 struct dw_pcie pci; 55 void __iomem *elbi_base; 56 struct clk *clk; 57 struct clk *bus_clk; 58 struct phy *phy; 59 struct regulator_bulk_data supplies[2]; 60 }; 61 62 static int exynos_pcie_init_clk_resources(struct exynos_pcie *ep) 63 { 64 struct device *dev = ep->pci.dev; 65 int ret; 66 67 ret = clk_prepare_enable(ep->clk); 68 if (ret) { 69 dev_err(dev, "cannot enable pcie rc clock"); 70 return ret; 71 } 72 73 ret = clk_prepare_enable(ep->bus_clk); 74 if (ret) { 75 dev_err(dev, "cannot enable pcie bus clock"); 76 goto err_bus_clk; 77 } 78 79 return 0; 80 81 err_bus_clk: 82 clk_disable_unprepare(ep->clk); 83 84 return ret; 85 } 86 87 static void exynos_pcie_deinit_clk_resources(struct exynos_pcie *ep) 88 { 89 clk_disable_unprepare(ep->bus_clk); 90 clk_disable_unprepare(ep->clk); 91 } 92 93 static void exynos_pcie_writel(void __iomem *base, u32 val, u32 reg) 94 { 95 writel(val, base + reg); 96 } 97 98 static u32 exynos_pcie_readl(void __iomem *base, u32 reg) 99 { 100 return readl(base + reg); 101 } 102 103 static void exynos_pcie_sideband_dbi_w_mode(struct exynos_pcie *ep, bool on) 104 { 105 u32 val; 106 107 val = exynos_pcie_readl(ep->elbi_base, PCIE_ELBI_SLV_AWMISC); 108 if (on) 109 val |= PCIE_ELBI_SLV_DBI_ENABLE; 110 else 111 val &= ~PCIE_ELBI_SLV_DBI_ENABLE; 112 exynos_pcie_writel(ep->elbi_base, val, PCIE_ELBI_SLV_AWMISC); 113 } 114 115 static void exynos_pcie_sideband_dbi_r_mode(struct exynos_pcie *ep, bool on) 116 { 117 u32 val; 118 119 val = exynos_pcie_readl(ep->elbi_base, PCIE_ELBI_SLV_ARMISC); 120 if (on) 121 val |= PCIE_ELBI_SLV_DBI_ENABLE; 122 else 123 val &= ~PCIE_ELBI_SLV_DBI_ENABLE; 124 exynos_pcie_writel(ep->elbi_base, val, PCIE_ELBI_SLV_ARMISC); 125 } 126 127 static void exynos_pcie_assert_core_reset(struct exynos_pcie *ep) 128 { 129 u32 val; 130 131 val = exynos_pcie_readl(ep->elbi_base, PCIE_CORE_RESET); 132 val &= ~PCIE_CORE_RESET_ENABLE; 133 exynos_pcie_writel(ep->elbi_base, val, PCIE_CORE_RESET); 134 exynos_pcie_writel(ep->elbi_base, 0, PCIE_STICKY_RESET); 135 exynos_pcie_writel(ep->elbi_base, 0, PCIE_NONSTICKY_RESET); 136 } 137 138 static void exynos_pcie_deassert_core_reset(struct exynos_pcie *ep) 139 { 140 u32 val; 141 142 val = exynos_pcie_readl(ep->elbi_base, PCIE_CORE_RESET); 143 val |= PCIE_CORE_RESET_ENABLE; 144 145 exynos_pcie_writel(ep->elbi_base, val, PCIE_CORE_RESET); 146 exynos_pcie_writel(ep->elbi_base, 1, PCIE_STICKY_RESET); 147 exynos_pcie_writel(ep->elbi_base, 1, PCIE_NONSTICKY_RESET); 148 exynos_pcie_writel(ep->elbi_base, 1, PCIE_APP_INIT_RESET); 149 exynos_pcie_writel(ep->elbi_base, 0, PCIE_APP_INIT_RESET); 150 } 151 152 static int exynos_pcie_start_link(struct dw_pcie *pci) 153 { 154 struct exynos_pcie *ep = to_exynos_pcie(pci); 155 u32 val; 156 157 val = exynos_pcie_readl(ep->elbi_base, PCIE_SW_WAKE); 158 val &= ~PCIE_BUS_EN; 159 exynos_pcie_writel(ep->elbi_base, val, PCIE_SW_WAKE); 160 161 /* assert LTSSM enable */ 162 exynos_pcie_writel(ep->elbi_base, PCIE_ELBI_LTSSM_ENABLE, 163 PCIE_APP_LTSSM_ENABLE); 164 return 0; 165 } 166 167 static void exynos_pcie_clear_irq_pulse(struct exynos_pcie *ep) 168 { 169 u32 val = exynos_pcie_readl(ep->elbi_base, PCIE_IRQ_PULSE); 170 171 exynos_pcie_writel(ep->elbi_base, val, PCIE_IRQ_PULSE); 172 } 173 174 static irqreturn_t exynos_pcie_irq_handler(int irq, void *arg) 175 { 176 struct exynos_pcie *ep = arg; 177 178 exynos_pcie_clear_irq_pulse(ep); 179 return IRQ_HANDLED; 180 } 181 182 static void exynos_pcie_enable_irq_pulse(struct exynos_pcie *ep) 183 { 184 u32 val = IRQ_INTA_ASSERT | IRQ_INTB_ASSERT | 185 IRQ_INTC_ASSERT | IRQ_INTD_ASSERT; 186 187 exynos_pcie_writel(ep->elbi_base, val, PCIE_IRQ_EN_PULSE); 188 exynos_pcie_writel(ep->elbi_base, 0, PCIE_IRQ_EN_LEVEL); 189 exynos_pcie_writel(ep->elbi_base, 0, PCIE_IRQ_EN_SPECIAL); 190 } 191 192 static u32 exynos_pcie_read_dbi(struct dw_pcie *pci, void __iomem *base, 193 u32 reg, size_t size) 194 { 195 struct exynos_pcie *ep = to_exynos_pcie(pci); 196 u32 val; 197 198 exynos_pcie_sideband_dbi_r_mode(ep, true); 199 dw_pcie_read(base + reg, size, &val); 200 exynos_pcie_sideband_dbi_r_mode(ep, false); 201 return val; 202 } 203 204 static void exynos_pcie_write_dbi(struct dw_pcie *pci, void __iomem *base, 205 u32 reg, size_t size, u32 val) 206 { 207 struct exynos_pcie *ep = to_exynos_pcie(pci); 208 209 exynos_pcie_sideband_dbi_w_mode(ep, true); 210 dw_pcie_write(base + reg, size, val); 211 exynos_pcie_sideband_dbi_w_mode(ep, false); 212 } 213 214 static int exynos_pcie_rd_own_conf(struct pci_bus *bus, unsigned int devfn, 215 int where, int size, u32 *val) 216 { 217 struct dw_pcie *pci = to_dw_pcie_from_pp(bus->sysdata); 218 219 if (PCI_SLOT(devfn)) { 220 *val = ~0; 221 return PCIBIOS_DEVICE_NOT_FOUND; 222 } 223 224 *val = dw_pcie_read_dbi(pci, where, size); 225 return PCIBIOS_SUCCESSFUL; 226 } 227 228 static int exynos_pcie_wr_own_conf(struct pci_bus *bus, unsigned int devfn, 229 int where, int size, u32 val) 230 { 231 struct dw_pcie *pci = to_dw_pcie_from_pp(bus->sysdata); 232 233 if (PCI_SLOT(devfn)) 234 return PCIBIOS_DEVICE_NOT_FOUND; 235 236 dw_pcie_write_dbi(pci, where, size, val); 237 return PCIBIOS_SUCCESSFUL; 238 } 239 240 static struct pci_ops exynos_pci_ops = { 241 .read = exynos_pcie_rd_own_conf, 242 .write = exynos_pcie_wr_own_conf, 243 }; 244 245 static int exynos_pcie_link_up(struct dw_pcie *pci) 246 { 247 struct exynos_pcie *ep = to_exynos_pcie(pci); 248 u32 val = exynos_pcie_readl(ep->elbi_base, PCIE_ELBI_RDLH_LINKUP); 249 250 return (val & PCIE_ELBI_XMLH_LINKUP); 251 } 252 253 static int exynos_pcie_host_init(struct pcie_port *pp) 254 { 255 struct dw_pcie *pci = to_dw_pcie_from_pp(pp); 256 struct exynos_pcie *ep = to_exynos_pcie(pci); 257 258 pp->bridge->ops = &exynos_pci_ops; 259 260 exynos_pcie_assert_core_reset(ep); 261 262 phy_reset(ep->phy); 263 phy_power_on(ep->phy); 264 phy_init(ep->phy); 265 266 exynos_pcie_deassert_core_reset(ep); 267 exynos_pcie_enable_irq_pulse(ep); 268 269 return 0; 270 } 271 272 static const struct dw_pcie_host_ops exynos_pcie_host_ops = { 273 .host_init = exynos_pcie_host_init, 274 }; 275 276 static int exynos_add_pcie_port(struct exynos_pcie *ep, 277 struct platform_device *pdev) 278 { 279 struct dw_pcie *pci = &ep->pci; 280 struct pcie_port *pp = &pci->pp; 281 struct device *dev = &pdev->dev; 282 int ret; 283 284 pp->irq = platform_get_irq(pdev, 0); 285 if (pp->irq < 0) 286 return pp->irq; 287 288 ret = devm_request_irq(dev, pp->irq, exynos_pcie_irq_handler, 289 IRQF_SHARED, "exynos-pcie", ep); 290 if (ret) { 291 dev_err(dev, "failed to request irq\n"); 292 return ret; 293 } 294 295 pp->ops = &exynos_pcie_host_ops; 296 pp->msi_irq = -ENODEV; 297 298 ret = dw_pcie_host_init(pp); 299 if (ret) { 300 dev_err(dev, "failed to initialize host\n"); 301 return ret; 302 } 303 304 return 0; 305 } 306 307 static const struct dw_pcie_ops dw_pcie_ops = { 308 .read_dbi = exynos_pcie_read_dbi, 309 .write_dbi = exynos_pcie_write_dbi, 310 .link_up = exynos_pcie_link_up, 311 .start_link = exynos_pcie_start_link, 312 }; 313 314 static int exynos_pcie_probe(struct platform_device *pdev) 315 { 316 struct device *dev = &pdev->dev; 317 struct exynos_pcie *ep; 318 struct device_node *np = dev->of_node; 319 int ret; 320 321 ep = devm_kzalloc(dev, sizeof(*ep), GFP_KERNEL); 322 if (!ep) 323 return -ENOMEM; 324 325 ep->pci.dev = dev; 326 ep->pci.ops = &dw_pcie_ops; 327 328 ep->phy = devm_of_phy_get(dev, np, NULL); 329 if (IS_ERR(ep->phy)) 330 return PTR_ERR(ep->phy); 331 332 /* External Local Bus interface (ELBI) registers */ 333 ep->elbi_base = devm_platform_ioremap_resource_byname(pdev, "elbi"); 334 if (IS_ERR(ep->elbi_base)) 335 return PTR_ERR(ep->elbi_base); 336 337 ep->clk = devm_clk_get(dev, "pcie"); 338 if (IS_ERR(ep->clk)) { 339 dev_err(dev, "Failed to get pcie rc clock\n"); 340 return PTR_ERR(ep->clk); 341 } 342 343 ep->bus_clk = devm_clk_get(dev, "pcie_bus"); 344 if (IS_ERR(ep->bus_clk)) { 345 dev_err(dev, "Failed to get pcie bus clock\n"); 346 return PTR_ERR(ep->bus_clk); 347 } 348 349 ep->supplies[0].supply = "vdd18"; 350 ep->supplies[1].supply = "vdd10"; 351 ret = devm_regulator_bulk_get(dev, ARRAY_SIZE(ep->supplies), 352 ep->supplies); 353 if (ret) 354 return ret; 355 356 ret = exynos_pcie_init_clk_resources(ep); 357 if (ret) 358 return ret; 359 360 ret = regulator_bulk_enable(ARRAY_SIZE(ep->supplies), ep->supplies); 361 if (ret) 362 return ret; 363 364 platform_set_drvdata(pdev, ep); 365 366 ret = exynos_add_pcie_port(ep, pdev); 367 if (ret < 0) 368 goto fail_probe; 369 370 return 0; 371 372 fail_probe: 373 phy_exit(ep->phy); 374 exynos_pcie_deinit_clk_resources(ep); 375 regulator_bulk_disable(ARRAY_SIZE(ep->supplies), ep->supplies); 376 377 return ret; 378 } 379 380 static int __exit exynos_pcie_remove(struct platform_device *pdev) 381 { 382 struct exynos_pcie *ep = platform_get_drvdata(pdev); 383 384 dw_pcie_host_deinit(&ep->pci.pp); 385 exynos_pcie_assert_core_reset(ep); 386 phy_power_off(ep->phy); 387 phy_exit(ep->phy); 388 exynos_pcie_deinit_clk_resources(ep); 389 regulator_bulk_disable(ARRAY_SIZE(ep->supplies), ep->supplies); 390 391 return 0; 392 } 393 394 static int __maybe_unused exynos_pcie_suspend_noirq(struct device *dev) 395 { 396 struct exynos_pcie *ep = dev_get_drvdata(dev); 397 398 exynos_pcie_assert_core_reset(ep); 399 phy_power_off(ep->phy); 400 phy_exit(ep->phy); 401 regulator_bulk_disable(ARRAY_SIZE(ep->supplies), ep->supplies); 402 403 return 0; 404 } 405 406 static int __maybe_unused exynos_pcie_resume_noirq(struct device *dev) 407 { 408 struct exynos_pcie *ep = dev_get_drvdata(dev); 409 struct dw_pcie *pci = &ep->pci; 410 struct pcie_port *pp = &pci->pp; 411 int ret; 412 413 ret = regulator_bulk_enable(ARRAY_SIZE(ep->supplies), ep->supplies); 414 if (ret) 415 return ret; 416 417 /* exynos_pcie_host_init controls ep->phy */ 418 exynos_pcie_host_init(pp); 419 dw_pcie_setup_rc(pp); 420 exynos_pcie_start_link(pci); 421 return dw_pcie_wait_for_link(pci); 422 } 423 424 static const struct dev_pm_ops exynos_pcie_pm_ops = { 425 SET_NOIRQ_SYSTEM_SLEEP_PM_OPS(exynos_pcie_suspend_noirq, 426 exynos_pcie_resume_noirq) 427 }; 428 429 static const struct of_device_id exynos_pcie_of_match[] = { 430 { .compatible = "samsung,exynos5433-pcie", }, 431 { }, 432 }; 433 434 static struct platform_driver exynos_pcie_driver = { 435 .probe = exynos_pcie_probe, 436 .remove = __exit_p(exynos_pcie_remove), 437 .driver = { 438 .name = "exynos-pcie", 439 .of_match_table = exynos_pcie_of_match, 440 .pm = &exynos_pcie_pm_ops, 441 }, 442 }; 443 module_platform_driver(exynos_pcie_driver); 444 MODULE_LICENSE("GPL v2"); 445 MODULE_DEVICE_TABLE(of, exynos_pcie_of_match); 446