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