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