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