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