b7d7eefe26619779abd3bcc245d92a7e63ae74ec
[linux-2.6.git] / arch / arm / mach-tegra / pcie.c
1 /*
2  * arch/arm/mach-tegra/pcie.c
3  *
4  * PCIe host controller driver for TEGRA SOCs
5  *
6  * Copyright (c) 2010, CompuLab, Ltd.
7  * Author: Mike Rapoport <mike@compulab.co.il>
8  *
9  * Based on NVIDIA PCIe driver
10  * Copyright (c) 2008-2012, NVIDIA Corporation.
11  *
12  * Bits taken from arch/arm/mach-dove/pcie.c
13  *
14  * This program is free software; you can redistribute it and/or modify
15  * it under the terms of the GNU General Public License as published by
16  * the Free Software Foundation; either version 2 of the License, or
17  * (at your option) any later version.
18  *
19  * This program is distributed in the hope that it will be useful, but WITHOUT
20  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
21  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
22  * more details.
23  *
24  * You should have received a copy of the GNU General Public License along
25  * with this program; if not, write to the Free Software Foundation, Inc.,
26  * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
27  */
28
29 #include <linux/kernel.h>
30 #include <linux/pci.h>
31 #include <linux/interrupt.h>
32 #include <linux/irq.h>
33 #include <linux/clk.h>
34 #include <linux/delay.h>
35 #include <linux/msi.h>
36 #include <linux/platform_device.h>
37 #include <linux/regulator/consumer.h>
38
39 #include <asm/sizes.h>
40 #include <asm/mach/pci.h>
41
42 #include <mach/pinmux.h>
43 #include <mach/iomap.h>
44 #include <mach/clk.h>
45 #include <mach/powergate.h>
46 #include <mach/pci.h>
47
48 #define MSELECT_CONFIG_0_ENABLE_PCIE_APERTURE                           5
49
50 #define PINMUX_AUX_PEX_L0_RST_N_0                                       0x33bc
51 #define PINMUX_AUX_PEX_L0_RST_N_0_E_INPUT                               5
52 #define PINMUX_AUX_PEX_L0_RST_N_0_E_INPUT_ENABLE                        1
53
54 #define PINMUX_AUX_PEX_L1_RST_N_0                                       0x33cc
55 #define PINMUX_AUX_PEX_L1_RST_N_0_E_INPUT                               5
56 #define PINMUX_AUX_PEX_L1_RST_N_0_E_INPUT_ENABLE                        1
57
58 #define PINMUX_AUX_PEX_L2_RST_N_0                                       0x33d8
59 #define PINMUX_AUX_PEX_L2_RST_N_0_E_INPUT                               5
60 #define PINMUX_AUX_PEX_L2_RST_N_0_E_INPUT_ENABLE                        1
61 #define AFI_PEX0_CTRL_0_PEX0_CLKREQ_EN                                  1
62 #define NV_PCIE2_PADS_REFCLK_CFG1                               0x000000cc
63 #define APBDEV_PMC_SCRATCH42_0_PCX_CLAMP_MASK                           0x1
64
65
66 #define AFI_MSI_VEC0_0                                                  0x6c
67 #define AFI_MSI_VEC1_0                                                  0x70
68 #define AFI_MSI_VEC2_0                                                  0x74
69 #define AFI_MSI_VEC3_0                                                  0x78
70 #define AFI_MSI_VEC4_0                                                  0x7c
71 #define AFI_MSI_VEC5_0                                                  0x80
72 #define AFI_MSI_VEC6_0                                                  0x84
73 #define AFI_MSI_VEC7_0                                                  0x88
74
75 #define AFI_MSI_EN_VEC0_0                                               0x8c
76 #define AFI_MSI_EN_VEC1_0                                               0x90
77 #define AFI_MSI_EN_VEC2_0                                               0x94
78 #define AFI_MSI_EN_VEC3_0                                               0x98
79 #define AFI_MSI_EN_VEC4_0                                               0x9c
80 #define AFI_MSI_EN_VEC5_0                                               0xa0
81 #define AFI_MSI_EN_VEC6_0                                               0xa4
82 #define AFI_MSI_EN_VEC7_0                                               0xa8
83
84 #define AFI_MSI_FPCI_BAR_ST_0                                           0x64
85 #define AFI_MSI_BAR_SZ_0                                                0x60
86 #define AFI_MSI_AXI_BAR_ST_0                                            0x68
87 #define AFI_INTR_MASK_0                                                 0xb4
88 #define AFI_INTR_MASK_0_INT_MASK                                        0
89 #define AFI_INTR_MASK_0_MSI_MASK                                        8
90
91
92 #define AFI_PEXBIAS_CTRL_0                                              0x168
93
94
95 /* register definitions */
96 #define AFI_OFFSET                                                      0x3800
97 #define PADS_OFFSET                                                     0x3000
98 #define RP_OFFSET                                                       0x1000
99
100 #define AFI_AXI_BAR0_SZ                                                 0x00
101 #define AFI_AXI_BAR1_SZ                                                 0x04
102 #define AFI_AXI_BAR2_SZ                                                 0x08
103 #define AFI_AXI_BAR3_SZ                                                 0x0c
104 #define AFI_AXI_BAR4_SZ                                                 0x10
105 #define AFI_AXI_BAR5_SZ                                                 0x14
106
107 #define AFI_AXI_BAR0_START                                              0x18
108 #define AFI_AXI_BAR1_START                                              0x1c
109 #define AFI_AXI_BAR2_START                                              0x20
110 #define AFI_AXI_BAR3_START                                              0x24
111 #define AFI_AXI_BAR4_START                                              0x28
112 #define AFI_AXI_BAR5_START                                              0x2c
113
114 #define AFI_FPCI_BAR0                                                   0x30
115 #define AFI_FPCI_BAR1                                                   0x34
116 #define AFI_FPCI_BAR2                                                   0x38
117 #define AFI_FPCI_BAR3                                                   0x3c
118 #define AFI_FPCI_BAR4                                                   0x40
119 #define AFI_FPCI_BAR5                                                   0x44
120
121 #define AFI_CACHE_BAR0_SZ                                               0x48
122 #define AFI_CACHE_BAR0_ST                                               0x4c
123 #define AFI_CACHE_BAR1_SZ                                               0x50
124 #define AFI_CACHE_BAR1_ST                                               0x54
125
126 #define AFI_MSI_BAR_SZ                                                  0x60
127 #define AFI_MSI_FPCI_BAR_ST                                             0x64
128 #define AFI_MSI_AXI_BAR_ST                                              0x68
129
130 #define AFI_CONFIGURATION                                               0xac
131 #define AFI_CONFIGURATION_EN_FPCI                               (1 << 0)
132
133 #define AFI_FPCI_ERROR_MASKS                                            0xb0
134
135 #define AFI_INTR_MASK                                                   0xb4
136 #define AFI_INTR_MASK_INT_MASK                                  (1 << 0)
137 #define AFI_INTR_MASK_MSI_MASK                                  (1 << 8)
138
139 #define AFI_INTR_CODE                                                   0xb8
140 #define  AFI_INTR_CODE_MASK                                             0xf
141 #define  AFI_INTR_MASTER_ABORT                                          4
142 #define  AFI_INTR_LEGACY                                                6
143
144 #define AFI_INTR_SIGNATURE                                              0xbc
145 #define AFI_SM_INTR_ENABLE                                              0xc4
146
147 #define AFI_AFI_INTR_ENABLE                                             0xc8
148 #define AFI_INTR_EN_INI_SLVERR                                  (1 << 0)
149 #define AFI_INTR_EN_INI_DECERR                                  (1 << 1)
150 #define AFI_INTR_EN_TGT_SLVERR                                  (1 << 2)
151 #define AFI_INTR_EN_TGT_DECERR                                  (1 << 3)
152 #define AFI_INTR_EN_TGT_WRERR                                   (1 << 4)
153 #define AFI_INTR_EN_DFPCI_DECERR                                        (1 << 5)
154 #define AFI_INTR_EN_AXI_DECERR                                          (1 << 6)
155 #define AFI_INTR_EN_FPCI_TIMEOUT                                        (1 << 7)
156 #define AFI_INTR_EN_PRSNT_SENSE                                 (1 << 8)
157
158 #define AFI_PCIE_CONFIG                                                 0x0f8
159 #define AFI_PCIE_CONFIG_PCIEC0_DISABLE_DEVICE                   (1 << 1)
160 #define AFI_PCIE_CONFIG_PCIEC1_DISABLE_DEVICE                   (1 << 2)
161 #define AFI_PCIE_CONFIG_PCIEC2_DISABLE_DEVICE                   (1 << 3)
162 #define AFI_PCIE_CONFIG_SM2TMS0_XBAR_CONFIG_MASK                (0xf << 20)
163 #define AFI_PCIE_CONFIG_SM2TMS0_XBAR_CONFIG_SINGLE              (0x0 << 20)
164 #define AFI_PCIE_CONFIG_SM2TMS0_XBAR_CONFIG_DUAL                (0x1 << 20)
165 #define AFI_PCIE_CONFIG_SM2TMS0_XBAR_CONFIG_411                 (0x2 << 20)
166
167 #define AFI_FUSE                                                        0x104
168 #define AFI_FUSE_PCIE_T0_GEN2_DIS                               (1 << 2)
169
170 #define AFI_PEX0_CTRL                                                   0x110
171 #define AFI_PEX1_CTRL                                                   0x118
172 #define AFI_PEX2_CTRL                                                   0x128
173 #define AFI_PEX_CTRL_RST                                        (1 << 0)
174 #define AFI_PEX_CTRL_REFCLK_EN                                  (1 << 3)
175
176 #define RP_VEND_XP                                              0x00000F00
177 #define RP_VEND_XP_DL_UP                                        (1 << 30)
178
179 #define RP_LINK_CONTROL_STATUS                                  0x00000090
180 #define RP_LINK_CONTROL_STATUS_LINKSTAT_MASK                    0x3fff0000
181
182 #define PADS_CTL_SEL                                            0x0000009C
183
184 #define PADS_CTL                                                0x000000A0
185 #define PADS_CTL_IDDQ_1L                                        (1 << 0)
186 #define PADS_CTL_TX_DATA_EN_1L                                  (1 << 6)
187 #define PADS_CTL_RX_DATA_EN_1L                                  (1 << 10)
188
189 #ifdef CONFIG_ARCH_TEGRA_2x_SOC
190 #define  PADS_PLL_CTL                                           0x000000B8
191 #else
192 #define  PADS_PLL_CTL                                           0x000000B4
193 #endif
194 #define  PADS_PLL_CTL_RST_B4SM                                  (1 << 1)
195 #define  PADS_PLL_CTL_LOCKDET                                   (1 << 8)
196 #define  PADS_PLL_CTL_REFCLK_MASK                               (0x3 << 16)
197 #define  PADS_PLL_CTL_REFCLK_INTERNAL_CML                       (0 << 16)
198 #define  PADS_PLL_CTL_REFCLK_INTERNAL_CMOS                      (1 << 16)
199 #define  PADS_PLL_CTL_REFCLK_EXTERNAL                           (2 << 16)
200 #define  PADS_PLL_CTL_TXCLKREF_MASK                             (0x1 << 20)
201 #define  PADS_PLL_CTL_TXCLKREF_BUF_EN                           (1 << 22)
202 #define  PADS_PLL_CTL_TXCLKREF_DIV10                            (0 << 20)
203 #define  PADS_PLL_CTL_TXCLKREF_DIV5                             (1 << 20)
204
205 /* PMC access is required for PCIE xclk (un)clamping */
206 #define PMC_SCRATCH42                                           0x144
207 #define PMC_SCRATCH42_PCX_CLAMP                         (1 << 0)
208
209 #define NV_PCIE2_RP_PRIV_MISC                                   0x00000FE0
210 #define PCIE2_RP_PRIV_MISC_CTLR_CLK_CLAMP_ENABLE                1 << 23
211 #define PCIE2_RP_PRIV_MISC_TMS_CLK_CLAMP_ENABLE         1 << 31
212
213 #ifdef CONFIG_ARCH_TEGRA_2x_SOC
214 /*
215  * Tegra2 defines 1GB in the AXI address map for PCIe.
216  *
217  * That address space is split into different regions, with sizes and
218  * offsets as follows:
219  *
220  * 0x80000000 - 0x80003fff - PCI controller registers
221  * 0x80004000 - 0x80103fff - PCI configuration space
222  * 0x80104000 - 0x80203fff - PCI extended configuration space
223  * 0x80203fff - 0x803fffff - unused
224  * 0x80400000 - 0x8040ffff - downstream IO
225  * 0x80410000 - 0x8fffffff - unused
226  * 0x90000000 - 0x9fffffff - non-prefetchable memory
227  * 0xa0000000 - 0xbfffffff - prefetchable memory
228  */
229 #define TEGRA_PCIE_BASE         0x80000000
230
231 #define PCIE_REGS_SZ            SZ_16K
232 #define PCIE_CFG_OFF            PCIE_REGS_SZ
233 #define PCIE_CFG_SZ             SZ_1M
234 #define PCIE_EXT_CFG_OFF        (PCIE_CFG_SZ + PCIE_CFG_OFF)
235 #define PCIE_EXT_CFG_SZ         SZ_1M
236 #define PCIE_IOMAP_SZ           (PCIE_REGS_SZ + PCIE_CFG_SZ + PCIE_EXT_CFG_SZ)
237
238 #define MMIO_BASE               (TEGRA_PCIE_BASE + SZ_4M)
239 #define MMIO_SIZE               SZ_64K
240 #define MEM_BASE_0              (TEGRA_PCIE_BASE + SZ_256M)
241 #define MEM_SIZE                SZ_256M
242 #define PREFETCH_MEM_BASE_0     (MEM_BASE_0 + MEM_SIZE)
243 #define PREFETCH_MEM_SIZE       SZ_512M
244
245 #else
246
247 /*
248  * AXI address map for the PCIe aperture , defines 1GB in the AXI
249  *  address map for PCIe.
250  *
251  *  That address space is split into different regions, with sizes and
252  *  offsets as follows. Exepct for the Register space, SW is free to slice the
253  *  regions as it chooces.
254  *
255  *  The split below seems to work fine for now.
256  *
257  *  0x0000_0000 to 0x00ff_ffff - Register space          16MB.
258  *  0x0100_0000 to 0x01ff_ffff - Config space            16MB.
259  *  0x0200_0000 to 0x02ff_ffff - Extended config space   16MB.
260  *  0x0300_0000 to 0x03ff_ffff - Downstream IO space
261  *   ... Will be filled with other BARS like MSI/upstream IO etc.
262  *  0x1000_0000 to 0x1fff_ffff - non-prefetchable memory aperture
263  *  0x2000_0000 to 0x3fff_ffff - Prefetchable memory aperture
264  *
265  *  Config and Extended config sizes are choosen to support
266  *  maximum of 256 devices,
267  *  which is good enough for all the current use cases.
268  *
269  */
270 #define TEGRA_PCIE_BASE 0x00000000
271
272 #define PCIE_REGS_SZ            SZ_16M
273 #define PCIE_CFG_OFF            PCIE_REGS_SZ
274 #define PCIE_CFG_SZ             SZ_16M
275 #define PCIE_EXT_CFG_OFF        (PCIE_CFG_SZ + PCIE_CFG_OFF)
276 #define PCIE_EXT_CFG_SZ         SZ_16M
277 /* During the boot only registers/config and extended config apertures are
278  * mapped. Rest are mapped on demand by the PCI device drivers.
279  */
280 #define PCIE_IOMAP_SZ           (PCIE_REGS_SZ + PCIE_CFG_SZ + PCIE_EXT_CFG_SZ)
281
282 #define MMIO_BASE                               (TEGRA_PCIE_BASE + SZ_48M)
283 #define MMIO_SIZE                                                       SZ_1M
284 #define MEM_BASE_0                              (TEGRA_PCIE_BASE + SZ_256M)
285 #define MEM_SIZE                                                        SZ_256M
286 #define PREFETCH_MEM_BASE_0                     (MEM_BASE_0 + MEM_SIZE)
287 #define PREFETCH_MEM_SIZE                                               SZ_512M
288 #endif
289
290 #define  PCIE_CONF_BUS(b)                                       ((b) << 16)
291 #define  PCIE_CONF_DEV(d)                                       ((d) << 11)
292 #define  PCIE_CONF_FUNC(f)                                      ((f) << 8)
293 #define  PCIE_CONF_REG(r)       \
294         (((r) & ~0x3) | (((r) < 256) ? PCIE_CFG_OFF : PCIE_EXT_CFG_OFF))
295
296 struct tegra_pcie_port {
297         int                     index;
298         u8                      root_bus_nr;
299         void __iomem            *base;
300
301         bool                    link_up;
302
303         char                    io_space_name[16];
304         char                    mem_space_name[16];
305         char                    prefetch_space_name[20];
306         struct resource         res[3];
307 };
308
309 struct tegra_pcie_info {
310         struct tegra_pcie_port  port[MAX_PCIE_SUPPORTED_PORTS];
311         int                     num_ports;
312
313         void __iomem            *reg_clk_base;
314         void __iomem            *regs;
315         struct resource         res_mmio;
316         int                     power_rails_enabled;
317         int                     pcie_power_enabled;
318
319         struct regulator        *regulator_hvdd;
320         struct regulator        *regulator_pexio;
321         struct regulator        *regulator_avdd_plle;
322         struct clk              *pcie_xclk;
323         struct clk              *pll_e;
324         struct tegra_pci_platform_data *plat_data;
325 };
326
327 #define pmc_writel(value, reg) \
328         __raw_writel(value, (u32)reg_pmc_base + (reg))
329 #define pmc_readl(reg) \
330         __raw_readl((u32)reg_pmc_base + (reg))
331
332 static void __iomem *reg_pmc_base = IO_ADDRESS(TEGRA_PMC_BASE);
333
334 static struct tegra_pcie_info tegra_pcie = {
335         .res_mmio = {
336                 .name = "PCI IO",
337                 .start = MMIO_BASE,
338                 .end = MMIO_BASE + MMIO_SIZE - 1,
339                 .flags = IORESOURCE_MEM,
340         },
341 };
342
343 static struct resource pcie_io_space;
344 static struct resource pcie_mem_space;
345 static struct resource pcie_prefetch_mem_space;
346
347 void __iomem *tegra_pcie_io_base;
348 EXPORT_SYMBOL(tegra_pcie_io_base);
349
350 static inline void afi_writel(u32 value, unsigned long offset)
351 {
352         writel(value, offset + AFI_OFFSET + tegra_pcie.regs);
353 }
354
355 static inline u32 afi_readl(unsigned long offset)
356 {
357         return readl(offset + AFI_OFFSET + tegra_pcie.regs);
358 }
359
360 static inline void pads_writel(u32 value, unsigned long offset)
361 {
362         writel(value, offset + PADS_OFFSET + tegra_pcie.regs);
363 }
364
365 static inline u32 pads_readl(unsigned long offset)
366 {
367         return readl(offset + PADS_OFFSET + tegra_pcie.regs);
368 }
369
370 static inline void rp_writel(u32 value, unsigned long offset, int rp)
371 {
372         BUG_ON(rp != 0 && rp != 1 && rp != 2);
373         offset += rp * (0x1UL << (rp - 1)) * RP_OFFSET;
374         writel(value, offset + tegra_pcie.regs);
375 }
376
377 static inline unsigned int rp_readl(unsigned long offset, int rp)
378 {
379         BUG_ON(rp != 0 && rp != 1 && rp != 2);
380         offset += rp * (0x1UL << (rp - 1)) * RP_OFFSET;
381         return readl(offset + tegra_pcie.regs);
382 }
383
384 static struct tegra_pcie_port *bus_to_port(int bus)
385 {
386         int i;
387
388         for (i = tegra_pcie.num_ports - 1; i >= 0; i--) {
389                 int rbus = tegra_pcie.port[i].root_bus_nr;
390                 if (rbus != -1 && rbus == bus)
391                         break;
392         }
393
394         return i >= 0 ? tegra_pcie.port + i : NULL;
395 }
396
397 static int tegra_pcie_read_conf(struct pci_bus *bus, unsigned int devfn,
398                                 int where, int size, u32 *val)
399 {
400         struct tegra_pcie_port *pp = bus_to_port(bus->number);
401         void __iomem *addr;
402
403         if (pp) {
404                 if (devfn != 0) {
405                         *val = 0xffffffff;
406                         return PCIBIOS_DEVICE_NOT_FOUND;
407                 }
408
409                 addr = pp->base + (where & ~0x3);
410         } else {
411                 addr = tegra_pcie.regs + (PCIE_CONF_BUS(bus->number) +
412                                           PCIE_CONF_DEV(PCI_SLOT(devfn)) +
413                                           PCIE_CONF_FUNC(PCI_FUNC(devfn)) +
414                                           PCIE_CONF_REG(where));
415         }
416
417         *val = readl(addr);
418
419         if (size == 1)
420                 *val = (*val >> (8 * (where & 3))) & 0xff;
421         else if (size == 2)
422                 *val = (*val >> (8 * (where & 3))) & 0xffff;
423
424         return PCIBIOS_SUCCESSFUL;
425 }
426
427 static int tegra_pcie_write_conf(struct pci_bus *bus, unsigned int devfn,
428                                  int where, int size, u32 val)
429 {
430         struct tegra_pcie_port *pp = bus_to_port(bus->number);
431         void __iomem *addr;
432
433         u32 mask;
434         u32 tmp;
435         /* pcie core is supposed to enable bus mastering and io/mem responses
436          * if its not setting then enable corresponding bits in pci_command
437          */
438         if (where == PCI_COMMAND) {
439                 if (!(val & PCI_COMMAND_IO))
440                         val |= PCI_COMMAND_IO;
441                 if (!(val & PCI_COMMAND_MEMORY))
442                         val |= PCI_COMMAND_MEMORY;
443                 if (!(val & PCI_COMMAND_MASTER))
444                         val |= PCI_COMMAND_MASTER;
445                 if (!(val & PCI_COMMAND_SERR))
446                         val |= PCI_COMMAND_SERR;
447         }
448
449         if (pp) {
450                 if (devfn != 0)
451                         return PCIBIOS_DEVICE_NOT_FOUND;
452
453                 addr = pp->base + (where & ~0x3);
454         } else {
455                 addr = tegra_pcie.regs + (PCIE_CONF_BUS(bus->number) +
456                                           PCIE_CONF_DEV(PCI_SLOT(devfn)) +
457                                           PCIE_CONF_FUNC(PCI_FUNC(devfn)) +
458                                           PCIE_CONF_REG(where));
459         }
460
461         if (size == 4) {
462                 writel(val, addr);
463                 return PCIBIOS_SUCCESSFUL;
464         }
465
466         if (size == 2)
467                 mask = ~(0xffff << ((where & 0x3) * 8));
468         else if (size == 1)
469                 mask = ~(0xff << ((where & 0x3) * 8));
470         else
471                 return PCIBIOS_BAD_REGISTER_NUMBER;
472
473         tmp = readl(addr) & mask;
474         tmp |= val << ((where & 0x3) * 8);
475         writel(tmp, addr);
476
477         return PCIBIOS_SUCCESSFUL;
478 }
479
480 static struct pci_ops tegra_pcie_ops = {
481         .read   = tegra_pcie_read_conf,
482         .write  = tegra_pcie_write_conf,
483 };
484
485 static void __devinit tegra_pcie_fixup_bridge(struct pci_dev *dev)
486 {
487         u16 reg;
488
489         if ((dev->class >> 16) == PCI_BASE_CLASS_BRIDGE) {
490                 pci_read_config_word(dev, PCI_COMMAND, &reg);
491                 reg |= (PCI_COMMAND_IO | PCI_COMMAND_MEMORY |
492                         PCI_COMMAND_MASTER | PCI_COMMAND_SERR);
493                 pci_write_config_word(dev, PCI_COMMAND, reg);
494         }
495 }
496 DECLARE_PCI_FIXUP_FINAL(PCI_ANY_ID, PCI_ANY_ID, tegra_pcie_fixup_bridge);
497
498 /* Tegra PCIE root complex wrongly reports device class */
499 static void __devinit tegra_pcie_fixup_class(struct pci_dev *dev)
500 {
501         dev->class = PCI_CLASS_BRIDGE_PCI << 8;
502 }
503
504 #ifdef CONFIG_ARCH_TEGRA_2x_SOC
505 DECLARE_PCI_FIXUP_EARLY(PCI_VENDOR_ID_NVIDIA, 0x0bf0, tegra_pcie_fixup_class);
506 DECLARE_PCI_FIXUP_EARLY(PCI_VENDOR_ID_NVIDIA, 0x0bf1, tegra_pcie_fixup_class);
507 #else
508 DECLARE_PCI_FIXUP_EARLY(PCI_VENDOR_ID_NVIDIA, 0x0e1c, tegra_pcie_fixup_class);
509 DECLARE_PCI_FIXUP_EARLY(PCI_VENDOR_ID_NVIDIA, 0x0e1d, tegra_pcie_fixup_class);
510 #endif
511
512 /* Tegra PCIE requires relaxed ordering */
513 static void __devinit tegra_pcie_relax_enable(struct pci_dev *dev)
514 {
515         u16 val16;
516         int pos = pci_find_capability(dev, PCI_CAP_ID_EXP);
517
518         if (pos <= 0) {
519                 dev_err(&dev->dev, "skipping relaxed ordering fixup\n");
520                 return;
521         }
522
523         pci_read_config_word(dev, pos + PCI_EXP_DEVCTL, &val16);
524         val16 |= PCI_EXP_DEVCTL_RELAX_EN;
525         pci_write_config_word(dev, pos + PCI_EXP_DEVCTL, val16);
526 }
527 DECLARE_PCI_FIXUP_FINAL(PCI_ANY_ID, PCI_ANY_ID, tegra_pcie_relax_enable);
528
529 static void __init tegra_pcie_preinit(void)
530 {
531         pcie_io_space.name = "PCIe I/O Space";
532         pcie_io_space.start = PCIBIOS_MIN_IO;
533         pcie_io_space.end = IO_SPACE_LIMIT;
534         pcie_io_space.flags = IORESOURCE_IO;
535         if (request_resource(&ioport_resource, &pcie_io_space))
536                 panic("can't allocate PCIe I/O space");
537
538         pcie_mem_space.name = "PCIe MEM Space";
539         pcie_mem_space.start = MEM_BASE_0;
540         pcie_mem_space.end = MEM_BASE_0 + MEM_SIZE - 1;
541         pcie_mem_space.flags = IORESOURCE_MEM;
542         if (request_resource(&iomem_resource, &pcie_mem_space))
543                 panic("can't allocate PCIe MEM space");
544
545         pcie_prefetch_mem_space.name = "PCIe PREFETCH MEM Space";
546         pcie_prefetch_mem_space.start = PREFETCH_MEM_BASE_0;
547         pcie_prefetch_mem_space.end = PREFETCH_MEM_BASE_0 + PREFETCH_MEM_SIZE
548                                         - 1;
549         pcie_prefetch_mem_space.flags = IORESOURCE_MEM | IORESOURCE_PREFETCH;
550         if (request_resource(&iomem_resource, &pcie_prefetch_mem_space))
551                 panic("can't allocate PCIe PREFETCH MEM space");
552
553 }
554
555 static int tegra_pcie_setup(int nr, struct pci_sys_data *sys)
556 {
557         struct tegra_pcie_port *pp;
558
559         if (nr >= tegra_pcie.num_ports)
560                 return 0;
561
562         pp = tegra_pcie.port + nr;
563         pp->root_bus_nr = sys->busnr;
564
565         sys->resource[0] = &pcie_io_space;
566         sys->resource[1] = &pcie_mem_space;
567         sys->resource[2] = &pcie_prefetch_mem_space;
568
569         return 1;
570 }
571
572 static int tegra_pcie_map_irq(const struct pci_dev *dev, u8 slot, u8 pin)
573 {
574         return INT_PCIE_INTR;
575 }
576
577 static struct pci_bus *tegra_pcie_scan_bus(int nr,
578                                                   struct pci_sys_data *sys)
579 {
580         struct tegra_pcie_port *pp;
581
582         if (nr >= tegra_pcie.num_ports)
583                 return 0;
584
585         pp = tegra_pcie.port + nr;
586         pp->root_bus_nr = sys->busnr;
587
588         return pci_scan_bus(sys->busnr, &tegra_pcie_ops, sys);
589 }
590
591 static struct hw_pci tegra_pcie_hw = {
592         .nr_controllers = MAX_PCIE_SUPPORTED_PORTS,
593         .preinit        = tegra_pcie_preinit,
594         .setup          = tegra_pcie_setup,
595         .scan           = tegra_pcie_scan_bus,
596         .swizzle        = pci_std_swizzle,
597         .map_irq        = tegra_pcie_map_irq,
598 };
599
600
601 static irqreturn_t tegra_pcie_isr(int irq, void *arg)
602 {
603         const char *err_msg[] = {
604                 "Unknown",
605                 "AXI slave error",
606                 "AXI decode error",
607                 "Target abort",
608                 "Master abort",
609                 "Invalid write",
610                 ""
611                 "Response decoding error",
612                 "AXI response decoding error",
613                 "Transcation timeout",
614         };
615
616         u32 code, signature;
617
618         code = afi_readl(AFI_INTR_CODE) & AFI_INTR_CODE_MASK;
619         signature = afi_readl(AFI_INTR_SIGNATURE);
620         afi_writel(0, AFI_INTR_CODE);
621
622         if (code == AFI_INTR_LEGACY)
623                 return IRQ_NONE;
624
625         if (code >= ARRAY_SIZE(err_msg))
626                 code = 0;
627
628         /*
629          * do not pollute kernel log with master abort reports since they
630          * happen a lot during enumeration
631          */
632         if (code == AFI_INTR_MASTER_ABORT)
633                 pr_debug("PCIE: %s, signature: %08x\n",
634                                 err_msg[code], signature);
635         else
636                 pr_err("PCIE: %s, signature: %08x\n", err_msg[code], signature);
637
638         return IRQ_HANDLED;
639 }
640
641 /*
642  *  PCIe support functions
643  */
644 static void tegra_pcie_setup_translations(void)
645 {
646         u32 fpci_bar;
647         u32 size;
648         u32 axi_address;
649
650         /* Bar 0: config Bar */
651         fpci_bar = ((u32)0xfdff << 16);
652         size = PCIE_CFG_SZ;
653         axi_address = TEGRA_PCIE_BASE + PCIE_CFG_OFF;
654         afi_writel(axi_address, AFI_AXI_BAR0_START);
655         afi_writel(size >> 12, AFI_AXI_BAR0_SZ);
656         afi_writel(fpci_bar, AFI_FPCI_BAR0);
657
658         /* Bar 1: extended config Bar */
659         fpci_bar = ((u32)0xfe1 << 20);
660         size = PCIE_EXT_CFG_SZ;
661         axi_address = TEGRA_PCIE_BASE + PCIE_EXT_CFG_OFF;
662         afi_writel(axi_address, AFI_AXI_BAR1_START);
663         afi_writel(size >> 12, AFI_AXI_BAR1_SZ);
664         afi_writel(fpci_bar, AFI_FPCI_BAR1);
665
666         /* Bar 2: downstream IO bar */
667         fpci_bar = ((__u32)0xfdfc << 16);
668         size = MMIO_SIZE;
669         axi_address = MMIO_BASE;
670         afi_writel(axi_address, AFI_AXI_BAR2_START);
671         afi_writel(size >> 12, AFI_AXI_BAR2_SZ);
672         afi_writel(fpci_bar, AFI_FPCI_BAR2);
673
674         /* Bar 3: prefetchable memory BAR */
675         fpci_bar = (((PREFETCH_MEM_BASE_0 >> 12) & 0x0fffffff) << 4) | 0x1;
676         size =  PREFETCH_MEM_SIZE;
677         axi_address = PREFETCH_MEM_BASE_0;
678         afi_writel(axi_address, AFI_AXI_BAR3_START);
679         afi_writel(size >> 12, AFI_AXI_BAR3_SZ);
680         afi_writel(fpci_bar, AFI_FPCI_BAR3);
681
682         /* Bar 4: non prefetchable memory BAR */
683         fpci_bar = (((MEM_BASE_0 >> 12) & 0x0FFFFFFF) << 4) | 0x1;
684         size = MEM_SIZE;
685         axi_address = MEM_BASE_0;
686         afi_writel(axi_address, AFI_AXI_BAR4_START);
687         afi_writel(size >> 12, AFI_AXI_BAR4_SZ);
688         afi_writel(fpci_bar, AFI_FPCI_BAR4);
689
690         /* Bar 5: NULL out the remaining BAR as it is not used */
691         fpci_bar = 0;
692         size = 0;
693         axi_address = 0;
694         afi_writel(axi_address, AFI_AXI_BAR5_START);
695         afi_writel(size >> 12, AFI_AXI_BAR5_SZ);
696         afi_writel(fpci_bar, AFI_FPCI_BAR5);
697
698         /* map all upstream transactions as uncached */
699         afi_writel(PHYS_OFFSET, AFI_CACHE_BAR0_ST);
700         afi_writel(0, AFI_CACHE_BAR0_SZ);
701         afi_writel(0, AFI_CACHE_BAR1_ST);
702         afi_writel(0, AFI_CACHE_BAR1_SZ);
703
704         /* No MSI */
705         afi_writel(0, AFI_MSI_FPCI_BAR_ST);
706         afi_writel(0, AFI_MSI_BAR_SZ);
707         afi_writel(0, AFI_MSI_AXI_BAR_ST);
708         afi_writel(0, AFI_MSI_BAR_SZ);
709 }
710
711 static void tegra_pcie_enable_controller(void)
712 {
713         u32 val, reg;
714         int i;
715         void __iomem *reg_apb_misc_base;
716         void __iomem *reg_mselect_base;
717         reg_apb_misc_base = IO_ADDRESS(TEGRA_APB_MISC_BASE);
718         reg_mselect_base = IO_ADDRESS(TEGRA_MSELECT_BASE);
719
720         /* select the PCIE APERTURE in MSELECT config */
721         reg = readl(reg_mselect_base);
722         reg |= 1 << MSELECT_CONFIG_0_ENABLE_PCIE_APERTURE;
723         writel(reg, reg_mselect_base);
724
725         /* Enable slot clock and pulse the reset signals */
726         for (i = 0, reg = AFI_PEX0_CTRL; i < MAX_PCIE_SUPPORTED_PORTS;
727                         i++, reg += (i*8)) {
728                 val = afi_readl(reg) | AFI_PEX_CTRL_REFCLK_EN |
729                         (1 << AFI_PEX0_CTRL_0_PEX0_CLKREQ_EN);
730                 afi_writel(val, reg);
731                 val &= ~AFI_PEX_CTRL_RST;
732                 afi_writel(val, reg);
733
734                 val = afi_readl(reg) | AFI_PEX_CTRL_RST;
735                 afi_writel(val, reg);
736         }
737         afi_writel(0, AFI_PEXBIAS_CTRL_0);
738
739         /* Enable dual controller and both ports */
740         val = afi_readl(AFI_PCIE_CONFIG);
741         val &= ~(AFI_PCIE_CONFIG_PCIEC0_DISABLE_DEVICE |
742                  AFI_PCIE_CONFIG_PCIEC1_DISABLE_DEVICE |
743                  AFI_PCIE_CONFIG_PCIEC2_DISABLE_DEVICE |
744                  AFI_PCIE_CONFIG_SM2TMS0_XBAR_CONFIG_MASK);
745 #ifdef CONFIG_ARCH_TEGRA_2x_SOC
746         val |= AFI_PCIE_CONFIG_SM2TMS0_XBAR_CONFIG_DUAL;
747 #else
748         val |= AFI_PCIE_CONFIG_SM2TMS0_XBAR_CONFIG_411;
749 #endif
750         afi_writel(val, AFI_PCIE_CONFIG);
751
752         val = afi_readl(AFI_FUSE) & ~AFI_FUSE_PCIE_T0_GEN2_DIS;
753         afi_writel(val, AFI_FUSE);
754
755         /* Initialze internal PHY, enable up to 16 PCIE lanes */
756         pads_writel(0x0, PADS_CTL_SEL);
757
758         /* override IDDQ to 1 on all 4 lanes */
759         val = pads_readl(PADS_CTL) | PADS_CTL_IDDQ_1L;
760         pads_writel(val, PADS_CTL);
761
762         /*
763          * set up PHY PLL inputs select PLLE output as refclock,
764          * set TX ref sel to div10 (not div5)
765          */
766         val = pads_readl(PADS_PLL_CTL);
767         val &= ~(PADS_PLL_CTL_REFCLK_MASK | PADS_PLL_CTL_TXCLKREF_MASK);
768 #ifdef CONFIG_ARCH_TEGRA_2x_SOC
769         val |= (PADS_PLL_CTL_REFCLK_INTERNAL_CML | PADS_PLL_CTL_TXCLKREF_DIV10);
770 #else
771         val |= (PADS_PLL_CTL_REFCLK_INTERNAL_CML |
772                         PADS_PLL_CTL_TXCLKREF_BUF_EN);
773 #endif
774         pads_writel(val, PADS_PLL_CTL);
775
776         /* take PLL out of reset  */
777         val = pads_readl(PADS_PLL_CTL) | PADS_PLL_CTL_RST_B4SM;
778         pads_writel(val, PADS_PLL_CTL);
779
780         /*
781          * Hack, set the clock voltage to the DEFAULT provided by hw folks.
782          * This doesn't exist in the documentation
783          */
784         pads_writel(0xfa5cfa5c, 0xc8);
785         pads_writel(0x0000FA5C, NV_PCIE2_PADS_REFCLK_CFG1);
786
787         /* Wait for the PLL to lock */
788         do {
789                 val = pads_readl(PADS_PLL_CTL);
790         } while (!(val & PADS_PLL_CTL_LOCKDET));
791
792         /* turn off IDDQ override */
793         val = pads_readl(PADS_CTL) & ~PADS_CTL_IDDQ_1L;
794         pads_writel(val, PADS_CTL);
795
796         /* enable TX/RX data */
797         val = pads_readl(PADS_CTL);
798         val |= (PADS_CTL_TX_DATA_EN_1L | PADS_CTL_RX_DATA_EN_1L);
799         pads_writel(val, PADS_CTL);
800
801         /* Take the PCIe interface module out of reset */
802         tegra_periph_reset_deassert(tegra_pcie.pcie_xclk);
803
804         /* Finally enable PCIe */
805         val = afi_readl(AFI_CONFIGURATION) | AFI_CONFIGURATION_EN_FPCI;
806         afi_writel(val, AFI_CONFIGURATION);
807
808         val = (AFI_INTR_EN_INI_SLVERR | AFI_INTR_EN_INI_DECERR |
809                AFI_INTR_EN_TGT_SLVERR | AFI_INTR_EN_TGT_DECERR |
810                AFI_INTR_EN_TGT_WRERR | AFI_INTR_EN_DFPCI_DECERR |
811                AFI_INTR_EN_PRSNT_SENSE);
812         afi_writel(val, AFI_AFI_INTR_ENABLE);
813         afi_writel(0xffffffff, AFI_SM_INTR_ENABLE);
814
815         /* FIXME: No MSI for now, only INT */
816         afi_writel(AFI_INTR_MASK_INT_MASK, AFI_INTR_MASK);
817
818         /* Disable all execptions */
819         afi_writel(0, AFI_FPCI_ERROR_MASKS);
820
821         return;
822 }
823
824 static int tegra_pci_enable_regulators(void)
825 {
826         if (tegra_pcie.power_rails_enabled)
827                 return 0;
828         if (tegra_pcie.regulator_hvdd == NULL) {
829                 printk(KERN_INFO "PCIE.C: %s : regulator hvdd_pex\n",
830                                         __func__);
831                 tegra_pcie.regulator_hvdd =
832                         regulator_get(NULL, "hvdd_pex");
833                 if (IS_ERR_OR_NULL(tegra_pcie.regulator_hvdd)) {
834                         pr_err("%s: unable to get hvdd_pex regulator\n",
835                                         __func__);
836                         tegra_pcie.regulator_hvdd = 0;
837                 }
838         }
839
840         if (tegra_pcie.regulator_pexio == NULL) {
841                 printk(KERN_INFO "PCIE.C: %s : regulator pexio\n", __func__);
842                 tegra_pcie.regulator_pexio =
843                         regulator_get(NULL, "vdd_pexb");
844                 if (IS_ERR_OR_NULL(tegra_pcie.regulator_pexio)) {
845                         pr_err("%s: unable to get pexio regulator\n", __func__);
846                         tegra_pcie.regulator_pexio = 0;
847                 }
848         }
849
850         /*SATA and PCIE use same PLLE, In default configuration,
851         * and we set default AVDD_PLLE with SATA.
852         * So if use default board, you have to turn on (LDO2) AVDD_PLLE.
853          */
854         if (tegra_pcie.regulator_avdd_plle == NULL) {
855                 printk(KERN_INFO "PCIE.C: %s : regulator avdd_plle\n",
856                                 __func__);
857                 tegra_pcie.regulator_avdd_plle = regulator_get(NULL,
858                                                 "avdd_plle");
859                 if (IS_ERR_OR_NULL(tegra_pcie.regulator_avdd_plle)) {
860                         pr_err("%s: unable to get avdd_plle regulator\n",
861                                 __func__);
862                         tegra_pcie.regulator_avdd_plle = 0;
863                 }
864         }
865         if (tegra_pcie.regulator_hvdd)
866                 regulator_enable(tegra_pcie.regulator_hvdd);
867         if (tegra_pcie.regulator_pexio)
868                 regulator_enable(tegra_pcie.regulator_pexio);
869         if (tegra_pcie.regulator_avdd_plle)
870                 regulator_enable(tegra_pcie.regulator_avdd_plle);
871
872         tegra_pcie.power_rails_enabled = 1;
873
874         return 0;
875 }
876
877 static int tegra_pci_disable_regulators(void)
878 {
879         int err = 0;
880         if (tegra_pcie.power_rails_enabled == 0)
881                 goto err_exit;
882         if (tegra_pcie.regulator_hvdd)
883                 err = regulator_disable(tegra_pcie.regulator_hvdd);
884         if (err)
885                 goto err_exit;
886         if (tegra_pcie.regulator_pexio)
887                 err = regulator_disable(tegra_pcie.regulator_pexio);
888         if (err)
889                 goto err_exit;
890         if (tegra_pcie.regulator_avdd_plle)
891                 err = regulator_disable(tegra_pcie.regulator_avdd_plle);
892         tegra_pcie.power_rails_enabled = 0;
893 err_exit:
894         return err;
895 }
896
897 static int tegra_pcie_power_on(void)
898 {
899         int err = 0;
900         if (tegra_pcie.pcie_power_enabled)
901                 return 0;
902         err = tegra_pci_enable_regulators();
903         if (err)
904                 goto err_exit;
905         err = tegra_unpowergate_partition_with_clk_on(TEGRA_POWERGATE_PCIE);
906         if (err)
907                 goto err_exit;
908         if (tegra_pcie.pll_e)
909                 clk_enable(tegra_pcie.pll_e);
910
911         tegra_pcie.pcie_power_enabled = 1;
912 err_exit:
913         return err;
914 }
915
916 static int tegra_pcie_power_off(void)
917 {
918         int err = 0;
919         if (tegra_pcie.pcie_power_enabled == 0)
920                 return 0;
921         if (tegra_pcie.pll_e)
922                 clk_disable(tegra_pcie.pll_e);
923
924         err = tegra_powergate_partition_with_clk_off(TEGRA_POWERGATE_PCIE);
925         if (err)
926                 goto err_exit;
927
928         err = tegra_pci_disable_regulators();
929
930         tegra_pcie.pcie_power_enabled = 0;
931 err_exit:
932         return err;
933 }
934
935 static int tegra_pcie_power_regate(void)
936 {
937         int err;
938         err = tegra_unpowergate_partition_with_clk_on(TEGRA_POWERGATE_PCIE);
939         if (err) {
940                 pr_err("PCIE: powerup sequence failed: %d\n", err);
941                 return err;
942         }
943         tegra_periph_reset_assert(tegra_pcie.pcie_xclk);
944         return clk_enable(tegra_pcie.pll_e);
945 }
946
947 static int tegra_pcie_clocks_get(void)
948 {
949         /* reset the PCIEXCLK */
950         tegra_pcie.pcie_xclk = clk_get_sys("tegra_pcie", "pciex");
951         if (IS_ERR_OR_NULL(tegra_pcie.pcie_xclk)) {
952                 pr_err("%s: unable to get PCIE Xclock\n", __func__);
953                 goto error_exit;
954         }
955         tegra_pcie.pll_e = clk_get_sys(NULL, "pll_e");
956         if (IS_ERR_OR_NULL(tegra_pcie.pll_e)) {
957                 pr_err("%s: unable to get PLLE\n", __func__);
958                 goto error_exit;
959         }
960         return 0;
961 error_exit:
962         if (tegra_pcie.pcie_xclk)
963                 clk_put(tegra_pcie.pcie_xclk);
964         if (tegra_pcie.pll_e)
965                 clk_put(tegra_pcie.pll_e);
966         return -EINVAL;
967 }
968
969 static void tegra_pcie_clocks_put(void)
970 {
971         clk_put(tegra_pcie.pll_e);
972         clk_put(tegra_pcie.pcie_xclk);
973 }
974
975 static int __init tegra_pcie_get_resources(void)
976 {
977         struct resource *res_mmio = 0;
978         int err;
979         tegra_pcie.power_rails_enabled = 0;
980         err = tegra_pci_enable_regulators();
981         if (err) {
982                 pr_err("PCIE: failed to enable power rails %d\n", err);
983                 goto err_pwr_on_rail;
984         }
985         tegra_unpowergate_partition(TEGRA_POWERGATE_PCIE);
986
987         err = tegra_pcie_clocks_get();
988         if (err) {
989                 pr_err("PCIE: failed to get clocks: %d\n", err);
990                 return err;
991         }
992
993         err = tegra_pcie_power_regate();
994         if (err) {
995                 pr_err("PCIE: failed to power up: %d\n", err);
996                 goto err_pwr_on;
997         }
998
999         tegra_pcie.regs = ioremap_nocache(TEGRA_PCIE_BASE, PCIE_IOMAP_SZ);
1000         if (tegra_pcie.regs == NULL) {
1001                 pr_err("PCIE: Failed to map PCI/AFI registers\n");
1002                 err = -ENOMEM;
1003                 goto err_map_reg;
1004         }
1005         res_mmio = &tegra_pcie.res_mmio;
1006
1007         err = request_resource(&iomem_resource, res_mmio);
1008         if (err) {
1009                 pr_err("PCIE: Failed to request resources: %d\n", err);
1010                 goto err_req_io;
1011         }
1012
1013         tegra_pcie_io_base = ioremap_nocache(res_mmio->start,
1014                                              resource_size(res_mmio));
1015         if (tegra_pcie_io_base == NULL) {
1016                 pr_err("PCIE: Failed to map IO\n");
1017                 err = -ENOMEM;
1018                 goto err_map_io;
1019         }
1020
1021         err = request_irq(INT_PCIE_INTR, tegra_pcie_isr,
1022                           IRQF_SHARED, "PCIE", &tegra_pcie);
1023         if (err) {
1024                 pr_err("PCIE: Failed to register IRQ: %d\n", err);
1025                 goto err_irq;
1026         }
1027         set_irq_flags(INT_PCIE_INTR, IRQF_VALID);
1028
1029         return 0;
1030
1031 err_irq:
1032         iounmap(tegra_pcie_io_base);
1033 err_map_io:
1034         release_resource(&tegra_pcie.res_mmio);
1035 err_req_io:
1036         iounmap(tegra_pcie.regs);
1037 err_map_reg:
1038         tegra_pcie_power_off();
1039 err_pwr_on:
1040         tegra_pcie_clocks_put();
1041 err_pwr_on_rail:
1042         tegra_pci_disable_regulators();
1043         return err;
1044 }
1045
1046 /*
1047  * FIXME: If there are no PCIe cards attached, then calling this function
1048  * can result in the increase of the bootup time as there are big timeout
1049  * loops.
1050  */
1051 #define TEGRA_PCIE_LINKUP_TIMEOUT       200     /* up to 1.2 seconds */
1052 static bool tegra_pcie_check_link(struct tegra_pcie_port *pp, int idx,
1053                                   u32 reset_reg)
1054 {
1055         u32 reg;
1056         int retries = 3;
1057         int timeout;
1058
1059         do {
1060                 timeout = TEGRA_PCIE_LINKUP_TIMEOUT;
1061                 while (timeout) {
1062                         reg = readl(pp->base + RP_VEND_XP);
1063
1064                         if (reg & RP_VEND_XP_DL_UP)
1065                                 break;
1066
1067                         mdelay(1);
1068                         timeout--;
1069                 }
1070
1071                 if (!timeout)  {
1072                         pr_err("PCIE: port %d: link down, retrying\n", idx);
1073                         goto retry;
1074                 }
1075
1076                 timeout = TEGRA_PCIE_LINKUP_TIMEOUT;
1077                 while (timeout) {
1078                         reg = readl(pp->base + RP_LINK_CONTROL_STATUS);
1079
1080                         if (reg & 0x20000000)
1081                                 return true;
1082
1083                         mdelay(1);
1084                         timeout--;
1085                 }
1086
1087 retry:
1088                 /* Pulse the PEX reset */
1089                 reg = afi_readl(reset_reg) & ~AFI_PEX_CTRL_RST;
1090                 afi_writel(reg, reset_reg);
1091                 reg = afi_readl(reset_reg) | AFI_PEX_CTRL_RST;
1092                 afi_writel(reg, reset_reg);
1093
1094                 retries--;
1095         } while (retries);
1096
1097         return false;
1098 }
1099
1100 static void __init tegra_pcie_add_port(int index, u32 offset, u32 reset_reg)
1101 {
1102         struct tegra_pcie_port *pp;
1103         unsigned int data;
1104
1105         pp = tegra_pcie.port + tegra_pcie.num_ports;
1106
1107         pp->index = -1;
1108         pp->base = tegra_pcie.regs + offset;
1109         pp->link_up = tegra_pcie_check_link(pp, index, reset_reg);
1110
1111         if (!pp->link_up) {
1112                 pp->base = NULL;
1113                 printk(KERN_INFO "PCIE: port %d: link down, ignoring\n", index);
1114                 return;
1115         }
1116         /* Power mangagement settings */
1117         /* Enable clock clamping by default */
1118         data = rp_readl(NV_PCIE2_RP_PRIV_MISC, index);
1119         data |= (PCIE2_RP_PRIV_MISC_CTLR_CLK_CLAMP_ENABLE) |
1120                 (PCIE2_RP_PRIV_MISC_TMS_CLK_CLAMP_ENABLE);
1121         rp_writel(data, NV_PCIE2_RP_PRIV_MISC, index);
1122
1123         tegra_pcie.num_ports++;
1124         pp->index = index;
1125         pp->root_bus_nr = -1;
1126         memset(pp->res, 0, sizeof(pp->res));
1127 }
1128
1129 static int tegra_pcie_init(void)
1130 {
1131         int err = 0;
1132         int port;
1133         int rp_offset = 0;
1134         int ctrl_offset = AFI_PEX0_CTRL;
1135
1136 #ifdef CONFIG_ARCH_TEGRA_2x_SOC
1137         pcibios_min_mem = 0x1000;
1138         pcibios_min_io = 0;
1139 #else
1140         pcibios_min_mem = 0x03000000ul;
1141         pcibios_min_io = 0x10000000ul;
1142 #endif
1143         err = tegra_pcie_get_resources();
1144         if (err)
1145                 return err;
1146         tegra_pcie_enable_controller();
1147
1148         /* setup the AFI address translations */
1149         tegra_pcie_setup_translations();
1150         for (port = 0; port < MAX_PCIE_SUPPORTED_PORTS; port++) {
1151                 ctrl_offset += (port * 8);
1152                 rp_offset = (rp_offset + 0x1000) * port;
1153                 if (tegra_pcie.plat_data->port_status[port])
1154                         tegra_pcie_add_port(port, rp_offset, ctrl_offset);
1155         }
1156
1157         tegra_pcie.pcie_power_enabled = 1;
1158         if (tegra_pcie.num_ports)
1159                 pci_common_init(&tegra_pcie_hw);
1160         else
1161                 err = tegra_pcie_power_off();
1162
1163         return err;
1164 }
1165
1166 static int tegra_pci_probe(struct platform_device *pdev)
1167 {
1168         int ret;
1169         struct pci_dev *dev = NULL;
1170
1171         tegra_pcie.plat_data = pdev->dev.platform_data;
1172         dev_dbg(&pdev->dev, "PCIE.C: %s : _port_status[0] %d\n",
1173                 __func__, tegra_pcie.plat_data->port_status[0]);
1174         dev_dbg(&pdev->dev, "PCIE.C: %s : _port_status[1] %d\n",
1175                 __func__, tegra_pcie.plat_data->port_status[1]);
1176         dev_dbg(&pdev->dev, "PCIE.C: %s : _port_status[2] %d\n",
1177                 __func__, tegra_pcie.plat_data->port_status[2]);
1178         ret = tegra_pcie_init();
1179
1180         /* disable async PM of pci devices to ensure right order */
1181         /* suspend/resume calls of tegra and bus driver */
1182         for_each_pci_dev(dev)
1183                 device_disable_async_suspend(&dev->dev);
1184
1185         return ret;
1186 }
1187
1188 static int tegra_pci_suspend(struct platform_device *pdev, pm_message_t state)
1189 {
1190         return tegra_pcie_power_off();
1191 }
1192
1193 static int tegra_pci_resume(struct platform_device *pdev)
1194 {
1195         int ret;
1196
1197         ret = tegra_pcie_power_on();
1198         tegra_pcie_enable_controller();
1199         tegra_pcie_setup_translations();
1200
1201         return ret;
1202 }
1203
1204 static int tegra_pci_remove(struct platform_device *pdev)
1205 {
1206         return 0;
1207 }
1208
1209 static struct platform_driver tegra_pci_driver = {
1210         .probe   = tegra_pci_probe,
1211         .remove  = tegra_pci_remove,
1212 #ifdef CONFIG_PM
1213         .suspend = tegra_pci_suspend,
1214         .resume  = tegra_pci_resume,
1215 #endif
1216         .driver  = {
1217                 .name  = "tegra-pcie",
1218                 .owner = THIS_MODULE,
1219         },
1220 };
1221
1222 static int __init tegra_pci_init_driver(void)
1223 {
1224         return platform_driver_register(&tegra_pci_driver);
1225 }
1226
1227 static void __exit tegra_pci_exit_driver(void)
1228 {
1229         platform_driver_unregister(&tegra_pci_driver);
1230 }
1231
1232 module_init(tegra_pci_init_driver);
1233 module_exit(tegra_pci_exit_driver);
1234
1235 static struct irq_chip tegra_irq_chip_msi_pcie = {
1236         .name = "PCIe-MSI",
1237         .irq_mask = mask_msi_irq,
1238         .irq_unmask = unmask_msi_irq,
1239         .irq_enable = unmask_msi_irq,
1240         .irq_disable = mask_msi_irq,
1241 };
1242
1243 /* 1:1 matching of these to the MSI vectors, 1 per bit */
1244 /* and each mapping matches one of the available interrupts */
1245 /*   irq should equal INT_PCI_MSI_BASE + index */
1246 struct msi_map_entry {
1247         bool used;
1248         u8 index;
1249         int irq;
1250 };
1251
1252 /* hardware supports 256 max*/
1253 #if (INT_PCI_MSI_NR > 256)
1254 #error "INT_PCI_MSI_NR too big"
1255 #endif
1256
1257 #define MSI_MAP_SIZE  (INT_PCI_MSI_NR)
1258 static struct msi_map_entry msi_map[MSI_MAP_SIZE];
1259
1260 static void msi_map_init(void)
1261 {
1262         int i;
1263
1264         for (i = 0; i < MSI_MAP_SIZE; i++) {
1265                 msi_map[i].used = false;
1266                 msi_map[i].index = i;
1267                 msi_map[i].irq = 0;
1268         }
1269 }
1270
1271 /* returns an index into the map*/
1272 static struct msi_map_entry *msi_map_get(void)
1273 {
1274         struct msi_map_entry *retval = NULL;
1275         int i;
1276
1277         for (i = 0; i < MSI_MAP_SIZE; i++) {
1278                 if (!msi_map[i].used) {
1279                         retval = msi_map + i;
1280                         retval->irq = INT_PCI_MSI_BASE + i;
1281                         retval->used = true;
1282                         break;
1283                 }
1284         }
1285
1286         return retval;
1287 }
1288
1289 void msi_map_release(struct msi_map_entry *entry)
1290 {
1291         if (entry) {
1292                 entry->used = false;
1293                 entry->irq = 0;
1294         }
1295 }
1296
1297 static irqreturn_t pci_tegra_msi_isr(int irq, void *arg)
1298 {
1299         int i;
1300         int offset;
1301         int index;
1302         u32 reg;
1303
1304         for (i = 0; i < 8; i++) {
1305                 reg = afi_readl(AFI_MSI_VEC0_0 + i * 4);
1306                 while (reg != 0x00000000) {
1307                         offset = find_first_bit((unsigned long int *)&reg, 32);
1308                         index = i * 32 + offset;
1309                         /* clear the interrupt */
1310                         afi_writel(1ul << index, AFI_MSI_VEC0_0 + i * 4);
1311                         if (index < MSI_MAP_SIZE) {
1312                                 if (msi_map[index].used)
1313                                         generic_handle_irq(msi_map[index].irq);
1314                                 else
1315                                         printk(KERN_INFO "unexpected MSI (1)\n");
1316                         } else {
1317                                 /* that's weird who triggered this?*/
1318                                 /* just clear it*/
1319                                 printk(KERN_INFO "unexpected MSI (2)\n");
1320                         }
1321                         /* see if there's any more pending in this vector */
1322                         reg = afi_readl(AFI_MSI_VEC0_0 + i * 4);
1323                 }
1324         }
1325
1326         return IRQ_HANDLED;
1327 }
1328
1329 static bool pci_tegra_enable_msi(void)
1330 {
1331         bool retval = false;
1332         static bool already_done;
1333         u32 reg;
1334         u32 msi_base = 0;
1335         u32 msi_aligned = 0;
1336
1337         /* enables MSI interrupts.  */
1338         /* this only happens once. */
1339         if (already_done) {
1340                 retval = true;
1341                 goto exit;
1342         }
1343
1344         msi_map_init();
1345
1346         if (request_irq(INT_PCIE_MSI, pci_tegra_msi_isr,
1347                 IRQF_SHARED, "PCIe-MSI",
1348                 pci_tegra_msi_isr)) {
1349                         pr_err("%s: Cannot register IRQ %u\n",
1350                                 __func__, INT_PCIE_MSI);
1351                         goto exit;
1352         }
1353
1354         /* setup AFI/FPCI range */
1355         /* FIXME do this better! should be based on PAGE_SIZE */
1356         msi_base = __get_free_pages(GFP_KERNEL, 3);
1357         msi_aligned = ((msi_base + ((1<<12) - 1)) & ~((1<<12) - 1));
1358         msi_aligned = virt_to_phys((void *)msi_aligned);
1359
1360 #ifdef CONFIG_ARCH_TEGRA_2x_SOC
1361         afi_writel(msi_aligned, AFI_MSI_FPCI_BAR_ST_0);
1362 #else
1363         /* different from T20!*/
1364         afi_writel(msi_aligned>>8, AFI_MSI_FPCI_BAR_ST_0);
1365 #endif
1366         afi_writel(msi_aligned, AFI_MSI_AXI_BAR_ST_0);
1367         /* this register is in 4K increments */
1368         afi_writel(1, AFI_MSI_BAR_SZ_0);
1369
1370         /* enable all MSI vectors */
1371         afi_writel(0xffffffff, AFI_MSI_EN_VEC0_0);
1372         afi_writel(0xffffffff, AFI_MSI_EN_VEC1_0);
1373         afi_writel(0xffffffff, AFI_MSI_EN_VEC2_0);
1374         afi_writel(0xffffffff, AFI_MSI_EN_VEC3_0);
1375         afi_writel(0xffffffff, AFI_MSI_EN_VEC4_0);
1376         afi_writel(0xffffffff, AFI_MSI_EN_VEC5_0);
1377         afi_writel(0xffffffff, AFI_MSI_EN_VEC6_0);
1378         afi_writel(0xffffffff, AFI_MSI_EN_VEC7_0);
1379
1380         /* and unmask the MSI interrupt */
1381         reg = 0;
1382         reg |= ((1 << AFI_INTR_MASK_0_INT_MASK) |
1383                         (1 << AFI_INTR_MASK_0_MSI_MASK));
1384         afi_writel(reg, AFI_INTR_MASK_0);
1385
1386         set_irq_flags(INT_PCIE_MSI, IRQF_VALID);
1387
1388         already_done = true;
1389         retval = true;
1390 exit:
1391         if (!retval) {
1392                 if (msi_base)
1393                         free_pages(msi_base, 3);
1394         }
1395         return retval;
1396 }
1397
1398
1399 /* called by arch_setup_msi_irqs in drivers/pci/msi.c */
1400 int arch_setup_msi_irq(struct pci_dev *pdev, struct msi_desc *desc)
1401 {
1402         int retval = -EINVAL;
1403         struct msi_msg msg;
1404         struct msi_map_entry *map_entry = NULL;
1405
1406         if (!pci_tegra_enable_msi())
1407                 goto exit;
1408
1409         map_entry = msi_map_get();
1410         if (map_entry == NULL)
1411                 goto exit;
1412
1413         irq_alloc_desc(map_entry->irq);
1414         irq_set_chip_and_handler(map_entry->irq,
1415                                 &tegra_irq_chip_msi_pcie,
1416                                 handle_simple_irq);
1417
1418         irq_set_msi_desc(map_entry->irq, desc);
1419         set_irq_flags(map_entry->irq, IRQF_VALID);
1420
1421         msg.address_lo = afi_readl(AFI_MSI_AXI_BAR_ST_0);
1422         /* 32 bit address only */
1423         msg.address_hi = 0;
1424         msg.data = map_entry->index;
1425
1426         write_msi_msg(map_entry->irq, &msg);
1427
1428         retval = 0;
1429 exit:
1430         if (retval != 0) {
1431                 if (map_entry)
1432                         msi_map_release(map_entry);
1433         }
1434
1435         return retval;
1436 }
1437
1438 void arch_teardown_msi_irq(unsigned int irq)
1439 {
1440         int i;
1441         for (i = 0; i < MSI_MAP_SIZE; i++) {
1442                 if ((msi_map[i].used) && (msi_map[i].irq == irq)) {
1443                         irq_free_desc(msi_map[i].irq);
1444                         msi_map_release(msi_map + i);
1445                         break;
1446                 }
1447         }
1448 }