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