1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * PCIe host controller driver for Kirin Phone SoCs 4 * 5 * Copyright (C) 2017 HiSilicon Electronics Co., Ltd. 6 * https://www.huawei.com 7 * 8 * Author: Xiaowei Song <songxiaowei@huawei.com> 9 */ 10 11 #include <linux/compiler.h> 12 #include <linux/clk.h> 13 #include <linux/delay.h> 14 #include <linux/err.h> 15 #include <linux/gpio.h> 16 #include <linux/interrupt.h> 17 #include <linux/mfd/syscon.h> 18 #include <linux/of_address.h> 19 #include <linux/of_gpio.h> 20 #include <linux/of_pci.h> 21 #include <linux/pci.h> 22 #include <linux/pci_regs.h> 23 #include <linux/platform_device.h> 24 #include <linux/regmap.h> 25 #include <linux/resource.h> 26 #include <linux/types.h> 27 #include "pcie-designware.h" 28 29 #define to_kirin_pcie(x) dev_get_drvdata((x)->dev) 30 31 #define REF_CLK_FREQ 100000000 32 33 /* PCIe ELBI registers */ 34 #define SOC_PCIECTRL_CTRL0_ADDR 0x000 35 #define SOC_PCIECTRL_CTRL1_ADDR 0x004 36 #define SOC_PCIEPHY_CTRL2_ADDR 0x008 37 #define SOC_PCIEPHY_CTRL3_ADDR 0x00c 38 #define PCIE_ELBI_SLV_DBI_ENABLE (0x1 << 21) 39 40 /* info located in APB */ 41 #define PCIE_APP_LTSSM_ENABLE 0x01c 42 #define PCIE_APB_PHY_CTRL0 0x0 43 #define PCIE_APB_PHY_CTRL1 0x4 44 #define PCIE_APB_PHY_STATUS0 0x400 45 #define PCIE_LINKUP_ENABLE (0x8020) 46 #define PCIE_LTSSM_ENABLE_BIT (0x1 << 11) 47 #define PIPE_CLK_STABLE (0x1 << 19) 48 #define PHY_REF_PAD_BIT (0x1 << 8) 49 #define PHY_PWR_DOWN_BIT (0x1 << 22) 50 #define PHY_RST_ACK_BIT (0x1 << 16) 51 52 /* info located in sysctrl */ 53 #define SCTRL_PCIE_CMOS_OFFSET 0x60 54 #define SCTRL_PCIE_CMOS_BIT 0x10 55 #define SCTRL_PCIE_ISO_OFFSET 0x44 56 #define SCTRL_PCIE_ISO_BIT 0x30 57 #define SCTRL_PCIE_HPCLK_OFFSET 0x190 58 #define SCTRL_PCIE_HPCLK_BIT 0x184000 59 #define SCTRL_PCIE_OE_OFFSET 0x14a 60 #define PCIE_DEBOUNCE_PARAM 0xF0F400 61 #define PCIE_OE_BYPASS (0x3 << 28) 62 63 /* peri_crg ctrl */ 64 #define CRGCTRL_PCIE_ASSERT_OFFSET 0x88 65 #define CRGCTRL_PCIE_ASSERT_BIT 0x8c000000 66 67 /* Time for delay */ 68 #define REF_2_PERST_MIN 20000 69 #define REF_2_PERST_MAX 25000 70 #define PERST_2_ACCESS_MIN 10000 71 #define PERST_2_ACCESS_MAX 12000 72 #define LINK_WAIT_MIN 900 73 #define LINK_WAIT_MAX 1000 74 #define PIPE_CLK_WAIT_MIN 550 75 #define PIPE_CLK_WAIT_MAX 600 76 #define TIME_CMOS_MIN 100 77 #define TIME_CMOS_MAX 105 78 #define TIME_PHY_PD_MIN 10 79 #define TIME_PHY_PD_MAX 11 80 81 struct kirin_pcie { 82 struct dw_pcie *pci; 83 void __iomem *apb_base; 84 void __iomem *phy_base; 85 struct regmap *crgctrl; 86 struct regmap *sysctrl; 87 struct clk *apb_sys_clk; 88 struct clk *apb_phy_clk; 89 struct clk *phy_ref_clk; 90 struct clk *pcie_aclk; 91 struct clk *pcie_aux_clk; 92 int gpio_id_reset; 93 }; 94 95 /* Registers in PCIeCTRL */ 96 static inline void kirin_apb_ctrl_writel(struct kirin_pcie *kirin_pcie, 97 u32 val, u32 reg) 98 { 99 writel(val, kirin_pcie->apb_base + reg); 100 } 101 102 static inline u32 kirin_apb_ctrl_readl(struct kirin_pcie *kirin_pcie, u32 reg) 103 { 104 return readl(kirin_pcie->apb_base + reg); 105 } 106 107 /* Registers in PCIePHY */ 108 static inline void kirin_apb_phy_writel(struct kirin_pcie *kirin_pcie, 109 u32 val, u32 reg) 110 { 111 writel(val, kirin_pcie->phy_base + reg); 112 } 113 114 static inline u32 kirin_apb_phy_readl(struct kirin_pcie *kirin_pcie, u32 reg) 115 { 116 return readl(kirin_pcie->phy_base + reg); 117 } 118 119 static long kirin_pcie_get_clk(struct kirin_pcie *kirin_pcie, 120 struct platform_device *pdev) 121 { 122 struct device *dev = &pdev->dev; 123 124 kirin_pcie->phy_ref_clk = devm_clk_get(dev, "pcie_phy_ref"); 125 if (IS_ERR(kirin_pcie->phy_ref_clk)) 126 return PTR_ERR(kirin_pcie->phy_ref_clk); 127 128 kirin_pcie->pcie_aux_clk = devm_clk_get(dev, "pcie_aux"); 129 if (IS_ERR(kirin_pcie->pcie_aux_clk)) 130 return PTR_ERR(kirin_pcie->pcie_aux_clk); 131 132 kirin_pcie->apb_phy_clk = devm_clk_get(dev, "pcie_apb_phy"); 133 if (IS_ERR(kirin_pcie->apb_phy_clk)) 134 return PTR_ERR(kirin_pcie->apb_phy_clk); 135 136 kirin_pcie->apb_sys_clk = devm_clk_get(dev, "pcie_apb_sys"); 137 if (IS_ERR(kirin_pcie->apb_sys_clk)) 138 return PTR_ERR(kirin_pcie->apb_sys_clk); 139 140 kirin_pcie->pcie_aclk = devm_clk_get(dev, "pcie_aclk"); 141 if (IS_ERR(kirin_pcie->pcie_aclk)) 142 return PTR_ERR(kirin_pcie->pcie_aclk); 143 144 return 0; 145 } 146 147 static long kirin_pcie_get_resource(struct kirin_pcie *kirin_pcie, 148 struct platform_device *pdev) 149 { 150 kirin_pcie->apb_base = 151 devm_platform_ioremap_resource_byname(pdev, "apb"); 152 if (IS_ERR(kirin_pcie->apb_base)) 153 return PTR_ERR(kirin_pcie->apb_base); 154 155 kirin_pcie->phy_base = 156 devm_platform_ioremap_resource_byname(pdev, "phy"); 157 if (IS_ERR(kirin_pcie->phy_base)) 158 return PTR_ERR(kirin_pcie->phy_base); 159 160 kirin_pcie->pci->dbi_base = 161 devm_platform_ioremap_resource_byname(pdev, "dbi"); 162 if (IS_ERR(kirin_pcie->pci->dbi_base)) 163 return PTR_ERR(kirin_pcie->pci->dbi_base); 164 165 kirin_pcie->crgctrl = 166 syscon_regmap_lookup_by_compatible("hisilicon,hi3660-crgctrl"); 167 if (IS_ERR(kirin_pcie->crgctrl)) 168 return PTR_ERR(kirin_pcie->crgctrl); 169 170 kirin_pcie->sysctrl = 171 syscon_regmap_lookup_by_compatible("hisilicon,hi3660-sctrl"); 172 if (IS_ERR(kirin_pcie->sysctrl)) 173 return PTR_ERR(kirin_pcie->sysctrl); 174 175 return 0; 176 } 177 178 static int kirin_pcie_phy_init(struct kirin_pcie *kirin_pcie) 179 { 180 struct device *dev = kirin_pcie->pci->dev; 181 u32 reg_val; 182 183 reg_val = kirin_apb_phy_readl(kirin_pcie, PCIE_APB_PHY_CTRL1); 184 reg_val &= ~PHY_REF_PAD_BIT; 185 kirin_apb_phy_writel(kirin_pcie, reg_val, PCIE_APB_PHY_CTRL1); 186 187 reg_val = kirin_apb_phy_readl(kirin_pcie, PCIE_APB_PHY_CTRL0); 188 reg_val &= ~PHY_PWR_DOWN_BIT; 189 kirin_apb_phy_writel(kirin_pcie, reg_val, PCIE_APB_PHY_CTRL0); 190 usleep_range(TIME_PHY_PD_MIN, TIME_PHY_PD_MAX); 191 192 reg_val = kirin_apb_phy_readl(kirin_pcie, PCIE_APB_PHY_CTRL1); 193 reg_val &= ~PHY_RST_ACK_BIT; 194 kirin_apb_phy_writel(kirin_pcie, reg_val, PCIE_APB_PHY_CTRL1); 195 196 usleep_range(PIPE_CLK_WAIT_MIN, PIPE_CLK_WAIT_MAX); 197 reg_val = kirin_apb_phy_readl(kirin_pcie, PCIE_APB_PHY_STATUS0); 198 if (reg_val & PIPE_CLK_STABLE) { 199 dev_err(dev, "PIPE clk is not stable\n"); 200 return -EINVAL; 201 } 202 203 return 0; 204 } 205 206 static void kirin_pcie_oe_enable(struct kirin_pcie *kirin_pcie) 207 { 208 u32 val; 209 210 regmap_read(kirin_pcie->sysctrl, SCTRL_PCIE_OE_OFFSET, &val); 211 val |= PCIE_DEBOUNCE_PARAM; 212 val &= ~PCIE_OE_BYPASS; 213 regmap_write(kirin_pcie->sysctrl, SCTRL_PCIE_OE_OFFSET, val); 214 } 215 216 static int kirin_pcie_clk_ctrl(struct kirin_pcie *kirin_pcie, bool enable) 217 { 218 int ret = 0; 219 220 if (!enable) 221 goto close_clk; 222 223 ret = clk_set_rate(kirin_pcie->phy_ref_clk, REF_CLK_FREQ); 224 if (ret) 225 return ret; 226 227 ret = clk_prepare_enable(kirin_pcie->phy_ref_clk); 228 if (ret) 229 return ret; 230 231 ret = clk_prepare_enable(kirin_pcie->apb_sys_clk); 232 if (ret) 233 goto apb_sys_fail; 234 235 ret = clk_prepare_enable(kirin_pcie->apb_phy_clk); 236 if (ret) 237 goto apb_phy_fail; 238 239 ret = clk_prepare_enable(kirin_pcie->pcie_aclk); 240 if (ret) 241 goto aclk_fail; 242 243 ret = clk_prepare_enable(kirin_pcie->pcie_aux_clk); 244 if (ret) 245 goto aux_clk_fail; 246 247 return 0; 248 249 close_clk: 250 clk_disable_unprepare(kirin_pcie->pcie_aux_clk); 251 aux_clk_fail: 252 clk_disable_unprepare(kirin_pcie->pcie_aclk); 253 aclk_fail: 254 clk_disable_unprepare(kirin_pcie->apb_phy_clk); 255 apb_phy_fail: 256 clk_disable_unprepare(kirin_pcie->apb_sys_clk); 257 apb_sys_fail: 258 clk_disable_unprepare(kirin_pcie->phy_ref_clk); 259 260 return ret; 261 } 262 263 static int kirin_pcie_power_on(struct kirin_pcie *kirin_pcie) 264 { 265 int ret; 266 267 /* Power supply for Host */ 268 regmap_write(kirin_pcie->sysctrl, 269 SCTRL_PCIE_CMOS_OFFSET, SCTRL_PCIE_CMOS_BIT); 270 usleep_range(TIME_CMOS_MIN, TIME_CMOS_MAX); 271 kirin_pcie_oe_enable(kirin_pcie); 272 273 ret = kirin_pcie_clk_ctrl(kirin_pcie, true); 274 if (ret) 275 return ret; 276 277 /* ISO disable, PCIeCtrl, PHY assert and clk gate clear */ 278 regmap_write(kirin_pcie->sysctrl, 279 SCTRL_PCIE_ISO_OFFSET, SCTRL_PCIE_ISO_BIT); 280 regmap_write(kirin_pcie->crgctrl, 281 CRGCTRL_PCIE_ASSERT_OFFSET, CRGCTRL_PCIE_ASSERT_BIT); 282 regmap_write(kirin_pcie->sysctrl, 283 SCTRL_PCIE_HPCLK_OFFSET, SCTRL_PCIE_HPCLK_BIT); 284 285 ret = kirin_pcie_phy_init(kirin_pcie); 286 if (ret) 287 goto close_clk; 288 289 /* perst assert Endpoint */ 290 if (!gpio_request(kirin_pcie->gpio_id_reset, "pcie_perst")) { 291 usleep_range(REF_2_PERST_MIN, REF_2_PERST_MAX); 292 ret = gpio_direction_output(kirin_pcie->gpio_id_reset, 1); 293 if (ret) 294 goto close_clk; 295 usleep_range(PERST_2_ACCESS_MIN, PERST_2_ACCESS_MAX); 296 297 return 0; 298 } 299 300 close_clk: 301 kirin_pcie_clk_ctrl(kirin_pcie, false); 302 return ret; 303 } 304 305 static void kirin_pcie_sideband_dbi_w_mode(struct kirin_pcie *kirin_pcie, 306 bool on) 307 { 308 u32 val; 309 310 val = kirin_apb_ctrl_readl(kirin_pcie, SOC_PCIECTRL_CTRL0_ADDR); 311 if (on) 312 val = val | PCIE_ELBI_SLV_DBI_ENABLE; 313 else 314 val = val & ~PCIE_ELBI_SLV_DBI_ENABLE; 315 316 kirin_apb_ctrl_writel(kirin_pcie, val, SOC_PCIECTRL_CTRL0_ADDR); 317 } 318 319 static void kirin_pcie_sideband_dbi_r_mode(struct kirin_pcie *kirin_pcie, 320 bool on) 321 { 322 u32 val; 323 324 val = kirin_apb_ctrl_readl(kirin_pcie, SOC_PCIECTRL_CTRL1_ADDR); 325 if (on) 326 val = val | PCIE_ELBI_SLV_DBI_ENABLE; 327 else 328 val = val & ~PCIE_ELBI_SLV_DBI_ENABLE; 329 330 kirin_apb_ctrl_writel(kirin_pcie, val, SOC_PCIECTRL_CTRL1_ADDR); 331 } 332 333 static int kirin_pcie_rd_own_conf(struct pcie_port *pp, 334 int where, int size, u32 *val) 335 { 336 struct dw_pcie *pci = to_dw_pcie_from_pp(pp); 337 struct kirin_pcie *kirin_pcie = to_kirin_pcie(pci); 338 int ret; 339 340 kirin_pcie_sideband_dbi_r_mode(kirin_pcie, true); 341 ret = dw_pcie_read(pci->dbi_base + where, size, val); 342 kirin_pcie_sideband_dbi_r_mode(kirin_pcie, false); 343 344 return ret; 345 } 346 347 static int kirin_pcie_wr_own_conf(struct pcie_port *pp, 348 int where, int size, u32 val) 349 { 350 struct dw_pcie *pci = to_dw_pcie_from_pp(pp); 351 struct kirin_pcie *kirin_pcie = to_kirin_pcie(pci); 352 int ret; 353 354 kirin_pcie_sideband_dbi_w_mode(kirin_pcie, true); 355 ret = dw_pcie_write(pci->dbi_base + where, size, val); 356 kirin_pcie_sideband_dbi_w_mode(kirin_pcie, false); 357 358 return ret; 359 } 360 361 static u32 kirin_pcie_read_dbi(struct dw_pcie *pci, void __iomem *base, 362 u32 reg, size_t size) 363 { 364 struct kirin_pcie *kirin_pcie = to_kirin_pcie(pci); 365 u32 ret; 366 367 kirin_pcie_sideband_dbi_r_mode(kirin_pcie, true); 368 dw_pcie_read(base + reg, size, &ret); 369 kirin_pcie_sideband_dbi_r_mode(kirin_pcie, false); 370 371 return ret; 372 } 373 374 static void kirin_pcie_write_dbi(struct dw_pcie *pci, void __iomem *base, 375 u32 reg, size_t size, u32 val) 376 { 377 struct kirin_pcie *kirin_pcie = to_kirin_pcie(pci); 378 379 kirin_pcie_sideband_dbi_w_mode(kirin_pcie, true); 380 dw_pcie_write(base + reg, size, val); 381 kirin_pcie_sideband_dbi_w_mode(kirin_pcie, false); 382 } 383 384 static int kirin_pcie_link_up(struct dw_pcie *pci) 385 { 386 struct kirin_pcie *kirin_pcie = to_kirin_pcie(pci); 387 u32 val = kirin_apb_ctrl_readl(kirin_pcie, PCIE_APB_PHY_STATUS0); 388 389 if ((val & PCIE_LINKUP_ENABLE) == PCIE_LINKUP_ENABLE) 390 return 1; 391 392 return 0; 393 } 394 395 static int kirin_pcie_establish_link(struct pcie_port *pp) 396 { 397 struct dw_pcie *pci = to_dw_pcie_from_pp(pp); 398 struct kirin_pcie *kirin_pcie = to_kirin_pcie(pci); 399 struct device *dev = kirin_pcie->pci->dev; 400 int count = 0; 401 402 if (kirin_pcie_link_up(pci)) 403 return 0; 404 405 dw_pcie_setup_rc(pp); 406 407 /* assert LTSSM enable */ 408 kirin_apb_ctrl_writel(kirin_pcie, PCIE_LTSSM_ENABLE_BIT, 409 PCIE_APP_LTSSM_ENABLE); 410 411 /* check if the link is up or not */ 412 while (!kirin_pcie_link_up(pci)) { 413 usleep_range(LINK_WAIT_MIN, LINK_WAIT_MAX); 414 count++; 415 if (count == 1000) { 416 dev_err(dev, "Link Fail\n"); 417 return -EINVAL; 418 } 419 } 420 421 return 0; 422 } 423 424 static int kirin_pcie_host_init(struct pcie_port *pp) 425 { 426 kirin_pcie_establish_link(pp); 427 428 if (IS_ENABLED(CONFIG_PCI_MSI)) 429 dw_pcie_msi_init(pp); 430 431 return 0; 432 } 433 434 static const struct dw_pcie_ops kirin_dw_pcie_ops = { 435 .read_dbi = kirin_pcie_read_dbi, 436 .write_dbi = kirin_pcie_write_dbi, 437 .link_up = kirin_pcie_link_up, 438 }; 439 440 static const struct dw_pcie_host_ops kirin_pcie_host_ops = { 441 .rd_own_conf = kirin_pcie_rd_own_conf, 442 .wr_own_conf = kirin_pcie_wr_own_conf, 443 .host_init = kirin_pcie_host_init, 444 }; 445 446 static int kirin_pcie_add_msi(struct dw_pcie *pci, 447 struct platform_device *pdev) 448 { 449 int irq; 450 451 if (IS_ENABLED(CONFIG_PCI_MSI)) { 452 irq = platform_get_irq(pdev, 0); 453 if (irq < 0) 454 return irq; 455 456 pci->pp.msi_irq = irq; 457 } 458 459 return 0; 460 } 461 462 static int kirin_add_pcie_port(struct dw_pcie *pci, 463 struct platform_device *pdev) 464 { 465 int ret; 466 467 ret = kirin_pcie_add_msi(pci, pdev); 468 if (ret) 469 return ret; 470 471 pci->pp.ops = &kirin_pcie_host_ops; 472 473 return dw_pcie_host_init(&pci->pp); 474 } 475 476 static int kirin_pcie_probe(struct platform_device *pdev) 477 { 478 struct device *dev = &pdev->dev; 479 struct kirin_pcie *kirin_pcie; 480 struct dw_pcie *pci; 481 int ret; 482 483 if (!dev->of_node) { 484 dev_err(dev, "NULL node\n"); 485 return -EINVAL; 486 } 487 488 kirin_pcie = devm_kzalloc(dev, sizeof(struct kirin_pcie), GFP_KERNEL); 489 if (!kirin_pcie) 490 return -ENOMEM; 491 492 pci = devm_kzalloc(dev, sizeof(*pci), GFP_KERNEL); 493 if (!pci) 494 return -ENOMEM; 495 496 pci->dev = dev; 497 pci->ops = &kirin_dw_pcie_ops; 498 kirin_pcie->pci = pci; 499 500 ret = kirin_pcie_get_clk(kirin_pcie, pdev); 501 if (ret) 502 return ret; 503 504 ret = kirin_pcie_get_resource(kirin_pcie, pdev); 505 if (ret) 506 return ret; 507 508 kirin_pcie->gpio_id_reset = of_get_named_gpio(dev->of_node, 509 "reset-gpios", 0); 510 if (kirin_pcie->gpio_id_reset < 0) 511 return -ENODEV; 512 513 ret = kirin_pcie_power_on(kirin_pcie); 514 if (ret) 515 return ret; 516 517 platform_set_drvdata(pdev, kirin_pcie); 518 519 return kirin_add_pcie_port(pci, pdev); 520 } 521 522 static const struct of_device_id kirin_pcie_match[] = { 523 { .compatible = "hisilicon,kirin960-pcie" }, 524 {}, 525 }; 526 527 static struct platform_driver kirin_pcie_driver = { 528 .probe = kirin_pcie_probe, 529 .driver = { 530 .name = "kirin-pcie", 531 .of_match_table = kirin_pcie_match, 532 .suppress_bind_attrs = true, 533 }, 534 }; 535 builtin_platform_driver(kirin_pcie_driver); 536