target/linux/imx6/files-3.10/arch/arm/mach-imx/pcie.c

   1 /*
   2  * arch/arm/mach-imx/pcie.c
   3  *
   4  * PCIe host controller driver for IMX6 SOCs
   5  *
   6  * Copyright (C) 2012 Freescale Semiconductor, Inc. All Rights Reserved.
   7  * Copyright (C) 2013 Tim Harvey <tharvey@gateworks.com>
   8  *
   9  * Bits taken from arch/arm/mach-dove/pcie.c
  10  *
  11  * This program is free software; you can redistribute it and/or modify
  12  * it under the terms of the GNU General Public License as published by
  13  * the Free Software Foundation; either version 2 of the License, or
  14  * (at your option) any later version.
  15
  16  * This program is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  * GNU General Public License for more details.
  20
  21  * You should have received a copy of the GNU General Public License along
  22  * with this program; if not, write to the Free Software Foundation, Inc.,
  23  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  24  */
  25 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  26
  27 #include <linux/module.h>
  28 #include <linux/kernel.h>
  29 #include <linux/pci.h>
  30 #include <linux/interrupt.h>
  31 #include <linux/irq.h>
  32 #include <linux/clk.h>
  33 #include <linux/delay.h>
  34 #include <linux/gpio.h>
  35 #include <linux/platform_device.h>
  36 #include <linux/of.h>
  37 #include <linux/of_platform.h>
  38 #include <linux/of_address.h>
  39 #include <linux/of_gpio.h>
  40
  41 #include <asm/signal.h>
  42 #include <asm/mach/pci.h>
  43 #include <asm/sizes.h>
  44
  45 #include "msi.h"
  46
  47 /* PCIe Registers */
  48 #define PCIE_ARB_BASE_ADDR  0x01000000
  49 #define PCIE_ARB_END_ADDR   0x01FFFFFF
  50 #define PCIE_RC_IOBLSSR     0x1c
  51
  52 /* Register Definitions */
  53 #define PRT_LOG_R_BaseAddress 0x700
  54
  55 /* Register DB_R0 */
  56 /* Debug Register 0 */
  57 #define DB_R0 (PRT_LOG_R_BaseAddress + 0x28)
  58 #define DB_R0_RegisterSize 32
  59 #define DB_R0_RegisterResetValue 0x0
  60 #define DB_R0_RegisterResetMask 0xFFFFFFFF
  61 /* End of Register Definition for DB_R0 */
  62
  63 /* Register DB_R1 */
  64 /* Debug Register 1 */
  65 #define DB_R1 (PRT_LOG_R_BaseAddress + 0x2c)
  66 #define DB_R1_RegisterSize 32
  67 #define DB_R1_RegisterResetValue 0x0
  68 #define DB_R1_RegisterResetMask 0xFFFFFFFF
  69 /* End of Register Definition for DB_R1 */
  70
  71 #define PCIE_PL_MSICA           0x820
  72 #define PCIE_PL_MSICUA          0x824
  73 #define PCIE_PL_MSIC_INT        0x828
  74
  75 #define MSIC_INT_EN     0x0
  76 #define MSIC_INT_MASK   0x4
  77 #define MSIC_INT_STATUS 0x8
  78
  79 #define ATU_R_BaseAddress 0x900
  80 #define ATU_VIEWPORT_R (ATU_R_BaseAddress + 0x0)
  81 #define ATU_REGION_CTRL1_R (ATU_R_BaseAddress + 0x4)
  82 #define ATU_REGION_CTRL2_R (ATU_R_BaseAddress + 0x8)
  83 #define ATU_REGION_LOWBASE_R (ATU_R_BaseAddress + 0xC)
  84 #define ATU_REGION_UPBASE_R (ATU_R_BaseAddress + 0x10)
  85 #define ATU_REGION_LIMIT_ADDR_R (ATU_R_BaseAddress + 0x14)
  86 #define ATU_REGION_LOW_TRGT_ADDR_R (ATU_R_BaseAddress + 0x18)
  87 #define ATU_REGION_UP_TRGT_ADDR_R (ATU_R_BaseAddress + 0x1C)
  88
  89 /* IOMUXC */
  90 #define IOMUXC_GPR_BASE_ADDR    0x020E0000
  91 #define IOMUXC_GPR1     (imx_pcie.gpr_base + 0x04)
  92 #define IOMUXC_GPR8     (imx_pcie.gpr_base + 0x20)
  93 #define IOMUXC_GPR12    (imx_pcie.gpr_base + 0x30)
  94 /* GPR1: iomuxc_gpr1_pcie_ref_clk_en(iomuxc_gpr1[16]) */
  95 #define iomuxc_gpr1_pcie_ref_clk_en             (1 << 16)
  96 /* GPR1: iomuxc_gpr1_test_powerdown(iomuxc_gpr1_18) */
  97 #define iomuxc_gpr1_test_powerdown              (1 << 18)
  98 /* GPR12: iomuxc_gpr12_los_level(iomuxc_gpr12[8:4]) */
  99 #define iomuxc_gpr12_los_level                  (0x1F << 4)
 100 /* GPR12: iomuxc_gpr12_app_ltssm_enable(iomuxc_gpr12[10]) */
 101 #define iomuxc_gpr12_app_ltssm_enable           (1 << 10)
 102 /* GPR12: iomuxc_gpr12_device_type(iomuxc_gpr12[15:12]) */
 103 #define iomuxc_gpr12_device_type                (0xF << 12)
 104 /* GPR8: iomuxc_gpr8_tx_deemph_gen1(iomuxc_gpr8[5:0]) */
 105 #define iomuxc_gpr8_tx_deemph_gen1              (0x3F << 0)
 106 /* GPR8: iomuxc_gpr8_tx_deemph_gen2_3p5db(iomuxc_gpr8[11:6]) */
 107 #define iomuxc_gpr8_tx_deemph_gen2_3p5db        (0x3F << 6)
 108 /* GPR8: iomuxc_gpr8_tx_deemph_gen2_6db(iomuxc_gpr8[17:12]) */
 109 #define iomuxc_gpr8_tx_deemph_gen2_6db          (0x3F << 12)
 110 /* GPR8: iomuxc_gpr8_tx_swing_full(iomuxc_gpr8[24:18]) */
 111 #define iomuxc_gpr8_tx_swing_full               (0x7F << 18)
 112 /* GPR8: iomuxc_gpr8_tx_swing_low(iomuxc_gpr8[31:25]) */
 113 #define iomuxc_gpr8_tx_swing_low                (0x7F << 25)
 114
 115 /* Registers of PHY */
 116 /* Register PHY_STS_R */
 117 /* PHY Status Register */
 118 #define PHY_STS_R (PRT_LOG_R_BaseAddress + 0x110)
 119
 120 /* Register PHY_CTRL_R */
 121 /* PHY Control Register */
 122 #define PHY_CTRL_R (PRT_LOG_R_BaseAddress + 0x114)
 123
 124 #define SSP_CR_SUP_DIG_MPLL_OVRD_IN_LO 0x0011
 125 /* FIELD: RES_ACK_IN_OVRD [15:15]
 126 // FIELD: RES_ACK_IN [14:14]
 127 // FIELD: RES_REQ_IN_OVRD [13:13]
 128 // FIELD: RES_REQ_IN [12:12]
 129 // FIELD: RTUNE_REQ_OVRD [11:11]
 130 // FIELD: RTUNE_REQ [10:10]
 131 // FIELD: MPLL_MULTIPLIER_OVRD [9:9]
 132 // FIELD: MPLL_MULTIPLIER [8:2]
 133 // FIELD: MPLL_EN_OVRD [1:1]
 134 // FIELD: MPLL_EN [0:0]
 135 */
 136
 137 #define SSP_CR_SUP_DIG_ATEOVRD 0x0010
 138 /* FIELD: ateovrd_en [2:2]
 139 // FIELD: ref_usb2_en [1:1]
 140 // FIELD: ref_clkdiv2 [0:0]
 141 */
 142
 143 #define SSP_CR_LANE0_DIG_RX_OVRD_IN_LO 0x1005
 144 /* FIELD: RX_LOS_EN_OVRD [13:13]
 145 // FIELD: RX_LOS_EN [12:12]
 146 // FIELD: RX_TERM_EN_OVRD [11:11]
 147 // FIELD: RX_TERM_EN [10:10]
 148 // FIELD: RX_BIT_SHIFT_OVRD [9:9]
 149 // FIELD: RX_BIT_SHIFT [8:8]
 150 // FIELD: RX_ALIGN_EN_OVRD [7:7]
 151 // FIELD: RX_ALIGN_EN [6:6]
 152 // FIELD: RX_DATA_EN_OVRD [5:5]
 153 // FIELD: RX_DATA_EN [4:4]
 154 // FIELD: RX_PLL_EN_OVRD [3:3]
 155 // FIELD: RX_PLL_EN [2:2]
 156 // FIELD: RX_INVERT_OVRD [1:1]
 157 // FIELD: RX_INVERT [0:0]
 158 */
 159
 160 #define SSP_CR_LANE0_DIG_RX_ASIC_OUT 0x100D
 161 /* FIELD: LOS [2:2]
 162 // FIELD: PLL_STATE [1:1]
 163 // FIELD: VALID [0:0]
 164 */
 165
 166 /* control bus bit definition */
 167 #define PCIE_CR_CTL_DATA_LOC 0
 168 #define PCIE_CR_CTL_CAP_ADR_LOC 16
 169 #define PCIE_CR_CTL_CAP_DAT_LOC 17
 170 #define PCIE_CR_CTL_WR_LOC 18
 171 #define PCIE_CR_CTL_RD_LOC 19
 172 #define PCIE_CR_STAT_DATA_LOC 0
 173 #define PCIE_CR_STAT_ACK_LOC 16
 174
 175 #define PCIE_CAP_STRUC_BaseAddress 0x70
 176
 177 /* Register LNK_CAP */
 178 /* PCIE Link cap */
 179 #define LNK_CAP (PCIE_CAP_STRUC_BaseAddress + 0xc)
 180
 181 /* End of Register Definitions */
 182
 183 enum {
 184         MemRdWr = 0,
 185         MemRdLk = 1,
 186         IORdWr = 2,
 187         CfgRdWr0 = 4,
 188         CfgRdWr1 = 5
 189 };
 190
 191 struct imx_pcie_port {
 192         u8                      index;
 193         u8                      root_bus_nr;
 194         void __iomem            *base;
 195         void __iomem            *dbi_base;
 196         spinlock_t              conf_lock;
 197
 198         char                    io_space_name[16];
 199         char                    mem_space_name[16];
 200
 201         struct resource         res[2];
 202         struct clk *clk;
 203 };
 204
 205 struct imx_pcie_info {
 206         struct imx_pcie_port imx_pcie_port[1];
 207         int num_pcie_ports;
 208
 209         void __iomem *base;
 210         void __iomem *dbi_base;
 211         void __iomem *gpr_base;
 212
 213         unsigned int pcie_pwr_en;
 214         unsigned int pcie_rst;
 215         unsigned int pcie_wake_up;
 216         unsigned int pcie_dis;
 217 };
 218
 219 static struct imx_pcie_info imx_pcie;
 220
 221 static int pcie_phy_cr_read(int addr, int *data);
 222 static int pcie_phy_cr_write(int addr, int data);
 223 static void change_field(int *in, int start, int end, int val);
 224
 225 /* IMX PCIE GPR configure routines */
 226 static inline void imx_pcie_clrset(u32 mask, u32 val, void __iomem *addr)
 227 {
 228         writel(((readl(addr) & ~mask) | (val & mask)), addr);
 229 }
 230
 231 static int imx_pcie_setup(int nr, struct pci_sys_data *sys)
 232 {
 233         struct imx_pcie_port *pp;
 234
 235         if (nr >= imx_pcie.num_pcie_ports)
 236                 return 0;
 237
 238         pp = &imx_pcie.imx_pcie_port[nr];
 239         pp->root_bus_nr = sys->busnr;
 240
 241         /*
 242          * IORESOURCE_IO
 243          */
 244         snprintf(pp->io_space_name, sizeof(pp->io_space_name),
 245                  "PCIe %d I/O", pp->index);
 246         pp->io_space_name[sizeof(pp->io_space_name) - 1] = 0;
 247         pp->res[0].name = pp->io_space_name;
 248         if (pp->index == 0) {
 249                 pp->res[0].start = PCIE_ARB_BASE_ADDR;
 250                 pp->res[0].end = pp->res[0].start + SZ_1M - 1;
 251         }
 252         pp->res[0].flags = IORESOURCE_IO;
 253         if (request_resource(&ioport_resource, &pp->res[0]))
 254                 panic("Request PCIe IO resource failed\n");
 255         pci_add_resource_offset(&sys->resources, &pp->res[0], sys->io_offset);
 256
 257         /*
 258          * IORESOURCE_MEM
 259          */
 260         snprintf(pp->mem_space_name, sizeof(pp->mem_space_name),
 261                         "PCIe %d MEM", pp->index);
 262         pp->mem_space_name[sizeof(pp->mem_space_name) - 1] = 0;
 263         pp->res[1].name = pp->mem_space_name;
 264         if (pp->index == 0) {
 265                 pp->res[1].start = PCIE_ARB_BASE_ADDR + SZ_1M;
 266                 pp->res[1].end = pp->res[1].start + SZ_16M - SZ_2M - 1;
 267         }
 268         pp->res[1].flags = IORESOURCE_MEM;
 269         if (request_resource(&iomem_resource, &pp->res[1]))
 270                 panic("Request PCIe Memory resource failed\n");
 271         pci_add_resource_offset(&sys->resources, &pp->res[1], sys->mem_offset);
 272
 273         return 1;
 274 }
 275
 276 static int imx_pcie_link_up(void __iomem *dbi_base)
 277 {
 278         /* Check the pcie link up or link down */
 279         int iterations = 200;
 280         u32 rc, ltssm, rx_valid, temp;
 281
 282         do {
 283                 /* link is debug bit 36 debug 1 start in bit 32 */
 284                 rc = readl(dbi_base + DB_R1) & (0x1 << (36 - 32)) ;
 285                 iterations--;
 286                 usleep_range(2000, 3000);
 287
 288                 /* From L0, initiate MAC entry to gen2 if EP/RC supports gen2.
 289                  * Wait 2ms (LTSSM timeout is 24ms, PHY lock is ~5us in gen2).
 290                  * If (MAC/LTSSM.state == Recovery.RcvrLock)
 291                  * && (PHY/rx_valid==0) then pulse PHY/rx_reset. Transition
 292                  * to gen2 is stuck
 293                  */
 294                 pcie_phy_cr_read(SSP_CR_LANE0_DIG_RX_ASIC_OUT, &rx_valid);
 295                 ltssm = readl(dbi_base + DB_R0) & 0x3F;
 296                 if ((ltssm == 0x0D) && ((rx_valid & 0x01) == 0)) {
 297                         pr_info("Transition to gen2 is stuck, reset PHY!\n");
 298                         pcie_phy_cr_read(SSP_CR_LANE0_DIG_RX_OVRD_IN_LO, &temp);
 299                         change_field(&temp, 3, 3, 0x1);
 300                         change_field(&temp, 5, 5, 0x1);
 301                         pcie_phy_cr_write(SSP_CR_LANE0_DIG_RX_OVRD_IN_LO,
 302                                         0x0028);
 303                         usleep_range(2000, 3000);
 304                         pcie_phy_cr_read(SSP_CR_LANE0_DIG_RX_OVRD_IN_LO, &temp);
 305                         change_field(&temp, 3, 3, 0x0);
 306                         change_field(&temp, 5, 5, 0x0);
 307                         pcie_phy_cr_write(SSP_CR_LANE0_DIG_RX_OVRD_IN_LO,
 308                                         0x0000);
 309                 }
 310
 311                 if ((iterations < 0))
 312                         pr_info("link up failed, DB_R0:0x%08x, DB_R1:0x%08x!\n"
 313                                         , readl(dbi_base + DB_R0)
 314                                         , readl(dbi_base + DB_R1));
 315         } while (!rc && iterations);
 316
 317         if (!rc)
 318                 return 0;
 319         return 1;
 320 }
 321
 322 static void imx_pcie_regions_setup(void __iomem *dbi_base)
 323 {
 324         unsigned bus;
 325         unsigned i;
 326         unsigned untranslated_base = PCIE_ARB_END_ADDR +1 - SZ_1M;
 327         void __iomem *p = dbi_base + PCIE_PL_MSIC_INT;
 328         /*
 329          * i.MX6 defines 16MB in the AXI address map for PCIe.
 330          *
 331          * That address space excepted the pcie registers is
 332          * split and defined into different regions by iATU,
 333          * with sizes and offsets as follows:
 334          *
 335          * 0x0100_0000 --- 0x010F_FFFF 1MB IORESOURCE_IO
 336          * 0x0110_0000 --- 0x01EF_FFFF 14MB IORESOURCE_MEM
 337          * 0x01F0_0000 --- 0x01FF_FFFF 1MB Cfg + Registers
 338          */
 339
 340         /* CMD reg:I/O space, MEM space, and Bus Master Enable */
 341         writel(readl(dbi_base + PCI_COMMAND)
 342                         | PCI_COMMAND_IO
 343                         | PCI_COMMAND_MEMORY
 344                         | PCI_COMMAND_MASTER,
 345                         dbi_base + PCI_COMMAND);
 346
 347         /* Set the CLASS_REV of RC CFG header to PCI_CLASS_BRIDGE_PCI */
 348         writel(readl(dbi_base + PCI_CLASS_REVISION)
 349                         | (PCI_CLASS_BRIDGE_PCI << 16),
 350                         dbi_base + PCI_CLASS_REVISION);
 351
 352         /*
 353          * region0-3 outbound used to access target cfg
 354          */
 355         for (bus = 1; bus <= 4; bus++) {
 356                 writel(bus - 1, dbi_base + ATU_VIEWPORT_R);
 357                 writel(untranslated_base, dbi_base + ATU_REGION_LOWBASE_R);
 358                 untranslated_base += (1 << 18);
 359                 if (bus == 4)
 360                         untranslated_base -= (1 << 14); //(remove registers)
 361                 writel(untranslated_base - 1, dbi_base + ATU_REGION_LIMIT_ADDR_R);
 362                 writel(0, dbi_base + ATU_REGION_UPBASE_R);
 363
 364                 writel(bus << 24, dbi_base + ATU_REGION_LOW_TRGT_ADDR_R);
 365                 writel(0, dbi_base + ATU_REGION_UP_TRGT_ADDR_R);
 366                 writel((bus > 1) ? CfgRdWr1 : CfgRdWr0,
 367                                 dbi_base + ATU_REGION_CTRL1_R);
 368                 writel((1<<31), dbi_base + ATU_REGION_CTRL2_R);
 369         }
 370
 371         writel(MSI_MATCH_ADDR, dbi_base + PCIE_PL_MSICA);
 372         writel(0, dbi_base + PCIE_PL_MSICUA);
 373         for (i = 0; i < 8 ; i++) {
 374                 writel(0, p + MSIC_INT_EN);
 375                 writel(0xffffffff, p + MSIC_INT_MASK);
 376                 writel(0xffffffff, p + MSIC_INT_STATUS);
 377                 p += 12;
 378         }
 379 }
 380
 381 void imx_pcie_mask_irq(unsigned pos, int set)
 382 {
 383         unsigned mask = 1 << (pos & 0x1f);
 384         unsigned val, newval;
 385         void __iomem *p = imx_pcie.dbi_base + PCIE_PL_MSIC_INT + MSIC_INT_MASK + ((pos >> 5) * 12);
 386         if (pos >= (8 * 32))
 387                 return;
 388         val = readl(p);
 389         if (set)
 390                 newval = val | mask;
 391         else
 392                 newval = val & ~mask;
 393         if (val != newval)
 394                 writel(newval, p);
 395 }
 396
 397 void imx_pcie_enable_irq(unsigned pos, int set)
 398 {
 399         unsigned mask = 1 << (pos & 0x1f);
 400         unsigned val, newval;
 401         void __iomem *p = imx_pcie.dbi_base + PCIE_PL_MSIC_INT + MSIC_INT_EN + ((pos >> 5) * 12);
 402         if (pos >= (8 * 32))
 403                 return;
 404         val = readl(p);
 405         if (set)
 406                 newval = val | mask;
 407         else
 408                 newval = val & ~mask;
 409         if (val != newval)
 410                 writel(newval, p);
 411         if (set && (val != newval))
 412                 imx_pcie_mask_irq(pos, 0);      /* unmask when enabled */
 413 }
 414
 415 unsigned imx_pcie_msi_pending(unsigned index)
 416 {
 417         unsigned val, mask;
 418         void __iomem *p = imx_pcie.dbi_base + PCIE_PL_MSIC_INT + (index * 12);
 419         if (index >= 8)
 420                 return 0;
 421         val = readl(p + MSIC_INT_STATUS);
 422         mask = readl(p + MSIC_INT_MASK);
 423         val &= ~mask;
 424         writel(val, p + MSIC_INT_STATUS);
 425         return val;
 426 }
 427
 428 static char master_abort(struct pci_bus *bus, u32 devfn, int where)
 429 {
 430         u32 reg;
 431         void __iomem *dbi_base = imx_pcie.dbi_base;
 432         int ret = 0;
 433
 434         reg = readl(dbi_base + PCIE_RC_IOBLSSR);
 435         if (reg & 0x71000000) {
 436                 if (reg & 1<<30)
 437                         pr_err("%d:%02d.%d 0x%04x: parity error\n", bus->number, PCI_SLOT(devfn), PCI_FUNC(devfn), where);
 438                 if (reg & 1<<29) {
 439                         pr_err("%d:%02d.%d 0x%04x: master abort\n", bus->number, PCI_SLOT(devfn), PCI_FUNC(devfn), where);
 440                         ret = 1;
 441                 }
 442                 if (reg & 1<<28)
 443                         pr_err("%d:%02d.%d 0x%04x: target abort\n", bus->number, PCI_SLOT(devfn), PCI_FUNC(devfn), where);
 444                 if (reg & 1<<24)
 445                         pr_err("%d:%02d.%d 0x%04x: master data parity error\n", bus->number, PCI_SLOT(devfn), PCI_FUNC(devfn), where);
 446                 writel(reg, dbi_base + PCIE_RC_IOBLSSR);
 447                 udelay(1500); // without this delay subsequent reads through bridge can erroneously return 0???
 448         }
 449         return ret;
 450 }
 451
 452 static volatile void *get_cfg_addr(struct pci_bus *bus, u32 devfn, int where)
 453 {
 454         unsigned busnum;
 455         void __iomem *base = imx_pcie.base;
 456         void __iomem *dbi_base = imx_pcie.dbi_base;
 457
 458         if (!bus->number) {
 459                 if (devfn != 0)
 460                         return 0;
 461                 return (imx_pcie.dbi_base) + (where & 0x0ffc);
 462         }
 463         if ((devfn > 0xff) || (bus->number > 15))
 464                 return 0;
 465         busnum = bus->number - 1;
 466         if ((busnum < 3) && (devfn <= 3)) {
 467                 return (base) + (busnum << 18) + (devfn << 16) + (where & 0xfffc);
 468         }
 469         writel(3, dbi_base + ATU_VIEWPORT_R);
 470         writel((bus->number << 24) | (devfn << 16),
 471                         dbi_base + ATU_REGION_LOW_TRGT_ADDR_R);
 472         writel((bus->number > 1) ? CfgRdWr1 : CfgRdWr0,
 473                         dbi_base + ATU_REGION_CTRL1_R);
 474         return (base) + (3 << 18) + (where & 0xfffc);
 475 }
 476
 477 static int imx_pcie_rd_conf(struct pci_bus *bus, u32 devfn, int where,
 478                         int size, u32 *val)
 479 {
 480         const volatile void *va_address;
 481         u32 v;
 482
 483         if (0)
 484                 pr_info("%s: bus=%x, devfn=%x, where=%x size=%x\n", __func__, bus->number, devfn, where, size);
 485         va_address = get_cfg_addr(bus, devfn, where);
 486         if (!va_address) {
 487                 *val = 0xffffffff;
 488                 return PCIBIOS_DEVICE_NOT_FOUND;
 489         }
 490         v = readl(va_address);
 491         if (master_abort(bus, devfn, where)) {
 492                 return PCIBIOS_DEVICE_NOT_FOUND;
 493         }
 494         if (0)
 495                 pr_info("%s: bus=%x, devfn=%x, where=%x size=%x v=%x\n", __func__, bus->number, devfn, where, size, v);
 496         if (size == 4) {
 497                 *val = v;
 498         } else if (size == 1) {
 499                 *val = (v >> (8 * (where & 3))) & 0xFF;
 500         } else if (size == 2) {
 501                 *val = (v >> (8 * (where & 3))) & 0xFFFF;
 502         } else {
 503                 *val = 0xffffffff;
 504                 return PCIBIOS_BAD_REGISTER_NUMBER;
 505         }
 506         return PCIBIOS_SUCCESSFUL;
 507 }
 508
 509 static int imx_pcie_wr_conf(struct pci_bus *bus, u32 devfn,
 510                         int where, int size, u32 val)
 511 {
 512         volatile void *va_address;
 513         u32 mask, tmp;
 514
 515         if (0)
 516                 pr_info("%s: bus=%x, devfn=%x, where=%x size=%x val=%x\n", __func__, bus->number, devfn, where, size, val);
 517         va_address = get_cfg_addr(bus, devfn, where);
 518         if (!va_address)
 519                 return PCIBIOS_DEVICE_NOT_FOUND;
 520         if (size == 4) {
 521                 writel(val, va_address);
 522                 return (master_abort(bus, devfn, where))
 523                         ?PCIBIOS_DEVICE_NOT_FOUND:PCIBIOS_SUCCESSFUL;
 524         }
 525         if (size == 2)
 526                 mask = ~(0xFFFF << ((where & 0x3) * 8));
 527         else if (size == 1)
 528                 mask = ~(0xFF << ((where & 0x3) * 8));
 529         else
 530                 return PCIBIOS_BAD_REGISTER_NUMBER;
 531
 532         tmp = readl(va_address) & mask;
 533         tmp |= val << ((where & 0x3) * 8);
 534         writel(tmp, va_address);
 535         return (master_abort(bus, devfn, where))
 536                 ?PCIBIOS_DEVICE_NOT_FOUND:PCIBIOS_SUCCESSFUL;
 537 }
 538
 539 static struct pci_ops imx_pcie_ops = {
 540         .read = imx_pcie_rd_conf,
 541         .write = imx_pcie_wr_conf,
 542 };
 543
 544 signed short irq_map[] = {
 545         -EINVAL,
 546         MXC_INT_PCIE_3,         /* int a */
 547         MXC_INT_PCIE_2,         /* int b */
 548         MXC_INT_PCIE_1,         /* int c */
 549         MXC_INT_PCIE_0,         /* int d/MSI */
 550 };
 551
 552 static int imx_pcie_map_irq(const struct pci_dev *dev, u8 slot, u8 pin)
 553 {
 554         int val = -EINVAL;
 555         if (pin <= 4)
 556                 val = irq_map[pin];
 557         return val;
 558 }
 559
 560 static struct hw_pci imx_pci __initdata = {
 561         .nr_controllers = 1,
 562         .setup          = imx_pcie_setup,
 563         .ops    = &imx_pcie_ops,
 564         .map_irq        = imx_pcie_map_irq,
 565 };
 566
 567 /* PHY CR bus acess routines */
 568 static int pcie_phy_cr_ack_polling(int max_iterations, int exp_val)
 569 {
 570         u32 temp_rd_data, wait_counter = 0;
 571
 572         do {
 573                 temp_rd_data = readl(imx_pcie.dbi_base + PHY_STS_R);
 574                 temp_rd_data = (temp_rd_data >> PCIE_CR_STAT_ACK_LOC) & 0x1;
 575                 wait_counter++;
 576         } while ((wait_counter < max_iterations) && (temp_rd_data != exp_val));
 577
 578         if (temp_rd_data != exp_val)
 579                 return 0 ;
 580         return 1 ;
 581 }
 582
 583 static int pcie_phy_cr_cap_addr(int addr)
 584 {
 585         u32 temp_wr_data;
 586         void __iomem *dbi_base = imx_pcie.dbi_base;
 587
 588         /* write addr */
 589         temp_wr_data = addr << PCIE_CR_CTL_DATA_LOC ;
 590         writel(temp_wr_data, dbi_base + PHY_CTRL_R);
 591
 592         /* capture addr */
 593         temp_wr_data |= (0x1 << PCIE_CR_CTL_CAP_ADR_LOC);
 594         writel(temp_wr_data, dbi_base + PHY_CTRL_R);
 595
 596         /* wait for ack */
 597         if (!pcie_phy_cr_ack_polling(100, 1))
 598                 return 0;
 599
 600         /* deassert cap addr */
 601         temp_wr_data = addr << PCIE_CR_CTL_DATA_LOC;
 602         writel(temp_wr_data, dbi_base + PHY_CTRL_R);
 603
 604         /* wait for ack de-assetion */
 605         if (!pcie_phy_cr_ack_polling(100, 0))
 606                 return 0 ;
 607
 608         return 1 ;
 609 }
 610
 611 static int pcie_phy_cr_read(int addr , int *data)
 612 {
 613         u32 temp_rd_data, temp_wr_data;
 614         void __iomem *dbi_base = imx_pcie.dbi_base;
 615
 616         /*  write addr */
 617         /* cap addr */
 618         if (!pcie_phy_cr_cap_addr(addr))
 619                 return 0;
 620
 621         /* assert rd signal */
 622         temp_wr_data = 0x1 << PCIE_CR_CTL_RD_LOC;
 623         writel(temp_wr_data, dbi_base + PHY_CTRL_R);
 624
 625         /* wait for ack */
 626         if (!pcie_phy_cr_ack_polling(100, 1))
 627                 return 0;
 628
 629         /* after got ack return data */
 630         temp_rd_data = readl(dbi_base + PHY_STS_R);
 631         *data = (temp_rd_data & (0xffff << PCIE_CR_STAT_DATA_LOC)) ;
 632
 633         /* deassert rd signal */
 634         temp_wr_data = 0x0;
 635         writel(temp_wr_data, dbi_base + PHY_CTRL_R);
 636
 637         /* wait for ack de-assetion */
 638         if (!pcie_phy_cr_ack_polling(100, 0))
 639                 return 0 ;
 640
 641         return 1 ;
 642
 643 }
 644
 645 static int pcie_phy_cr_write(int addr, int data)
 646 {
 647         u32 temp_wr_data;
 648         void __iomem *dbi_base = imx_pcie.dbi_base;
 649
 650         /* write addr */
 651         /* cap addr */
 652         if (!pcie_phy_cr_cap_addr(addr))
 653                 return 0 ;
 654
 655         temp_wr_data = data << PCIE_CR_CTL_DATA_LOC;
 656         writel(temp_wr_data, dbi_base + PHY_CTRL_R);
 657
 658         /* capture data */
 659         temp_wr_data |= (0x1 << PCIE_CR_CTL_CAP_DAT_LOC);
 660         writel(temp_wr_data, dbi_base + PHY_CTRL_R);
 661
 662         /* wait for ack */
 663         if (!pcie_phy_cr_ack_polling(100, 1))
 664                 return 0 ;
 665
 666         /* deassert cap data */
 667         temp_wr_data = data << PCIE_CR_CTL_DATA_LOC;
 668         writel(temp_wr_data, dbi_base + PHY_CTRL_R);
 669
 670         /* wait for ack de-assetion */
 671         if (!pcie_phy_cr_ack_polling(100, 0))
 672                 return 0;
 673
 674         /* assert wr signal */
 675         temp_wr_data = 0x1 << PCIE_CR_CTL_WR_LOC;
 676         writel(temp_wr_data, dbi_base + PHY_CTRL_R);
 677
 678         /* wait for ack */
 679         if (!pcie_phy_cr_ack_polling(100, 1))
 680                 return 0;
 681
 682         /* deassert wr signal */
 683         temp_wr_data = data << PCIE_CR_CTL_DATA_LOC;
 684         writel(temp_wr_data, dbi_base + PHY_CTRL_R);
 685
 686         /* wait for ack de-assetion */
 687         if (!pcie_phy_cr_ack_polling(100, 0))
 688                 return 0;
 689
 690         temp_wr_data = 0x0 ;
 691         writel(temp_wr_data, dbi_base + PHY_CTRL_R);
 692
 693         return 1 ;
 694 }
 695
 696 static void change_field(int *in, int start, int end, int val)
 697 {
 698         int mask;
 699
 700         mask = ((0xFFFFFFFF << start) ^ (0xFFFFFFFF << (end + 1))) & 0xFFFFFFFF;
 701         *in = (*in & ~mask) | (val << start);
 702 }
 703
 704 static int imx_pcie_enable_controller(struct device *dev)
 705 {
 706         struct clk *clk;
 707         struct device_node *np = dev->of_node;
 708
 709         if (gpio_is_valid(imx_pcie.pcie_pwr_en)) {
 710                 /* Enable PCIE power */
 711                 gpio_request(imx_pcie.pcie_pwr_en, "PCIE POWER_EN");
 712
 713                 /* activate PCIE_PWR_EN */
 714                 gpio_direction_output(imx_pcie.pcie_pwr_en, 1);
 715         }
 716
 717         // power up PCIe PHY
 718         imx_pcie_clrset(iomuxc_gpr1_test_powerdown, 0 << 18, IOMUXC_GPR1);
 719
 720         /* enable the clks */
 721         if (np)
 722                 clk = of_clk_get(np, 0);
 723         else
 724                 clk = devm_clk_get(dev, "pcie_clk");
 725         if (IS_ERR(clk)) {
 726                 pr_err("no pcie clock.\n");
 727                 return -EINVAL;
 728         }
 729
 730         if (clk_prepare_enable(clk)) {
 731                 pr_err("can't enable pcie clock.\n");
 732                 clk_put(clk);
 733                 return -EINVAL;
 734         }
 735
 736         // Enable PCIe PHY ref clock
 737         imx_pcie_clrset(iomuxc_gpr1_pcie_ref_clk_en, 1 << 16, IOMUXC_GPR1);
 738
 739         return 0;
 740 }
 741
 742 static void card_reset(struct device *dev)
 743 {
 744         if (gpio_is_valid(imx_pcie.pcie_rst)) {
 745                 /* PCIE RESET */
 746                 gpio_request(imx_pcie.pcie_rst, "PCIE RESET");
 747
 748                 /* activate PERST_B */
 749                 gpio_direction_output(imx_pcie.pcie_rst, 0);
 750
 751                 /* Add one reset to the pcie external device */
 752                 msleep(100);
 753
 754                 /* deactive PERST_B */
 755                 gpio_direction_output(imx_pcie.pcie_rst, 1);
 756         }
 757 }
 758
 759 static void add_pcie_port(struct platform_device *pdev, void __iomem *base, void __iomem *dbi_base)
 760 {
 761         struct clk *clk;
 762         struct device *dev = &pdev->dev;
 763         struct device_node *np = dev->of_node;
 764
 765         if (imx_pcie_link_up(dbi_base)) {
 766                 struct imx_pcie_port *pp = &imx_pcie.imx_pcie_port[imx_pcie.num_pcie_ports++];
 767
 768                 pr_info("IMX PCIe port: link up.\n");
 769
 770                 pp->index = 0;
 771                 pp->root_bus_nr = -1;
 772                 pp->base = base;
 773                 pp->dbi_base = dbi_base;
 774                 spin_lock_init(&pp->conf_lock);
 775                 memset(pp->res, 0, sizeof(pp->res));
 776         } else {
 777                 pr_info("IMX PCIe port: link down!\n");
 778                 /* Release the clocks, and disable the power */
 779
 780                 if (np)
 781                         clk = of_clk_get(np, 0);
 782                 else
 783                         clk = clk_get(NULL, "pcie_clk");
 784                 if (IS_ERR(clk)) {
 785                         pr_err("no pcie clock.\n");
 786                         return;
 787                 }
 788
 789                 clk_disable_unprepare(clk);
 790                 clk_put(clk);
 791
 792                 // Disable the PCIE PHY Ref Clock
 793                 imx_pcie_clrset(iomuxc_gpr1_pcie_ref_clk_en, 0 << 16, IOMUXC_GPR1);
 794
 795                 if (gpio_is_valid(imx_pcie.pcie_pwr_en)) {
 796                         /* Disable PCIE power */
 797                         gpio_request(imx_pcie.pcie_pwr_en, "PCIE POWER_EN");
 798
 799                         /* activate PCIE_PWR_EN */
 800                         gpio_direction_output(imx_pcie.pcie_pwr_en, 0);
 801                 }
 802
 803                 // Power down PCIE PHY
 804                 imx_pcie_clrset(iomuxc_gpr1_test_powerdown, 1 << 18, IOMUXC_GPR1);
 805         }
 806 }
 807
 808 static int imx_pcie_abort_handler(unsigned long addr, unsigned int fsr,
 809                 struct pt_regs *regs)
 810 {
 811         unsigned long instr;
 812         unsigned long pc = instruction_pointer(regs) - 4;
 813
 814         instr = *(unsigned long *)pc;
 815 /* imprecise aborts are no longer enabled in 3.7+ during init it would appear.
 816  * We now using PCIE_RC_IOBLSSR to detect master abort however we will still get
 817  * at least one imprecise abort and need to have a handler.
 818  */
 819 #if 0
 820         if (instr == 0xf57ff04f) {
 821                 /* dsb sy */
 822                 pc -= 4;
 823                 instr = *(unsigned long *)pc;
 824         }
 825         pr_info("PCIe abort: address = 0x%08lx fsr = 0x%03x PC = 0x%08lx LR = 0x%08lx instr=%08lx\n",
 826                 addr, fsr, regs->ARM_pc, regs->ARM_lr, instr);
 827
 828
 829         /*
 830          * If the instruction being executed was a read,
 831          * make it look like it read all-ones.
 832          */
 833         if ((instr & 0x0c500000) == 0x04100000) {
 834                 /* LDR instruction */
 835                 int reg = (instr >> 12) & 15;
 836
 837                 regs->uregs[reg] = -1;
 838                 regs->ARM_pc = pc + 4;
 839                 return 0;
 840         }
 841         return 1;
 842 #else
 843         pr_info("PCIe abort: address = 0x%08lx fsr = 0x%03x PC = 0x%08lx LR = 0x%08lx instr=%08lx\n",
 844                 addr, fsr, regs->ARM_pc, regs->ARM_lr, instr);
 845
 846         return 0;
 847 #endif
 848 }
 849
 850
 851 static int imx_pcie_pltfm_probe(struct platform_device *pdev)
 852 {
 853         struct resource *mem;
 854         struct device *dev = &pdev->dev;
 855         struct device_node *np = pdev->dev.of_node;
 856         struct resource res;
 857         int ret;
 858
 859         if (!np) {
 860                 dev_err(&pdev->dev, "No of data found\n");
 861                 return -EINVAL;
 862         }
 863
 864         res.start = res.end = 0;
 865         ret = of_address_to_resource(np, 0, &res);
 866         if (ret)
 867                 goto err;
 868         mem = &res;
 869         imx_pcie.pcie_pwr_en = of_get_named_gpio(np, "pwren-gpios", 0);
 870         imx_pcie.pcie_rst = of_get_named_gpio(np, "rst-gpios", 0);
 871         imx_pcie.pcie_wake_up = of_get_named_gpio(np, "wake-gpios", 0);
 872         imx_pcie.pcie_dis = of_get_named_gpio(np, "dis-gpios", 0);
 873         //pdev->dev.platform_data = pdata;
 874
 875         imx_pcie.base = ioremap_nocache(PCIE_ARB_END_ADDR - SZ_1M + 1, SZ_1M - SZ_16K);
 876         if (!imx_pcie.base) {
 877                 pr_err("error with ioremap in function %s\n", __func__);
 878                 return -EIO;
 879         }
 880
 881         imx_pcie.dbi_base = devm_ioremap(dev, mem->start, resource_size(mem));
 882         if (!imx_pcie.dbi_base) {
 883                 dev_err(dev, "can't map %pR\n", mem);
 884                 return -ENOMEM;
 885         }
 886
 887         np = of_find_compatible_node(NULL, NULL, "fsl,imx6q-iomuxc-gpr");
 888         if (!np) {
 889                 dev_err(dev, "can't find iomux\n");
 890                 return -ENOMEM;
 891         }
 892         ret = of_address_to_resource(np, 0, &res);
 893         of_node_put(np);
 894         if (ret)
 895                 goto err;
 896         mem = &res;
 897         imx_pcie.gpr_base = devm_ioremap(dev, mem->start, resource_size(mem));
 898         if (!imx_pcie.gpr_base) {
 899                 dev_err(dev, "can't map %pR\n", mem);
 900                 return -ENOMEM;
 901         }
 902
 903         // hold LTSSM in detect state
 904         imx_pcie_clrset(iomuxc_gpr12_app_ltssm_enable, 0 << 10, IOMUXC_GPR12);
 905
 906         /* configure constant input signal to the pcie ctrl and phy */
 907         // set device type to RC (PCI_EXP_TYPE_ROOT_PORT=4 is from pcie_regs.h)
 908         imx_pcie_clrset(iomuxc_gpr12_device_type, PCI_EXP_TYPE_ROOT_PORT << 12, IOMUXC_GPR12);
 909         // loss of signal detect sensitivity function - must be 0x9
 910         imx_pcie_clrset(iomuxc_gpr12_los_level, 9 << 4, IOMUXC_GPR12);
 911         // not clear what values these should have from RM
 912         imx_pcie_clrset(iomuxc_gpr8_tx_deemph_gen1, 0 << 0, IOMUXC_GPR8);
 913         imx_pcie_clrset(iomuxc_gpr8_tx_deemph_gen2_3p5db, 0 << 6, IOMUXC_GPR8);
 914         imx_pcie_clrset(iomuxc_gpr8_tx_deemph_gen2_6db, 20 << 12, IOMUXC_GPR8);
 915         imx_pcie_clrset(iomuxc_gpr8_tx_swing_full, 127 << 18, IOMUXC_GPR8);
 916         imx_pcie_clrset(iomuxc_gpr8_tx_swing_low, 127 << 25, IOMUXC_GPR8);
 917
 918         /* Enable the pwr, clks and so on */
 919         ret = imx_pcie_enable_controller(dev);
 920         if (ret)
 921                 goto err;
 922
 923         /* togle the external card's reset */
 924         card_reset(dev) ;
 925
 926         usleep_range(3000, 4000);
 927         imx_pcie_regions_setup(imx_pcie.dbi_base);
 928         usleep_range(3000, 4000);
 929
 930         /*
 931          * Force to GEN1 because of PCIE2USB storage stress tests
 932          * would be failed when GEN2 is enabled
 933          */
 934         writel(((readl(imx_pcie.dbi_base + LNK_CAP) & 0xfffffff0) | 0x1),
 935                         imx_pcie.dbi_base + LNK_CAP);
 936
 937         /* start link up */
 938         imx_pcie_clrset(iomuxc_gpr12_app_ltssm_enable, 1 << 10, IOMUXC_GPR12);
 939
 940         hook_fault_code(16 + 6, imx_pcie_abort_handler, SIGBUS, 0,
 941                         "imprecise external abort");
 942
 943         /* add the pcie port */
 944         add_pcie_port(pdev, imx_pcie.base, imx_pcie.dbi_base);
 945
 946         pci_common_init(&imx_pci);
 947
 948         return 0;
 949
 950 err:
 951         return ret;
 952 }
 953
 954 static int imx_pcie_pltfm_remove(struct platform_device *pdev)
 955 {
 956         struct clk *clk;
 957         struct device *dev = &pdev->dev;
 958         struct device_node *np = dev->of_node;
 959         struct resource *iomem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 960
 961         /* Release clocks, and disable power  */
 962         if (np)
 963                 clk = of_clk_get(np, 0);
 964         else
 965                 clk = devm_clk_get(dev, "pcie_clk");
 966         if (IS_ERR(clk))
 967                 pr_err("no pcie clock.\n");
 968
 969         if (clk) {
 970                 clk_disable_unprepare(clk);
 971                 clk_put(clk);
 972         }
 973
 974         // disable PCIe PHY clock ref
 975         imx_pcie_clrset(iomuxc_gpr1_pcie_ref_clk_en, 0 << 16, IOMUXC_GPR1);
 976
 977         if (gpio_is_valid(imx_pcie.pcie_pwr_en)) {
 978                 /* Disable PCIE power */
 979                 gpio_request(imx_pcie.pcie_pwr_en, "PCIE POWER_EN");
 980
 981                 /* activate PCIE_PWR_EN */
 982                 gpio_direction_output(imx_pcie.pcie_pwr_en, 0);
 983         }
 984
 985         // power down PCIe PHY
 986         imx_pcie_clrset(iomuxc_gpr1_test_powerdown, 1 << 18, IOMUXC_GPR1);
 987
 988         iounmap(imx_pcie.base);
 989         iounmap(imx_pcie.dbi_base);
 990         iounmap(imx_pcie.gpr_base);
 991         release_mem_region(iomem->start, resource_size(iomem));
 992         //platform_set_drvdata(pdev, NULL);
 993
 994         return 0;
 995 }
 996
 997 static const struct of_device_id of_imx_pcie_match[] = {
 998         { .compatible = "fsl,pcie" },
 999         {}
1000 };
1001 MODULE_DEVICE_TABLE(of, of_imx_pcie_match);
1002
1003 static struct platform_driver imx_pcie_pltfm_driver = {
1004         .driver = {
1005                 .name   = "imx-pcie",
1006                 .owner  = THIS_MODULE,
1007                 .of_match_table = of_imx_pcie_match,
1008         },
1009         .probe          = imx_pcie_pltfm_probe,
1010         .remove         = imx_pcie_pltfm_remove,
1011 };
1012
1013 /*****************************************************************************\
1014  *                                                                           *
1015  * Driver init/exit                                                          *
1016  *                                                                           *
1017 \*****************************************************************************/
1018
1019 static int __init imx_pcie_drv_init(void)
1020 {
1021         pcibios_min_io = 0;
1022         pcibios_min_mem = 0;
1023
1024         return platform_driver_register(&imx_pcie_pltfm_driver);
1025 }
1026
1027 static void __exit imx_pcie_drv_exit(void)
1028 {
1029         platform_driver_unregister(&imx_pcie_pltfm_driver);
1030 }
1031
1032 //module_init(imx_pcie_drv_init);
1033 //module_exit(imx_pcie_drv_exit);
1034 late_initcall(imx_pcie_drv_init);
1035
1036 MODULE_DESCRIPTION("i.MX PCIE platform driver");
1037 MODULE_LICENSE("GPL v2");