drivers/pci/host/pci-imx6.c

   1 /*
   2  * PCIe host controller driver for Freescale i.MX6 SoCs
   3  *
   4  * Copyright (C) 2013 Kosagi
   5  *              http://www.kosagi.com
   6  *
   7  * Author: Sean Cross <xobs@kosagi.com>
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License version 2 as
  11  * published by the Free Software Foundation.
  12  */
  13
  14 #include <linux/clk.h>
  15 #include <linux/delay.h>
  16 #include <linux/gpio.h>
  17 #include <linux/kernel.h>
  18 #include <linux/mfd/syscon.h>
  19 #include <linux/mfd/syscon/imx6q-iomuxc-gpr.h>
  20 #include <linux/module.h>
  21 #include <linux/of_gpio.h>
  22 #include <linux/of_device.h>
  23 #include <linux/pci.h>
  24 #include <linux/platform_device.h>
  25 #include <linux/regmap.h>
  26 #include <linux/resource.h>
  27 #include <linux/signal.h>
  28 #include <linux/types.h>
  29 #include <linux/interrupt.h>
  30
  31 #include "pcie-designware.h"
  32
  33 #define to_imx6_pcie(x) container_of(x, struct imx6_pcie, pp)
  34
  35 enum imx6_pcie_variants {
  36         IMX6Q,
  37         IMX6SX,
  38         IMX6QP,
  39 };
  40
  41 struct imx6_pcie {
  42         struct pcie_port        pp;     /* pp.dbi_base is DT 0th resource */
  43         int                     reset_gpio;
  44         bool                    gpio_active_high;
  45         struct clk              *pcie_bus;
  46         struct clk              *pcie_phy;
  47         struct clk              *pcie_inbound_axi;
  48         struct clk              *pcie;
  49         struct regmap           *iomuxc_gpr;
  50         enum imx6_pcie_variants variant;
  51         u32                     tx_deemph_gen1;
  52         u32                     tx_deemph_gen2_3p5db;
  53         u32                     tx_deemph_gen2_6db;
  54         u32                     tx_swing_full;
  55         u32                     tx_swing_low;
  56         int                     link_gen;
  57 };
  58
  59 /* PCIe Root Complex registers (memory-mapped) */
  60 #define PCIE_RC_LCR                             0x7c
  61 #define PCIE_RC_LCR_MAX_LINK_SPEEDS_GEN1        0x1
  62 #define PCIE_RC_LCR_MAX_LINK_SPEEDS_GEN2        0x2
  63 #define PCIE_RC_LCR_MAX_LINK_SPEEDS_MASK        0xf
  64
  65 #define PCIE_RC_LCSR                            0x80
  66
  67 /* PCIe Port Logic registers (memory-mapped) */
  68 #define PL_OFFSET 0x700
  69 #define PCIE_PL_PFLR (PL_OFFSET + 0x08)
  70 #define PCIE_PL_PFLR_LINK_STATE_MASK            (0x3f << 16)
  71 #define PCIE_PL_PFLR_FORCE_LINK                 (1 << 15)
  72 #define PCIE_PHY_DEBUG_R0 (PL_OFFSET + 0x28)
  73 #define PCIE_PHY_DEBUG_R1 (PL_OFFSET + 0x2c)
  74 #define PCIE_PHY_DEBUG_R1_XMLH_LINK_IN_TRAINING (1 << 29)
  75 #define PCIE_PHY_DEBUG_R1_XMLH_LINK_UP          (1 << 4)
  76
  77 #define PCIE_PHY_CTRL (PL_OFFSET + 0x114)
  78 #define PCIE_PHY_CTRL_DATA_LOC 0
  79 #define PCIE_PHY_CTRL_CAP_ADR_LOC 16
  80 #define PCIE_PHY_CTRL_CAP_DAT_LOC 17
  81 #define PCIE_PHY_CTRL_WR_LOC 18
  82 #define PCIE_PHY_CTRL_RD_LOC 19
  83
  84 #define PCIE_PHY_STAT (PL_OFFSET + 0x110)
  85 #define PCIE_PHY_STAT_ACK_LOC 16
  86
  87 #define PCIE_LINK_WIDTH_SPEED_CONTROL   0x80C
  88 #define PORT_LOGIC_SPEED_CHANGE         (0x1 << 17)
  89
  90 /* PHY registers (not memory-mapped) */
  91 #define PCIE_PHY_RX_ASIC_OUT 0x100D
  92 #define PCIE_PHY_RX_ASIC_OUT_VALID      (1 << 0)
  93
  94 #define PHY_RX_OVRD_IN_LO 0x1005
  95 #define PHY_RX_OVRD_IN_LO_RX_DATA_EN (1 << 5)
  96 #define PHY_RX_OVRD_IN_LO_RX_PLL_EN (1 << 3)
  97
  98 static int pcie_phy_poll_ack(struct imx6_pcie *imx6_pcie, int exp_val)
  99 {
 100         struct pcie_port *pp = &imx6_pcie->pp;
 101         u32 val;
 102         u32 max_iterations = 10;
 103         u32 wait_counter = 0;
 104
 105         do {
 106                 val = dw_pcie_readl_rc(pp, PCIE_PHY_STAT);
 107                 val = (val >> PCIE_PHY_STAT_ACK_LOC) & 0x1;
 108                 wait_counter++;
 109
 110                 if (val == exp_val)
 111                         return 0;
 112
 113                 udelay(1);
 114         } while (wait_counter < max_iterations);
 115
 116         return -ETIMEDOUT;
 117 }
 118
 119 static int pcie_phy_wait_ack(struct imx6_pcie *imx6_pcie, int addr)
 120 {
 121         struct pcie_port *pp = &imx6_pcie->pp;
 122         u32 val;
 123         int ret;
 124
 125         val = addr << PCIE_PHY_CTRL_DATA_LOC;
 126         dw_pcie_writel_rc(pp, PCIE_PHY_CTRL, val);
 127
 128         val |= (0x1 << PCIE_PHY_CTRL_CAP_ADR_LOC);
 129         dw_pcie_writel_rc(pp, PCIE_PHY_CTRL, val);
 130
 131         ret = pcie_phy_poll_ack(imx6_pcie, 1);
 132         if (ret)
 133                 return ret;
 134
 135         val = addr << PCIE_PHY_CTRL_DATA_LOC;
 136         dw_pcie_writel_rc(pp, PCIE_PHY_CTRL, val);
 137
 138         return pcie_phy_poll_ack(imx6_pcie, 0);
 139 }
 140
 141 /* Read from the 16-bit PCIe PHY control registers (not memory-mapped) */
 142 static int pcie_phy_read(struct imx6_pcie *imx6_pcie, int addr, int *data)
 143 {
 144         struct pcie_port *pp = &imx6_pcie->pp;
 145         u32 val, phy_ctl;
 146         int ret;
 147
 148         ret = pcie_phy_wait_ack(imx6_pcie, addr);
 149         if (ret)
 150                 return ret;
 151
 152         /* assert Read signal */
 153         phy_ctl = 0x1 << PCIE_PHY_CTRL_RD_LOC;
 154         dw_pcie_writel_rc(pp, PCIE_PHY_CTRL, phy_ctl);
 155
 156         ret = pcie_phy_poll_ack(imx6_pcie, 1);
 157         if (ret)
 158                 return ret;
 159
 160         val = dw_pcie_readl_rc(pp, PCIE_PHY_STAT);
 161         *data = val & 0xffff;
 162
 163         /* deassert Read signal */
 164         dw_pcie_writel_rc(pp, PCIE_PHY_CTRL, 0x00);
 165
 166         return pcie_phy_poll_ack(imx6_pcie, 0);
 167 }
 168
 169 static int pcie_phy_write(struct imx6_pcie *imx6_pcie, int addr, int data)
 170 {
 171         struct pcie_port *pp = &imx6_pcie->pp;
 172         u32 var;
 173         int ret;
 174
 175         /* write addr */
 176         /* cap addr */
 177         ret = pcie_phy_wait_ack(imx6_pcie, addr);
 178         if (ret)
 179                 return ret;
 180
 181         var = data << PCIE_PHY_CTRL_DATA_LOC;
 182         dw_pcie_writel_rc(pp, PCIE_PHY_CTRL, var);
 183
 184         /* capture data */
 185         var |= (0x1 << PCIE_PHY_CTRL_CAP_DAT_LOC);
 186         dw_pcie_writel_rc(pp, PCIE_PHY_CTRL, var);
 187
 188         ret = pcie_phy_poll_ack(imx6_pcie, 1);
 189         if (ret)
 190                 return ret;
 191
 192         /* deassert cap data */
 193         var = data << PCIE_PHY_CTRL_DATA_LOC;
 194         dw_pcie_writel_rc(pp, PCIE_PHY_CTRL, var);
 195
 196         /* wait for ack de-assertion */
 197         ret = pcie_phy_poll_ack(imx6_pcie, 0);
 198         if (ret)
 199                 return ret;
 200
 201         /* assert wr signal */
 202         var = 0x1 << PCIE_PHY_CTRL_WR_LOC;
 203         dw_pcie_writel_rc(pp, PCIE_PHY_CTRL, var);
 204
 205         /* wait for ack */
 206         ret = pcie_phy_poll_ack(imx6_pcie, 1);
 207         if (ret)
 208                 return ret;
 209
 210         /* deassert wr signal */
 211         var = data << PCIE_PHY_CTRL_DATA_LOC;
 212         dw_pcie_writel_rc(pp, PCIE_PHY_CTRL, var);
 213
 214         /* wait for ack de-assertion */
 215         ret = pcie_phy_poll_ack(imx6_pcie, 0);
 216         if (ret)
 217                 return ret;
 218
 219         dw_pcie_writel_rc(pp, PCIE_PHY_CTRL, 0x0);
 220
 221         return 0;
 222 }
 223
 224 static void imx6_pcie_reset_phy(struct imx6_pcie *imx6_pcie)
 225 {
 226         u32 tmp;
 227
 228         pcie_phy_read(imx6_pcie, PHY_RX_OVRD_IN_LO, &tmp);
 229         tmp |= (PHY_RX_OVRD_IN_LO_RX_DATA_EN |
 230                 PHY_RX_OVRD_IN_LO_RX_PLL_EN);
 231         pcie_phy_write(imx6_pcie, PHY_RX_OVRD_IN_LO, tmp);
 232
 233         usleep_range(2000, 3000);
 234
 235         pcie_phy_read(imx6_pcie, PHY_RX_OVRD_IN_LO, &tmp);
 236         tmp &= ~(PHY_RX_OVRD_IN_LO_RX_DATA_EN |
 237                   PHY_RX_OVRD_IN_LO_RX_PLL_EN);
 238         pcie_phy_write(imx6_pcie, PHY_RX_OVRD_IN_LO, tmp);
 239 }
 240
 241 /*  Added for PCI abort handling */
 242 static int imx6q_pcie_abort_handler(unsigned long addr,
 243                 unsigned int fsr, struct pt_regs *regs)
 244 {
 245         return 0;
 246 }
 247
 248 static int imx6_pcie_assert_core_reset(struct imx6_pcie *imx6_pcie)
 249 {
 250         struct pcie_port *pp = &imx6_pcie->pp;
 251         u32 val, gpr1, gpr12;
 252
 253         switch (imx6_pcie->variant) {
 254         case IMX6SX:
 255                 regmap_update_bits(imx6_pcie->iomuxc_gpr, IOMUXC_GPR12,
 256                                    IMX6SX_GPR12_PCIE_TEST_POWERDOWN,
 257                                    IMX6SX_GPR12_PCIE_TEST_POWERDOWN);
 258                 /* Force PCIe PHY reset */
 259                 regmap_update_bits(imx6_pcie->iomuxc_gpr, IOMUXC_GPR5,
 260                                    IMX6SX_GPR5_PCIE_BTNRST_RESET,
 261                                    IMX6SX_GPR5_PCIE_BTNRST_RESET);
 262                 break;
 263         case IMX6QP:
 264                 regmap_update_bits(imx6_pcie->iomuxc_gpr, IOMUXC_GPR1,
 265                                    IMX6Q_GPR1_PCIE_SW_RST,
 266                                    IMX6Q_GPR1_PCIE_SW_RST);
 267                 break;
 268         case IMX6Q:
 269                 /*
 270                  * If the bootloader already enabled the link we need some
 271                  * special handling to get the core back into a state where
 272                  * it is safe to touch it for configuration.  As there is
 273                  * no dedicated reset signal wired up for MX6QDL, we need
 274                  * to manually force LTSSM into "detect" state before
 275                  * completely disabling LTSSM, which is a prerequisite for
 276                  * core configuration.
 277                  *
 278                  * If both LTSSM_ENABLE and REF_SSP_ENABLE are active we
 279                  * have a strong indication that the bootloader activated
 280                  * the link.
 281                  */
 282                 regmap_read(imx6_pcie->iomuxc_gpr, IOMUXC_GPR1, &gpr1);
 283                 regmap_read(imx6_pcie->iomuxc_gpr, IOMUXC_GPR12, &gpr12);
 284
 285                 if ((gpr1 & IMX6Q_GPR1_PCIE_REF_CLK_EN) &&
 286                     (gpr12 & IMX6Q_GPR12_PCIE_CTL_2)) {
 287                         val = dw_pcie_readl_rc(pp, PCIE_PL_PFLR);
 288                         val &= ~PCIE_PL_PFLR_LINK_STATE_MASK;
 289                         val |= PCIE_PL_PFLR_FORCE_LINK;
 290                         dw_pcie_writel_rc(pp, PCIE_PL_PFLR, val);
 291
 292                         regmap_update_bits(imx6_pcie->iomuxc_gpr, IOMUXC_GPR12,
 293                                            IMX6Q_GPR12_PCIE_CTL_2, 0 << 10);
 294                 }
 295
 296                 regmap_update_bits(imx6_pcie->iomuxc_gpr, IOMUXC_GPR1,
 297                                    IMX6Q_GPR1_PCIE_TEST_PD, 1 << 18);
 298                 regmap_update_bits(imx6_pcie->iomuxc_gpr, IOMUXC_GPR1,
 299                                    IMX6Q_GPR1_PCIE_REF_CLK_EN, 0 << 16);
 300                 break;
 301         }
 302
 303         return 0;
 304 }
 305
 306 static int imx6_pcie_enable_ref_clk(struct imx6_pcie *imx6_pcie)
 307 {
 308         struct pcie_port *pp = &imx6_pcie->pp;
 309         struct device *dev = pp->dev;
 310         int ret = 0;
 311
 312         switch (imx6_pcie->variant) {
 313         case IMX6SX:
 314                 ret = clk_prepare_enable(imx6_pcie->pcie_inbound_axi);
 315                 if (ret) {
 316                         dev_err(dev, "unable to enable pcie_axi clock\n");
 317                         break;
 318                 }
 319
 320                 regmap_update_bits(imx6_pcie->iomuxc_gpr, IOMUXC_GPR12,
 321                                    IMX6SX_GPR12_PCIE_TEST_POWERDOWN, 0);
 322                 break;
 323         case IMX6QP:            /* FALLTHROUGH */
 324         case IMX6Q:
 325                 /* power up core phy and enable ref clock */
 326                 regmap_update_bits(imx6_pcie->iomuxc_gpr, IOMUXC_GPR1,
 327                                    IMX6Q_GPR1_PCIE_TEST_PD, 0 << 18);
 328                 /*
 329                  * the async reset input need ref clock to sync internally,
 330                  * when the ref clock comes after reset, internal synced
 331                  * reset time is too short, cannot meet the requirement.
 332                  * add one ~10us delay here.
 333                  */
 334                 udelay(10);
 335                 regmap_update_bits(imx6_pcie->iomuxc_gpr, IOMUXC_GPR1,
 336                                    IMX6Q_GPR1_PCIE_REF_CLK_EN, 1 << 16);
 337                 break;
 338         }
 339
 340         return ret;
 341 }
 342
 343 static int imx6_pcie_deassert_core_reset(struct imx6_pcie *imx6_pcie)
 344 {
 345         struct pcie_port *pp = &imx6_pcie->pp;
 346         struct device *dev = pp->dev;
 347         int ret;
 348
 349         ret = clk_prepare_enable(imx6_pcie->pcie_phy);
 350         if (ret) {
 351                 dev_err(dev, "unable to enable pcie_phy clock\n");
 352                 goto err_pcie_phy;
 353         }
 354
 355         ret = clk_prepare_enable(imx6_pcie->pcie_bus);
 356         if (ret) {
 357                 dev_err(dev, "unable to enable pcie_bus clock\n");
 358                 goto err_pcie_bus;
 359         }
 360
 361         ret = clk_prepare_enable(imx6_pcie->pcie);
 362         if (ret) {
 363                 dev_err(dev, "unable to enable pcie clock\n");
 364                 goto err_pcie;
 365         }
 366
 367         ret = imx6_pcie_enable_ref_clk(imx6_pcie);
 368         if (ret) {
 369                 dev_err(dev, "unable to enable pcie ref clock\n");
 370                 goto err_ref_clk;
 371         }
 372
 373         /* allow the clocks to stabilize */
 374         usleep_range(200, 500);
 375
 376         /* Some boards don't have PCIe reset GPIO. */
 377         if (gpio_is_valid(imx6_pcie->reset_gpio)) {
 378                 gpio_set_value_cansleep(imx6_pcie->reset_gpio,
 379                                         imx6_pcie->gpio_active_high);
 380                 msleep(100);
 381                 gpio_set_value_cansleep(imx6_pcie->reset_gpio,
 382                                         !imx6_pcie->gpio_active_high);
 383         }
 384
 385         switch (imx6_pcie->variant) {
 386         case IMX6SX:
 387                 regmap_update_bits(imx6_pcie->iomuxc_gpr, IOMUXC_GPR5,
 388                                    IMX6SX_GPR5_PCIE_BTNRST_RESET, 0);
 389                 break;
 390         case IMX6QP:
 391                 regmap_update_bits(imx6_pcie->iomuxc_gpr, IOMUXC_GPR1,
 392                                    IMX6Q_GPR1_PCIE_SW_RST, 0);
 393
 394                 usleep_range(200, 500);
 395                 break;
 396         case IMX6Q:             /* Nothing to do */
 397                 break;
 398         }
 399
 400         return 0;
 401
 402 err_ref_clk:
 403         clk_disable_unprepare(imx6_pcie->pcie);
 404 err_pcie:
 405         clk_disable_unprepare(imx6_pcie->pcie_bus);
 406 err_pcie_bus:
 407         clk_disable_unprepare(imx6_pcie->pcie_phy);
 408 err_pcie_phy:
 409         return ret;
 410 }
 411
 412 static void imx6_pcie_init_phy(struct imx6_pcie *imx6_pcie)
 413 {
 414         if (imx6_pcie->variant == IMX6SX)
 415                 regmap_update_bits(imx6_pcie->iomuxc_gpr, IOMUXC_GPR12,
 416                                    IMX6SX_GPR12_PCIE_RX_EQ_MASK,
 417                                    IMX6SX_GPR12_PCIE_RX_EQ_2);
 418
 419         regmap_update_bits(imx6_pcie->iomuxc_gpr, IOMUXC_GPR12,
 420                         IMX6Q_GPR12_PCIE_CTL_2, 0 << 10);
 421
 422         /* configure constant input signal to the pcie ctrl and phy */
 423         regmap_update_bits(imx6_pcie->iomuxc_gpr, IOMUXC_GPR12,
 424                         IMX6Q_GPR12_DEVICE_TYPE, PCI_EXP_TYPE_ROOT_PORT << 12);
 425         regmap_update_bits(imx6_pcie->iomuxc_gpr, IOMUXC_GPR12,
 426                         IMX6Q_GPR12_LOS_LEVEL, 9 << 4);
 427
 428         regmap_update_bits(imx6_pcie->iomuxc_gpr, IOMUXC_GPR8,
 429                            IMX6Q_GPR8_TX_DEEMPH_GEN1,
 430                            imx6_pcie->tx_deemph_gen1 << 0);
 431         regmap_update_bits(imx6_pcie->iomuxc_gpr, IOMUXC_GPR8,
 432                            IMX6Q_GPR8_TX_DEEMPH_GEN2_3P5DB,
 433                            imx6_pcie->tx_deemph_gen2_3p5db << 6);
 434         regmap_update_bits(imx6_pcie->iomuxc_gpr, IOMUXC_GPR8,
 435                            IMX6Q_GPR8_TX_DEEMPH_GEN2_6DB,
 436                            imx6_pcie->tx_deemph_gen2_6db << 12);
 437         regmap_update_bits(imx6_pcie->iomuxc_gpr, IOMUXC_GPR8,
 438                            IMX6Q_GPR8_TX_SWING_FULL,
 439                            imx6_pcie->tx_swing_full << 18);
 440         regmap_update_bits(imx6_pcie->iomuxc_gpr, IOMUXC_GPR8,
 441                            IMX6Q_GPR8_TX_SWING_LOW,
 442                            imx6_pcie->tx_swing_low << 25);
 443 }
 444
 445 static int imx6_pcie_wait_for_link(struct imx6_pcie *imx6_pcie)
 446 {
 447         struct pcie_port *pp = &imx6_pcie->pp;
 448         struct device *dev = pp->dev;
 449
 450         /* check if the link is up or not */
 451         if (!dw_pcie_wait_for_link(pp))
 452                 return 0;
 453
 454         dev_dbg(dev, "DEBUG_R0: 0x%08x, DEBUG_R1: 0x%08x\n",
 455                 dw_pcie_readl_rc(pp, PCIE_PHY_DEBUG_R0),
 456                 dw_pcie_readl_rc(pp, PCIE_PHY_DEBUG_R1));
 457         return -ETIMEDOUT;
 458 }
 459
 460 static int imx6_pcie_wait_for_speed_change(struct imx6_pcie *imx6_pcie)
 461 {
 462         struct pcie_port *pp = &imx6_pcie->pp;
 463         struct device *dev = pp->dev;
 464         u32 tmp;
 465         unsigned int retries;
 466
 467         for (retries = 0; retries < 200; retries++) {
 468                 tmp = dw_pcie_readl_rc(pp, PCIE_LINK_WIDTH_SPEED_CONTROL);
 469                 /* Test if the speed change finished. */
 470                 if (!(tmp & PORT_LOGIC_SPEED_CHANGE))
 471                         return 0;
 472                 usleep_range(100, 1000);
 473         }
 474
 475         dev_err(dev, "Speed change timeout\n");
 476         return -EINVAL;
 477 }
 478
 479 static irqreturn_t imx6_pcie_msi_handler(int irq, void *arg)
 480 {
 481         struct imx6_pcie *imx6_pcie = arg;
 482         struct pcie_port *pp = &imx6_pcie->pp;
 483
 484         return dw_handle_msi_irq(pp);
 485 }
 486
 487 static int imx6_pcie_establish_link(struct imx6_pcie *imx6_pcie)
 488 {
 489         struct pcie_port *pp = &imx6_pcie->pp;
 490         struct device *dev = pp->dev;
 491         u32 tmp;
 492         int ret;
 493
 494         /*
 495          * Force Gen1 operation when starting the link.  In case the link is
 496          * started in Gen2 mode, there is a possibility the devices on the
 497          * bus will not be detected at all.  This happens with PCIe switches.
 498          */
 499         tmp = dw_pcie_readl_rc(pp, PCIE_RC_LCR);
 500         tmp &= ~PCIE_RC_LCR_MAX_LINK_SPEEDS_MASK;
 501         tmp |= PCIE_RC_LCR_MAX_LINK_SPEEDS_GEN1;
 502         dw_pcie_writel_rc(pp, PCIE_RC_LCR, tmp);
 503
 504         /* Start LTSSM. */
 505         regmap_update_bits(imx6_pcie->iomuxc_gpr, IOMUXC_GPR12,
 506                         IMX6Q_GPR12_PCIE_CTL_2, 1 << 10);
 507
 508         ret = imx6_pcie_wait_for_link(imx6_pcie);
 509         if (ret) {
 510                 dev_info(dev, "Link never came up\n");
 511                 goto err_reset_phy;
 512         }
 513
 514         if (imx6_pcie->link_gen == 2) {
 515                 /* Allow Gen2 mode after the link is up. */
 516                 tmp = dw_pcie_readl_rc(pp, PCIE_RC_LCR);
 517                 tmp &= ~PCIE_RC_LCR_MAX_LINK_SPEEDS_MASK;
 518                 tmp |= PCIE_RC_LCR_MAX_LINK_SPEEDS_GEN2;
 519                 dw_pcie_writel_rc(pp, PCIE_RC_LCR, tmp);
 520         } else {
 521                 dev_info(dev, "Link: Gen2 disabled\n");
 522         }
 523
 524         /*
 525          * Start Directed Speed Change so the best possible speed both link
 526          * partners support can be negotiated.
 527          */
 528         tmp = dw_pcie_readl_rc(pp, PCIE_LINK_WIDTH_SPEED_CONTROL);
 529         tmp |= PORT_LOGIC_SPEED_CHANGE;
 530         dw_pcie_writel_rc(pp, PCIE_LINK_WIDTH_SPEED_CONTROL, tmp);
 531
 532         ret = imx6_pcie_wait_for_speed_change(imx6_pcie);
 533         if (ret) {
 534                 dev_err(dev, "Failed to bring link up!\n");
 535                 goto err_reset_phy;
 536         }
 537
 538         /* Make sure link training is finished as well! */
 539         ret = imx6_pcie_wait_for_link(imx6_pcie);
 540         if (ret) {
 541                 dev_err(dev, "Failed to bring link up!\n");
 542                 goto err_reset_phy;
 543         }
 544
 545         tmp = dw_pcie_readl_rc(pp, PCIE_RC_LCSR);
 546         dev_info(dev, "Link up, Gen%i\n", (tmp >> 16) & 0xf);
 547         return 0;
 548
 549 err_reset_phy:
 550         dev_dbg(dev, "PHY DEBUG_R0=0x%08x DEBUG_R1=0x%08x\n",
 551                 dw_pcie_readl_rc(pp, PCIE_PHY_DEBUG_R0),
 552                 dw_pcie_readl_rc(pp, PCIE_PHY_DEBUG_R1));
 553         imx6_pcie_reset_phy(imx6_pcie);
 554         return ret;
 555 }
 556
 557 static void imx6_pcie_host_init(struct pcie_port *pp)
 558 {
 559         struct imx6_pcie *imx6_pcie = to_imx6_pcie(pp);
 560
 561         imx6_pcie_assert_core_reset(imx6_pcie);
 562         imx6_pcie_init_phy(imx6_pcie);
 563         imx6_pcie_deassert_core_reset(imx6_pcie);
 564         dw_pcie_setup_rc(pp);
 565         imx6_pcie_establish_link(imx6_pcie);
 566
 567         if (IS_ENABLED(CONFIG_PCI_MSI))
 568                 dw_pcie_msi_init(pp);
 569 }
 570
 571 static int imx6_pcie_link_up(struct pcie_port *pp)
 572 {
 573         return dw_pcie_readl_rc(pp, PCIE_PHY_DEBUG_R1) &
 574                         PCIE_PHY_DEBUG_R1_XMLH_LINK_UP;
 575 }
 576
 577 static struct pcie_host_ops imx6_pcie_host_ops = {
 578         .link_up = imx6_pcie_link_up,
 579         .host_init = imx6_pcie_host_init,
 580 };
 581
 582 static int __init imx6_add_pcie_port(struct imx6_pcie *imx6_pcie,
 583                                      struct platform_device *pdev)
 584 {
 585         struct pcie_port *pp = &imx6_pcie->pp;
 586         struct device *dev = pp->dev;
 587         int ret;
 588
 589         if (IS_ENABLED(CONFIG_PCI_MSI)) {
 590                 pp->msi_irq = platform_get_irq_byname(pdev, "msi");
 591                 if (pp->msi_irq <= 0) {
 592                         dev_err(dev, "failed to get MSI irq\n");
 593                         return -ENODEV;
 594                 }
 595
 596                 ret = devm_request_irq(dev, pp->msi_irq,
 597                                        imx6_pcie_msi_handler,
 598                                        IRQF_SHARED | IRQF_NO_THREAD,
 599                                        "mx6-pcie-msi", imx6_pcie);
 600                 if (ret) {
 601                         dev_err(dev, "failed to request MSI irq\n");
 602                         return ret;
 603                 }
 604         }
 605
 606         pp->root_bus_nr = -1;
 607         pp->ops = &imx6_pcie_host_ops;
 608
 609         ret = dw_pcie_host_init(pp);
 610         if (ret) {
 611                 dev_err(dev, "failed to initialize host\n");
 612                 return ret;
 613         }
 614
 615         return 0;
 616 }
 617
 618 static int __init imx6_pcie_probe(struct platform_device *pdev)
 619 {
 620         struct device *dev = &pdev->dev;
 621         struct imx6_pcie *imx6_pcie;
 622         struct pcie_port *pp;
 623         struct resource *dbi_base;
 624         struct device_node *node = dev->of_node;
 625         int ret;
 626
 627         imx6_pcie = devm_kzalloc(dev, sizeof(*imx6_pcie), GFP_KERNEL);
 628         if (!imx6_pcie)
 629                 return -ENOMEM;
 630
 631         pp = &imx6_pcie->pp;
 632         pp->dev = dev;
 633
 634         imx6_pcie->variant =
 635                 (enum imx6_pcie_variants)of_device_get_match_data(dev);
 636
 637         /* Added for PCI abort handling */
 638         hook_fault_code(16 + 6, imx6q_pcie_abort_handler, SIGBUS, 0,
 639                 "imprecise external abort");
 640
 641         dbi_base = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 642         pp->dbi_base = devm_ioremap_resource(dev, dbi_base);
 643         if (IS_ERR(pp->dbi_base))
 644                 return PTR_ERR(pp->dbi_base);
 645
 646         /* Fetch GPIOs */
 647         imx6_pcie->reset_gpio = of_get_named_gpio(node, "reset-gpio", 0);
 648         imx6_pcie->gpio_active_high = of_property_read_bool(node,
 649                                                 "reset-gpio-active-high");
 650         if (gpio_is_valid(imx6_pcie->reset_gpio)) {
 651                 ret = devm_gpio_request_one(dev, imx6_pcie->reset_gpio,
 652                                 imx6_pcie->gpio_active_high ?
 653                                         GPIOF_OUT_INIT_HIGH :
 654                                         GPIOF_OUT_INIT_LOW,
 655                                 "PCIe reset");
 656                 if (ret) {
 657                         dev_err(dev, "unable to get reset gpio\n");
 658                         return ret;
 659                 }
 660         }
 661
 662         /* Fetch clocks */
 663         imx6_pcie->pcie_phy = devm_clk_get(dev, "pcie_phy");
 664         if (IS_ERR(imx6_pcie->pcie_phy)) {
 665                 dev_err(dev, "pcie_phy clock source missing or invalid\n");
 666                 return PTR_ERR(imx6_pcie->pcie_phy);
 667         }
 668
 669         imx6_pcie->pcie_bus = devm_clk_get(dev, "pcie_bus");
 670         if (IS_ERR(imx6_pcie->pcie_bus)) {
 671                 dev_err(dev, "pcie_bus clock source missing or invalid\n");
 672                 return PTR_ERR(imx6_pcie->pcie_bus);
 673         }
 674
 675         imx6_pcie->pcie = devm_clk_get(dev, "pcie");
 676         if (IS_ERR(imx6_pcie->pcie)) {
 677                 dev_err(dev, "pcie clock source missing or invalid\n");
 678                 return PTR_ERR(imx6_pcie->pcie);
 679         }
 680
 681         if (imx6_pcie->variant == IMX6SX) {
 682                 imx6_pcie->pcie_inbound_axi = devm_clk_get(dev,
 683                                                            "pcie_inbound_axi");
 684                 if (IS_ERR(imx6_pcie->pcie_inbound_axi)) {
 685                         dev_err(dev,
 686                                 "pcie_incbound_axi clock missing or invalid\n");
 687                         return PTR_ERR(imx6_pcie->pcie_inbound_axi);
 688                 }
 689         }
 690
 691         /* Grab GPR config register range */
 692         imx6_pcie->iomuxc_gpr =
 693                  syscon_regmap_lookup_by_compatible("fsl,imx6q-iomuxc-gpr");
 694         if (IS_ERR(imx6_pcie->iomuxc_gpr)) {
 695                 dev_err(dev, "unable to find iomuxc registers\n");
 696                 return PTR_ERR(imx6_pcie->iomuxc_gpr);
 697         }
 698
 699         /* Grab PCIe PHY Tx Settings */
 700         if (of_property_read_u32(node, "fsl,tx-deemph-gen1",
 701                                  &imx6_pcie->tx_deemph_gen1))
 702                 imx6_pcie->tx_deemph_gen1 = 0;
 703
 704         if (of_property_read_u32(node, "fsl,tx-deemph-gen2-3p5db",
 705                                  &imx6_pcie->tx_deemph_gen2_3p5db))
 706                 imx6_pcie->tx_deemph_gen2_3p5db = 0;
 707
 708         if (of_property_read_u32(node, "fsl,tx-deemph-gen2-6db",
 709                                  &imx6_pcie->tx_deemph_gen2_6db))
 710                 imx6_pcie->tx_deemph_gen2_6db = 20;
 711
 712         if (of_property_read_u32(node, "fsl,tx-swing-full",
 713                                  &imx6_pcie->tx_swing_full))
 714                 imx6_pcie->tx_swing_full = 127;
 715
 716         if (of_property_read_u32(node, "fsl,tx-swing-low",
 717                                  &imx6_pcie->tx_swing_low))
 718                 imx6_pcie->tx_swing_low = 127;
 719
 720         /* Limit link speed */
 721         ret = of_property_read_u32(node, "fsl,max-link-speed",
 722                                    &imx6_pcie->link_gen);
 723         if (ret)
 724                 imx6_pcie->link_gen = 1;
 725
 726         ret = imx6_add_pcie_port(imx6_pcie, pdev);
 727         if (ret < 0)
 728                 return ret;
 729
 730         platform_set_drvdata(pdev, imx6_pcie);
 731         return 0;
 732 }
 733
 734 static void imx6_pcie_shutdown(struct platform_device *pdev)
 735 {
 736         struct imx6_pcie *imx6_pcie = platform_get_drvdata(pdev);
 737
 738         /* bring down link, so bootloader gets clean state in case of reboot */
 739         imx6_pcie_assert_core_reset(imx6_pcie);
 740 }
 741
 742 static const struct of_device_id imx6_pcie_of_match[] = {
 743         { .compatible = "fsl,imx6q-pcie",  .data = (void *)IMX6Q,  },
 744         { .compatible = "fsl,imx6sx-pcie", .data = (void *)IMX6SX, },
 745         { .compatible = "fsl,imx6qp-pcie", .data = (void *)IMX6QP, },
 746         {},
 747 };
 748
 749 static struct platform_driver imx6_pcie_driver = {
 750         .driver = {
 751                 .name   = "imx6q-pcie",
 752                 .of_match_table = imx6_pcie_of_match,
 753         },
 754         .shutdown = imx6_pcie_shutdown,
 755 };
 756
 757 static int __init imx6_pcie_init(void)
 758 {
 759         return platform_driver_probe(&imx6_pcie_driver, imx6_pcie_probe);
 760 }
 761 device_initcall(imx6_pcie_init);