drivers/pci/controller/dwc/pcie-kirin.c

   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_add_pcie_port(struct dw_pcie *pci,
 423                                struct platform_device *pdev)
 424 {
 425         pci->pp.ops = &kirin_pcie_host_ops;
 426
 427         return dw_pcie_host_init(&pci->pp);
 428 }
 429
 430 static int kirin_pcie_probe(struct platform_device *pdev)
 431 {
 432         struct device *dev = &pdev->dev;
 433         struct kirin_pcie *kirin_pcie;
 434         struct dw_pcie *pci;
 435         int ret;
 436
 437         if (!dev->of_node) {
 438                 dev_err(dev, "NULL node\n");
 439                 return -EINVAL;
 440         }
 441
 442         kirin_pcie = devm_kzalloc(dev, sizeof(struct kirin_pcie), GFP_KERNEL);
 443         if (!kirin_pcie)
 444                 return -ENOMEM;
 445
 446         pci = devm_kzalloc(dev, sizeof(*pci), GFP_KERNEL);
 447         if (!pci)
 448                 return -ENOMEM;
 449
 450         pci->dev = dev;
 451         pci->ops = &kirin_dw_pcie_ops;
 452         kirin_pcie->pci = pci;
 453
 454         ret = kirin_pcie_get_clk(kirin_pcie, pdev);
 455         if (ret)
 456                 return ret;
 457
 458         ret = kirin_pcie_get_resource(kirin_pcie, pdev);
 459         if (ret)
 460                 return ret;
 461
 462         kirin_pcie->gpio_id_reset = of_get_named_gpio(dev->of_node,
 463                                                       "reset-gpios", 0);
 464         if (kirin_pcie->gpio_id_reset == -EPROBE_DEFER) {
 465                 return -EPROBE_DEFER;
 466         } else if (!gpio_is_valid(kirin_pcie->gpio_id_reset)) {
 467                 dev_err(dev, "unable to get a valid gpio pin\n");
 468                 return -ENODEV;
 469         }
 470
 471         ret = kirin_pcie_power_on(kirin_pcie);
 472         if (ret)
 473                 return ret;
 474
 475         platform_set_drvdata(pdev, kirin_pcie);
 476
 477         return kirin_add_pcie_port(pci, pdev);
 478 }
 479
 480 static const struct of_device_id kirin_pcie_match[] = {
 481         { .compatible = "hisilicon,kirin960-pcie" },
 482         {},
 483 };
 484
 485 static struct platform_driver kirin_pcie_driver = {
 486         .probe                  = kirin_pcie_probe,
 487         .driver                 = {
 488                 .name                   = "kirin-pcie",
 489                 .of_match_table = kirin_pcie_match,
 490                 .suppress_bind_attrs = true,
 491         },
 492 };
 493 builtin_platform_driver(kirin_pcie_driver);