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->crgctrl = 161 syscon_regmap_lookup_by_compatible("hisilicon,hi3660-crgctrl"); 162 if (IS_ERR(kirin_pcie->crgctrl)) 163 return PTR_ERR(kirin_pcie->crgctrl); 164 165 kirin_pcie->sysctrl = 166 syscon_regmap_lookup_by_compatible("hisilicon,hi3660-sctrl"); 167 if (IS_ERR(kirin_pcie->sysctrl)) 168 return PTR_ERR(kirin_pcie->sysctrl); 169 170 return 0; 171 } 172 173 static int kirin_pcie_phy_init(struct kirin_pcie *kirin_pcie) 174 { 175 struct device *dev = kirin_pcie->pci->dev; 176 u32 reg_val; 177 178 reg_val = kirin_apb_phy_readl(kirin_pcie, PCIE_APB_PHY_CTRL1); 179 reg_val &= ~PHY_REF_PAD_BIT; 180 kirin_apb_phy_writel(kirin_pcie, reg_val, PCIE_APB_PHY_CTRL1); 181 182 reg_val = kirin_apb_phy_readl(kirin_pcie, PCIE_APB_PHY_CTRL0); 183 reg_val &= ~PHY_PWR_DOWN_BIT; 184 kirin_apb_phy_writel(kirin_pcie, reg_val, PCIE_APB_PHY_CTRL0); 185 usleep_range(TIME_PHY_PD_MIN, TIME_PHY_PD_MAX); 186 187 reg_val = kirin_apb_phy_readl(kirin_pcie, PCIE_APB_PHY_CTRL1); 188 reg_val &= ~PHY_RST_ACK_BIT; 189 kirin_apb_phy_writel(kirin_pcie, reg_val, PCIE_APB_PHY_CTRL1); 190 191 usleep_range(PIPE_CLK_WAIT_MIN, PIPE_CLK_WAIT_MAX); 192 reg_val = kirin_apb_phy_readl(kirin_pcie, PCIE_APB_PHY_STATUS0); 193 if (reg_val & PIPE_CLK_STABLE) { 194 dev_err(dev, "PIPE clk is not stable\n"); 195 return -EINVAL; 196 } 197 198 return 0; 199 } 200 201 static void kirin_pcie_oe_enable(struct kirin_pcie *kirin_pcie) 202 { 203 u32 val; 204 205 regmap_read(kirin_pcie->sysctrl, SCTRL_PCIE_OE_OFFSET, &val); 206 val |= PCIE_DEBOUNCE_PARAM; 207 val &= ~PCIE_OE_BYPASS; 208 regmap_write(kirin_pcie->sysctrl, SCTRL_PCIE_OE_OFFSET, val); 209 } 210 211 static int kirin_pcie_clk_ctrl(struct kirin_pcie *kirin_pcie, bool enable) 212 { 213 int ret = 0; 214 215 if (!enable) 216 goto close_clk; 217 218 ret = clk_set_rate(kirin_pcie->phy_ref_clk, REF_CLK_FREQ); 219 if (ret) 220 return ret; 221 222 ret = clk_prepare_enable(kirin_pcie->phy_ref_clk); 223 if (ret) 224 return ret; 225 226 ret = clk_prepare_enable(kirin_pcie->apb_sys_clk); 227 if (ret) 228 goto apb_sys_fail; 229 230 ret = clk_prepare_enable(kirin_pcie->apb_phy_clk); 231 if (ret) 232 goto apb_phy_fail; 233 234 ret = clk_prepare_enable(kirin_pcie->pcie_aclk); 235 if (ret) 236 goto aclk_fail; 237 238 ret = clk_prepare_enable(kirin_pcie->pcie_aux_clk); 239 if (ret) 240 goto aux_clk_fail; 241 242 return 0; 243 244 close_clk: 245 clk_disable_unprepare(kirin_pcie->pcie_aux_clk); 246 aux_clk_fail: 247 clk_disable_unprepare(kirin_pcie->pcie_aclk); 248 aclk_fail: 249 clk_disable_unprepare(kirin_pcie->apb_phy_clk); 250 apb_phy_fail: 251 clk_disable_unprepare(kirin_pcie->apb_sys_clk); 252 apb_sys_fail: 253 clk_disable_unprepare(kirin_pcie->phy_ref_clk); 254 255 return ret; 256 } 257 258 static int kirin_pcie_power_on(struct kirin_pcie *kirin_pcie) 259 { 260 int ret; 261 262 /* Power supply for Host */ 263 regmap_write(kirin_pcie->sysctrl, 264 SCTRL_PCIE_CMOS_OFFSET, SCTRL_PCIE_CMOS_BIT); 265 usleep_range(TIME_CMOS_MIN, TIME_CMOS_MAX); 266 kirin_pcie_oe_enable(kirin_pcie); 267 268 ret = kirin_pcie_clk_ctrl(kirin_pcie, true); 269 if (ret) 270 return ret; 271 272 /* ISO disable, PCIeCtrl, PHY assert and clk gate clear */ 273 regmap_write(kirin_pcie->sysctrl, 274 SCTRL_PCIE_ISO_OFFSET, SCTRL_PCIE_ISO_BIT); 275 regmap_write(kirin_pcie->crgctrl, 276 CRGCTRL_PCIE_ASSERT_OFFSET, CRGCTRL_PCIE_ASSERT_BIT); 277 regmap_write(kirin_pcie->sysctrl, 278 SCTRL_PCIE_HPCLK_OFFSET, SCTRL_PCIE_HPCLK_BIT); 279 280 ret = kirin_pcie_phy_init(kirin_pcie); 281 if (ret) 282 goto close_clk; 283 284 /* perst assert Endpoint */ 285 if (!gpio_request(kirin_pcie->gpio_id_reset, "pcie_perst")) { 286 usleep_range(REF_2_PERST_MIN, REF_2_PERST_MAX); 287 ret = gpio_direction_output(kirin_pcie->gpio_id_reset, 1); 288 if (ret) 289 goto close_clk; 290 usleep_range(PERST_2_ACCESS_MIN, PERST_2_ACCESS_MAX); 291 292 return 0; 293 } 294 295 close_clk: 296 kirin_pcie_clk_ctrl(kirin_pcie, false); 297 return ret; 298 } 299 300 static void kirin_pcie_sideband_dbi_w_mode(struct kirin_pcie *kirin_pcie, 301 bool on) 302 { 303 u32 val; 304 305 val = kirin_apb_ctrl_readl(kirin_pcie, SOC_PCIECTRL_CTRL0_ADDR); 306 if (on) 307 val = val | PCIE_ELBI_SLV_DBI_ENABLE; 308 else 309 val = val & ~PCIE_ELBI_SLV_DBI_ENABLE; 310 311 kirin_apb_ctrl_writel(kirin_pcie, val, SOC_PCIECTRL_CTRL0_ADDR); 312 } 313 314 static void kirin_pcie_sideband_dbi_r_mode(struct kirin_pcie *kirin_pcie, 315 bool on) 316 { 317 u32 val; 318 319 val = kirin_apb_ctrl_readl(kirin_pcie, SOC_PCIECTRL_CTRL1_ADDR); 320 if (on) 321 val = val | PCIE_ELBI_SLV_DBI_ENABLE; 322 else 323 val = val & ~PCIE_ELBI_SLV_DBI_ENABLE; 324 325 kirin_apb_ctrl_writel(kirin_pcie, val, SOC_PCIECTRL_CTRL1_ADDR); 326 } 327 328 static int kirin_pcie_rd_own_conf(struct pci_bus *bus, unsigned int devfn, 329 int where, int size, u32 *val) 330 { 331 struct dw_pcie *pci = to_dw_pcie_from_pp(bus->sysdata); 332 333 if (PCI_SLOT(devfn)) { 334 *val = ~0; 335 return PCIBIOS_DEVICE_NOT_FOUND; 336 } 337 338 *val = dw_pcie_read_dbi(pci, where, size); 339 return PCIBIOS_SUCCESSFUL; 340 } 341 342 static int kirin_pcie_wr_own_conf(struct pci_bus *bus, unsigned int devfn, 343 int where, int size, u32 val) 344 { 345 struct dw_pcie *pci = to_dw_pcie_from_pp(bus->sysdata); 346 347 if (PCI_SLOT(devfn)) 348 return PCIBIOS_DEVICE_NOT_FOUND; 349 350 dw_pcie_write_dbi(pci, where, size, val); 351 return PCIBIOS_SUCCESSFUL; 352 } 353 354 static struct pci_ops kirin_pci_ops = { 355 .read = kirin_pcie_rd_own_conf, 356 .write = kirin_pcie_wr_own_conf, 357 }; 358 359 static u32 kirin_pcie_read_dbi(struct dw_pcie *pci, void __iomem *base, 360 u32 reg, size_t size) 361 { 362 struct kirin_pcie *kirin_pcie = to_kirin_pcie(pci); 363 u32 ret; 364 365 kirin_pcie_sideband_dbi_r_mode(kirin_pcie, true); 366 dw_pcie_read(base + reg, size, &ret); 367 kirin_pcie_sideband_dbi_r_mode(kirin_pcie, false); 368 369 return ret; 370 } 371 372 static void kirin_pcie_write_dbi(struct dw_pcie *pci, void __iomem *base, 373 u32 reg, size_t size, u32 val) 374 { 375 struct kirin_pcie *kirin_pcie = to_kirin_pcie(pci); 376 377 kirin_pcie_sideband_dbi_w_mode(kirin_pcie, true); 378 dw_pcie_write(base + reg, size, val); 379 kirin_pcie_sideband_dbi_w_mode(kirin_pcie, false); 380 } 381 382 static int kirin_pcie_link_up(struct dw_pcie *pci) 383 { 384 struct kirin_pcie *kirin_pcie = to_kirin_pcie(pci); 385 u32 val = kirin_apb_ctrl_readl(kirin_pcie, PCIE_APB_PHY_STATUS0); 386 387 if ((val & PCIE_LINKUP_ENABLE) == PCIE_LINKUP_ENABLE) 388 return 1; 389 390 return 0; 391 } 392 393 static int kirin_pcie_start_link(struct dw_pcie *pci) 394 { 395 struct kirin_pcie *kirin_pcie = to_kirin_pcie(pci); 396 397 /* assert LTSSM enable */ 398 kirin_apb_ctrl_writel(kirin_pcie, PCIE_LTSSM_ENABLE_BIT, 399 PCIE_APP_LTSSM_ENABLE); 400 401 return 0; 402 } 403 404 static int kirin_pcie_host_init(struct pcie_port *pp) 405 { 406 pp->bridge->ops = &kirin_pci_ops; 407 408 return 0; 409 } 410 411 static const struct dw_pcie_ops kirin_dw_pcie_ops = { 412 .read_dbi = kirin_pcie_read_dbi, 413 .write_dbi = kirin_pcie_write_dbi, 414 .link_up = kirin_pcie_link_up, 415 .start_link = kirin_pcie_start_link, 416 }; 417 418 static const struct dw_pcie_host_ops kirin_pcie_host_ops = { 419 .host_init = kirin_pcie_host_init, 420 }; 421 422 static int kirin_pcie_probe(struct platform_device *pdev) 423 { 424 struct device *dev = &pdev->dev; 425 struct kirin_pcie *kirin_pcie; 426 struct dw_pcie *pci; 427 int ret; 428 429 if (!dev->of_node) { 430 dev_err(dev, "NULL node\n"); 431 return -EINVAL; 432 } 433 434 kirin_pcie = devm_kzalloc(dev, sizeof(struct kirin_pcie), GFP_KERNEL); 435 if (!kirin_pcie) 436 return -ENOMEM; 437 438 pci = devm_kzalloc(dev, sizeof(*pci), GFP_KERNEL); 439 if (!pci) 440 return -ENOMEM; 441 442 pci->dev = dev; 443 pci->ops = &kirin_dw_pcie_ops; 444 pci->pp.ops = &kirin_pcie_host_ops; 445 kirin_pcie->pci = pci; 446 447 ret = kirin_pcie_get_clk(kirin_pcie, pdev); 448 if (ret) 449 return ret; 450 451 ret = kirin_pcie_get_resource(kirin_pcie, pdev); 452 if (ret) 453 return ret; 454 455 kirin_pcie->gpio_id_reset = of_get_named_gpio(dev->of_node, 456 "reset-gpios", 0); 457 if (kirin_pcie->gpio_id_reset == -EPROBE_DEFER) { 458 return -EPROBE_DEFER; 459 } else if (!gpio_is_valid(kirin_pcie->gpio_id_reset)) { 460 dev_err(dev, "unable to get a valid gpio pin\n"); 461 return -ENODEV; 462 } 463 464 ret = kirin_pcie_power_on(kirin_pcie); 465 if (ret) 466 return ret; 467 468 platform_set_drvdata(pdev, kirin_pcie); 469 470 return dw_pcie_host_init(&pci->pp); 471 } 472 473 static const struct of_device_id kirin_pcie_match[] = { 474 { .compatible = "hisilicon,kirin960-pcie" }, 475 {}, 476 }; 477 478 static struct platform_driver kirin_pcie_driver = { 479 .probe = kirin_pcie_probe, 480 .driver = { 481 .name = "kirin-pcie", 482 .of_match_table = kirin_pcie_match, 483 .suppress_bind_attrs = true, 484 }, 485 }; 486 builtin_platform_driver(kirin_pcie_driver); 487