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