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