Merge commit 'v2.6.39' into 20110526
[linux-2.6.git] / arch / arm / mach-tegra / pcie.c
1 /*
2  * arch/arm/mach-tegra/pci.c
3  *
4  * PCIe host controller driver for TEGRA(2) 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-2009, 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
36 #include <asm/sizes.h>
37 #include <asm/mach/pci.h>
38
39 #include <mach/pinmux.h>
40 #include <mach/iomap.h>
41 #include <mach/clk.h>
42 #include <mach/powergate.h>
43
44 /* register definitions */
45 #define AFI_OFFSET      0x3800
46 #define PADS_OFFSET     0x3000
47 #define RP0_OFFSET      0x0000
48 #define RP1_OFFSET      0x1000
49
50 #define AFI_AXI_BAR0_SZ 0x00
51 #define AFI_AXI_BAR1_SZ 0x04
52 #define AFI_AXI_BAR2_SZ 0x08
53 #define AFI_AXI_BAR3_SZ 0x0c
54 #define AFI_AXI_BAR4_SZ 0x10
55 #define AFI_AXI_BAR5_SZ 0x14
56
57 #define AFI_AXI_BAR0_START      0x18
58 #define AFI_AXI_BAR1_START      0x1c
59 #define AFI_AXI_BAR2_START      0x20
60 #define AFI_AXI_BAR3_START      0x24
61 #define AFI_AXI_BAR4_START      0x28
62 #define AFI_AXI_BAR5_START      0x2c
63
64 #define AFI_FPCI_BAR0   0x30
65 #define AFI_FPCI_BAR1   0x34
66 #define AFI_FPCI_BAR2   0x38
67 #define AFI_FPCI_BAR3   0x3c
68 #define AFI_FPCI_BAR4   0x40
69 #define AFI_FPCI_BAR5   0x44
70
71 #define AFI_CACHE_BAR0_SZ       0x48
72 #define AFI_CACHE_BAR0_ST       0x4c
73 #define AFI_CACHE_BAR1_SZ       0x50
74 #define AFI_CACHE_BAR1_ST       0x54
75
76 #define AFI_MSI_BAR_SZ          0x60
77 #define AFI_MSI_FPCI_BAR_ST     0x64
78 #define AFI_MSI_AXI_BAR_ST      0x68
79
80 #define AFI_CONFIGURATION               0xac
81 #define  AFI_CONFIGURATION_EN_FPCI      (1 << 0)
82
83 #define AFI_FPCI_ERROR_MASKS    0xb0
84
85 #define AFI_INTR_MASK           0xb4
86 #define  AFI_INTR_MASK_INT_MASK (1 << 0)
87 #define  AFI_INTR_MASK_MSI_MASK (1 << 8)
88
89 #define AFI_INTR_CODE           0xb8
90 #define  AFI_INTR_CODE_MASK     0xf
91 #define  AFI_INTR_MASTER_ABORT  4
92 #define  AFI_INTR_LEGACY        6
93
94 #define AFI_INTR_SIGNATURE      0xbc
95 #define AFI_SM_INTR_ENABLE      0xc4
96
97 #define AFI_AFI_INTR_ENABLE             0xc8
98 #define  AFI_INTR_EN_INI_SLVERR         (1 << 0)
99 #define  AFI_INTR_EN_INI_DECERR         (1 << 1)
100 #define  AFI_INTR_EN_TGT_SLVERR         (1 << 2)
101 #define  AFI_INTR_EN_TGT_DECERR         (1 << 3)
102 #define  AFI_INTR_EN_TGT_WRERR          (1 << 4)
103 #define  AFI_INTR_EN_DFPCI_DECERR       (1 << 5)
104 #define  AFI_INTR_EN_AXI_DECERR         (1 << 6)
105 #define  AFI_INTR_EN_FPCI_TIMEOUT       (1 << 7)
106
107 #define AFI_PCIE_CONFIG                                 0x0f8
108 #define  AFI_PCIE_CONFIG_PCIEC0_DISABLE_DEVICE          (1 << 1)
109 #define  AFI_PCIE_CONFIG_PCIEC1_DISABLE_DEVICE          (1 << 2)
110 #define  AFI_PCIE_CONFIG_SM2TMS0_XBAR_CONFIG_MASK       (0xf << 20)
111 #define  AFI_PCIE_CONFIG_SM2TMS0_XBAR_CONFIG_SINGLE     (0x0 << 20)
112 #define  AFI_PCIE_CONFIG_SM2TMS0_XBAR_CONFIG_DUAL       (0x1 << 20)
113
114 #define AFI_FUSE                        0x104
115 #define  AFI_FUSE_PCIE_T0_GEN2_DIS      (1 << 2)
116
117 #define AFI_PEX0_CTRL                   0x110
118 #define AFI_PEX1_CTRL                   0x118
119 #define  AFI_PEX_CTRL_RST               (1 << 0)
120 #define  AFI_PEX_CTRL_REFCLK_EN         (1 << 3)
121
122 #define RP_VEND_XP      0x00000F00
123 #define  RP_VEND_XP_DL_UP       (1 << 30)
124
125 #define RP_LINK_CONTROL_STATUS                  0x00000090
126 #define  RP_LINK_CONTROL_STATUS_LINKSTAT_MASK   0x3fff0000
127
128 #define PADS_CTL_SEL            0x0000009C
129
130 #define PADS_CTL                0x000000A0
131 #define  PADS_CTL_IDDQ_1L       (1 << 0)
132 #define  PADS_CTL_TX_DATA_EN_1L (1 << 6)
133 #define  PADS_CTL_RX_DATA_EN_1L (1 << 10)
134
135 #define PADS_PLL_CTL                            0x000000B8
136 #define  PADS_PLL_CTL_RST_B4SM                  (1 << 1)
137 #define  PADS_PLL_CTL_LOCKDET                   (1 << 8)
138 #define  PADS_PLL_CTL_REFCLK_MASK               (0x3 << 16)
139 #define  PADS_PLL_CTL_REFCLK_INTERNAL_CML       (0 << 16)
140 #define  PADS_PLL_CTL_REFCLK_INTERNAL_CMOS      (1 << 16)
141 #define  PADS_PLL_CTL_REFCLK_EXTERNAL           (2 << 16)
142 #define  PADS_PLL_CTL_TXCLKREF_MASK             (0x1 << 20)
143 #define  PADS_PLL_CTL_TXCLKREF_DIV10            (0 << 20)
144 #define  PADS_PLL_CTL_TXCLKREF_DIV5             (1 << 20)
145
146 /* PMC access is required for PCIE xclk (un)clamping */
147 #define PMC_SCRATCH42           0x144
148 #define PMC_SCRATCH42_PCX_CLAMP (1 << 0)
149
150 static void __iomem *reg_pmc_base = IO_ADDRESS(TEGRA_PMC_BASE);
151
152 #define pmc_writel(value, reg) \
153         __raw_writel(value, (u32)reg_pmc_base + (reg))
154 #define pmc_readl(reg) \
155         __raw_readl((u32)reg_pmc_base + (reg))
156
157 /*
158  * Tegra2 defines 1GB in the AXI address map for PCIe.
159  *
160  * That address space is split into different regions, with sizes and
161  * offsets as follows:
162  *
163  * 0x80000000 - 0x80003fff - PCI controller registers
164  * 0x80004000 - 0x80103fff - PCI configuration space
165  * 0x80104000 - 0x80203fff - PCI extended configuration space
166  * 0x80203fff - 0x803fffff - unused
167  * 0x80400000 - 0x8040ffff - downstream IO
168  * 0x80410000 - 0x8fffffff - unused
169  * 0x90000000 - 0x9fffffff - non-prefetchable memory
170  * 0xa0000000 - 0xbfffffff - prefetchable memory
171  */
172 #define TEGRA_PCIE_BASE         0x80000000
173
174 #define PCIE_REGS_SZ            SZ_16K
175 #define PCIE_CFG_OFF            PCIE_REGS_SZ
176 #define PCIE_CFG_SZ             SZ_1M
177 #define PCIE_EXT_CFG_OFF        (PCIE_CFG_SZ + PCIE_CFG_OFF)
178 #define PCIE_EXT_CFG_SZ         SZ_1M
179 #define PCIE_IOMAP_SZ           (PCIE_REGS_SZ + PCIE_CFG_SZ + PCIE_EXT_CFG_SZ)
180
181 #define MMIO_BASE               (TEGRA_PCIE_BASE + SZ_4M)
182 #define MMIO_SIZE               SZ_64K
183 #define MEM_BASE_0              (TEGRA_PCIE_BASE + SZ_256M)
184 #define MEM_SIZE_0              SZ_128M
185 #define MEM_BASE_1              (MEM_BASE_0 + MEM_SIZE_0)
186 #define MEM_SIZE_1              SZ_128M
187 #define PREFETCH_MEM_BASE_0     (MEM_BASE_1 + MEM_SIZE_1)
188 #define PREFETCH_MEM_SIZE_0     SZ_128M
189 #define PREFETCH_MEM_BASE_1     (PREFETCH_MEM_BASE_0 + PREFETCH_MEM_SIZE_0)
190 #define PREFETCH_MEM_SIZE_1     SZ_128M
191
192 #define  PCIE_CONF_BUS(b)       ((b) << 16)
193 #define  PCIE_CONF_DEV(d)       ((d) << 11)
194 #define  PCIE_CONF_FUNC(f)      ((f) << 8)
195 #define  PCIE_CONF_REG(r)       \
196         (((r) & ~0x3) | (((r) < 256) ? PCIE_CFG_OFF : PCIE_EXT_CFG_OFF))
197
198 struct tegra_pcie_port {
199         int                     index;
200         u8                      root_bus_nr;
201         void __iomem            *base;
202
203         bool                    link_up;
204
205         char                    io_space_name[16];
206         char                    mem_space_name[16];
207         char                    prefetch_space_name[20];
208         struct resource         res[3];
209 };
210
211 struct tegra_pcie_info {
212         struct tegra_pcie_port  port[2];
213         int                     num_ports;
214
215         void __iomem            *regs;
216         struct resource         res_mmio;
217
218         struct clk              *pex_clk;
219         struct clk              *afi_clk;
220         struct clk              *pcie_xclk;
221         struct clk              *pll_e;
222 };
223
224 static struct tegra_pcie_info tegra_pcie = {
225         .res_mmio = {
226                 .name = "PCI IO",
227                 .start = MMIO_BASE,
228                 .end = MMIO_BASE + MMIO_SIZE - 1,
229                 .flags = IORESOURCE_MEM,
230         },
231 };
232
233 void __iomem *tegra_pcie_io_base;
234 EXPORT_SYMBOL(tegra_pcie_io_base);
235
236 static inline void afi_writel(u32 value, unsigned long offset)
237 {
238         writel(value, offset + AFI_OFFSET + tegra_pcie.regs);
239 }
240
241 static inline u32 afi_readl(unsigned long offset)
242 {
243         return readl(offset + AFI_OFFSET + tegra_pcie.regs);
244 }
245
246 static inline void pads_writel(u32 value, unsigned long offset)
247 {
248         writel(value, offset + PADS_OFFSET + tegra_pcie.regs);
249 }
250
251 static inline u32 pads_readl(unsigned long offset)
252 {
253         return readl(offset + PADS_OFFSET + tegra_pcie.regs);
254 }
255
256 static struct tegra_pcie_port *bus_to_port(int bus)
257 {
258         int i;
259
260         for (i = tegra_pcie.num_ports - 1; i >= 0; i--) {
261                 int rbus = tegra_pcie.port[i].root_bus_nr;
262                 if (rbus != -1 && rbus == bus)
263                         break;
264         }
265
266         return i >= 0 ? tegra_pcie.port + i : NULL;
267 }
268
269 static int tegra_pcie_read_conf(struct pci_bus *bus, unsigned int devfn,
270                                 int where, int size, u32 *val)
271 {
272         struct tegra_pcie_port *pp = bus_to_port(bus->number);
273         void __iomem *addr;
274
275         if (pp) {
276                 if (devfn != 0) {
277                         *val = 0xffffffff;
278                         return PCIBIOS_DEVICE_NOT_FOUND;
279                 }
280
281                 addr = pp->base + (where & ~0x3);
282         } else {
283                 addr = tegra_pcie.regs + (PCIE_CONF_BUS(bus->number) +
284                                           PCIE_CONF_DEV(PCI_SLOT(devfn)) +
285                                           PCIE_CONF_FUNC(PCI_FUNC(devfn)) +
286                                           PCIE_CONF_REG(where));
287         }
288
289         *val = readl(addr);
290
291         if (size == 1)
292                 *val = (*val >> (8 * (where & 3))) & 0xff;
293         else if (size == 2)
294                 *val = (*val >> (8 * (where & 3))) & 0xffff;
295
296         return PCIBIOS_SUCCESSFUL;
297 }
298
299 static int tegra_pcie_write_conf(struct pci_bus *bus, unsigned int devfn,
300                                  int where, int size, u32 val)
301 {
302         struct tegra_pcie_port *pp = bus_to_port(bus->number);
303         void __iomem *addr;
304
305         u32 mask;
306         u32 tmp;
307
308         if (pp) {
309                 if (devfn != 0)
310                         return PCIBIOS_DEVICE_NOT_FOUND;
311
312                 addr = pp->base + (where & ~0x3);
313         } else {
314                 addr = tegra_pcie.regs + (PCIE_CONF_BUS(bus->number) +
315                                           PCIE_CONF_DEV(PCI_SLOT(devfn)) +
316                                           PCIE_CONF_FUNC(PCI_FUNC(devfn)) +
317                                           PCIE_CONF_REG(where));
318         }
319
320         if (size == 4) {
321                 writel(val, addr);
322                 return PCIBIOS_SUCCESSFUL;
323         }
324
325         if (size == 2)
326                 mask = ~(0xffff << ((where & 0x3) * 8));
327         else if (size == 1)
328                 mask = ~(0xff << ((where & 0x3) * 8));
329         else
330                 return PCIBIOS_BAD_REGISTER_NUMBER;
331
332         tmp = readl(addr) & mask;
333         tmp |= val << ((where & 0x3) * 8);
334         writel(tmp, addr);
335
336         return PCIBIOS_SUCCESSFUL;
337 }
338
339 static struct pci_ops tegra_pcie_ops = {
340         .read   = tegra_pcie_read_conf,
341         .write  = tegra_pcie_write_conf,
342 };
343
344 static void __devinit tegra_pcie_fixup_bridge(struct pci_dev *dev)
345 {
346         u16 reg;
347
348         if ((dev->class >> 16) == PCI_BASE_CLASS_BRIDGE) {
349                 pci_read_config_word(dev, PCI_COMMAND, &reg);
350                 reg |= (PCI_COMMAND_IO | PCI_COMMAND_MEMORY |
351                         PCI_COMMAND_MASTER | PCI_COMMAND_SERR);
352                 pci_write_config_word(dev, PCI_COMMAND, reg);
353         }
354 }
355 DECLARE_PCI_FIXUP_FINAL(PCI_ANY_ID, PCI_ANY_ID, tegra_pcie_fixup_bridge);
356
357 /* Tegra PCIE root complex wrongly reports device class */
358 static void __devinit tegra_pcie_fixup_class(struct pci_dev *dev)
359 {
360         dev->class = PCI_CLASS_BRIDGE_PCI << 8;
361 }
362 DECLARE_PCI_FIXUP_EARLY(PCI_VENDOR_ID_NVIDIA, 0x0bf0, tegra_pcie_fixup_class);
363 DECLARE_PCI_FIXUP_EARLY(PCI_VENDOR_ID_NVIDIA, 0x0bf1, tegra_pcie_fixup_class);
364
365 /* Tegra PCIE requires relaxed ordering */
366 static void __devinit tegra_pcie_relax_enable(struct pci_dev *dev)
367 {
368         u16 val16;
369         int pos = pci_find_capability(dev, PCI_CAP_ID_EXP);
370
371         if (pos <= 0) {
372                 dev_err(&dev->dev, "skipping relaxed ordering fixup\n");
373                 return;
374         }
375
376         pci_read_config_word(dev, pos + PCI_EXP_DEVCTL, &val16);
377         val16 |= PCI_EXP_DEVCTL_RELAX_EN;
378         pci_write_config_word(dev, pos + PCI_EXP_DEVCTL, val16);
379 }
380 DECLARE_PCI_FIXUP_FINAL(PCI_ANY_ID, PCI_ANY_ID, tegra_pcie_relax_enable);
381
382 static int tegra_pcie_setup(int nr, struct pci_sys_data *sys)
383 {
384         struct tegra_pcie_port *pp;
385
386         if (nr >= tegra_pcie.num_ports)
387                 return 0;
388
389         pp = tegra_pcie.port + nr;
390         pp->root_bus_nr = sys->busnr;
391
392         /*
393          * IORESOURCE_IO
394          */
395         snprintf(pp->io_space_name, sizeof(pp->io_space_name),
396                  "PCIe %d I/O", pp->index);
397         pp->io_space_name[sizeof(pp->io_space_name) - 1] = 0;
398         pp->res[0].name = pp->io_space_name;
399         if (pp->index == 0) {
400                 pp->res[0].start = PCIBIOS_MIN_IO;
401                 pp->res[0].end = pp->res[0].start + SZ_32K - 1;
402         } else {
403                 pp->res[0].start = PCIBIOS_MIN_IO + SZ_32K;
404                 pp->res[0].end = IO_SPACE_LIMIT;
405         }
406         pp->res[0].flags = IORESOURCE_IO;
407         if (request_resource(&ioport_resource, &pp->res[0]))
408                 panic("Request PCIe IO resource failed\n");
409         sys->resource[0] = &pp->res[0];
410
411         /*
412          * IORESOURCE_MEM
413          */
414         snprintf(pp->mem_space_name, sizeof(pp->mem_space_name),
415                  "PCIe %d MEM", pp->index);
416         pp->mem_space_name[sizeof(pp->mem_space_name) - 1] = 0;
417         pp->res[1].name = pp->mem_space_name;
418         if (pp->index == 0) {
419                 pp->res[1].start = MEM_BASE_0;
420                 pp->res[1].end = pp->res[1].start + MEM_SIZE_0 - 1;
421         } else {
422                 pp->res[1].start = MEM_BASE_1;
423                 pp->res[1].end = pp->res[1].start + MEM_SIZE_1 - 1;
424         }
425         pp->res[1].flags = IORESOURCE_MEM;
426         if (request_resource(&iomem_resource, &pp->res[1]))
427                 panic("Request PCIe Memory resource failed\n");
428         sys->resource[1] = &pp->res[1];
429
430         /*
431          * IORESOURCE_MEM | IORESOURCE_PREFETCH
432          */
433         snprintf(pp->prefetch_space_name, sizeof(pp->prefetch_space_name),
434                  "PCIe %d PREFETCH MEM", pp->index);
435         pp->prefetch_space_name[sizeof(pp->prefetch_space_name) - 1] = 0;
436         pp->res[2].name = pp->prefetch_space_name;
437         if (pp->index == 0) {
438                 pp->res[2].start = PREFETCH_MEM_BASE_0;
439                 pp->res[2].end = pp->res[2].start + PREFETCH_MEM_SIZE_0 - 1;
440         } else {
441                 pp->res[2].start = PREFETCH_MEM_BASE_1;
442                 pp->res[2].end = pp->res[2].start + PREFETCH_MEM_SIZE_1 - 1;
443         }
444         pp->res[2].flags = IORESOURCE_MEM | IORESOURCE_PREFETCH;
445         if (request_resource(&iomem_resource, &pp->res[2]))
446                 panic("Request PCIe Prefetch Memory resource failed\n");
447         sys->resource[2] = &pp->res[2];
448
449         return 1;
450 }
451
452 static int tegra_pcie_map_irq(struct pci_dev *dev, u8 slot, u8 pin)
453 {
454         return INT_PCIE_INTR;
455 }
456
457 static struct pci_bus __init *tegra_pcie_scan_bus(int nr,
458                                                   struct pci_sys_data *sys)
459 {
460         struct tegra_pcie_port *pp;
461
462         if (nr >= tegra_pcie.num_ports)
463                 return 0;
464
465         pp = tegra_pcie.port + nr;
466         pp->root_bus_nr = sys->busnr;
467
468         return pci_scan_bus(sys->busnr, &tegra_pcie_ops, sys);
469 }
470
471 static struct hw_pci tegra_pcie_hw __initdata = {
472         .nr_controllers = 2,
473         .setup          = tegra_pcie_setup,
474         .scan           = tegra_pcie_scan_bus,
475         .swizzle        = pci_std_swizzle,
476         .map_irq        = tegra_pcie_map_irq,
477 };
478
479
480 static irqreturn_t tegra_pcie_isr(int irq, void *arg)
481 {
482         const char *err_msg[] = {
483                 "Unknown",
484                 "AXI slave error",
485                 "AXI decode error",
486                 "Target abort",
487                 "Master abort",
488                 "Invalid write",
489                 "Response decoding error",
490                 "AXI response decoding error",
491                 "Transcation timeout",
492         };
493
494         u32 code, signature;
495
496         code = afi_readl(AFI_INTR_CODE) & AFI_INTR_CODE_MASK;
497         signature = afi_readl(AFI_INTR_SIGNATURE);
498         afi_writel(0, AFI_INTR_CODE);
499
500         if (code == AFI_INTR_LEGACY)
501                 return IRQ_NONE;
502
503         if (code >= ARRAY_SIZE(err_msg))
504                 code = 0;
505
506         /*
507          * do not pollute kernel log with master abort reports since they
508          * happen a lot during enumeration
509          */
510         if (code == AFI_INTR_MASTER_ABORT)
511                 pr_debug("PCIE: %s, signature: %08x\n", err_msg[code], signature);
512         else
513                 pr_err("PCIE: %s, signature: %08x\n", err_msg[code], signature);
514
515         return IRQ_HANDLED;
516 }
517
518 static void tegra_pcie_setup_translations(void)
519 {
520         u32 fpci_bar;
521         u32 size;
522         u32 axi_address;
523
524         /* Bar 0: config Bar */
525         fpci_bar = ((u32)0xfdff << 16);
526         size = PCIE_CFG_SZ;
527         axi_address = TEGRA_PCIE_BASE + PCIE_CFG_OFF;
528         afi_writel(axi_address, AFI_AXI_BAR0_START);
529         afi_writel(size >> 12, AFI_AXI_BAR0_SZ);
530         afi_writel(fpci_bar, AFI_FPCI_BAR0);
531
532         /* Bar 1: extended config Bar */
533         fpci_bar = ((u32)0xfe1 << 20);
534         size = PCIE_EXT_CFG_SZ;
535         axi_address = TEGRA_PCIE_BASE + PCIE_EXT_CFG_OFF;
536         afi_writel(axi_address, AFI_AXI_BAR1_START);
537         afi_writel(size >> 12, AFI_AXI_BAR1_SZ);
538         afi_writel(fpci_bar, AFI_FPCI_BAR1);
539
540         /* Bar 2: downstream IO bar */
541         fpci_bar = ((__u32)0xfdfc << 16);
542         size = MMIO_SIZE;
543         axi_address = MMIO_BASE;
544         afi_writel(axi_address, AFI_AXI_BAR2_START);
545         afi_writel(size >> 12, AFI_AXI_BAR2_SZ);
546         afi_writel(fpci_bar, AFI_FPCI_BAR2);
547
548         /* Bar 3: prefetchable memory BAR */
549         fpci_bar = (((PREFETCH_MEM_BASE_0 >> 12) & 0x0fffffff) << 4) | 0x1;
550         size =  PREFETCH_MEM_SIZE_0 +  PREFETCH_MEM_SIZE_1;
551         axi_address = PREFETCH_MEM_BASE_0;
552         afi_writel(axi_address, AFI_AXI_BAR3_START);
553         afi_writel(size >> 12, AFI_AXI_BAR3_SZ);
554         afi_writel(fpci_bar, AFI_FPCI_BAR3);
555
556         /* Bar 4: non prefetchable memory BAR */
557         fpci_bar = (((MEM_BASE_0 >> 12) & 0x0FFFFFFF) << 4) | 0x1;
558         size = MEM_SIZE_0 + MEM_SIZE_1;
559         axi_address = MEM_BASE_0;
560         afi_writel(axi_address, AFI_AXI_BAR4_START);
561         afi_writel(size >> 12, AFI_AXI_BAR4_SZ);
562         afi_writel(fpci_bar, AFI_FPCI_BAR4);
563
564         /* Bar 5: NULL out the remaining BAR as it is not used */
565         fpci_bar = 0;
566         size = 0;
567         axi_address = 0;
568         afi_writel(axi_address, AFI_AXI_BAR5_START);
569         afi_writel(size >> 12, AFI_AXI_BAR5_SZ);
570         afi_writel(fpci_bar, AFI_FPCI_BAR5);
571
572         /* map all upstream transactions as uncached */
573         afi_writel(PHYS_OFFSET, AFI_CACHE_BAR0_ST);
574         afi_writel(0, AFI_CACHE_BAR0_SZ);
575         afi_writel(0, AFI_CACHE_BAR1_ST);
576         afi_writel(0, AFI_CACHE_BAR1_SZ);
577
578         /* No MSI */
579         afi_writel(0, AFI_MSI_FPCI_BAR_ST);
580         afi_writel(0, AFI_MSI_BAR_SZ);
581         afi_writel(0, AFI_MSI_AXI_BAR_ST);
582         afi_writel(0, AFI_MSI_BAR_SZ);
583 }
584
585 static void tegra_pcie_enable_controller(void)
586 {
587         u32 val, reg;
588         int i;
589
590         /* Enable slot clock and pulse the reset signals */
591         for (i = 0, reg = AFI_PEX0_CTRL; i < 2; i++, reg += 0x8) {
592                 val = afi_readl(reg) |  AFI_PEX_CTRL_REFCLK_EN;
593                 afi_writel(val, reg);
594                 val &= ~AFI_PEX_CTRL_RST;
595                 afi_writel(val, reg);
596
597                 val = afi_readl(reg) | AFI_PEX_CTRL_RST;
598                 afi_writel(val, reg);
599         }
600
601         /* Enable dual controller and both ports */
602         val = afi_readl(AFI_PCIE_CONFIG);
603         val &= ~(AFI_PCIE_CONFIG_PCIEC0_DISABLE_DEVICE |
604                  AFI_PCIE_CONFIG_PCIEC1_DISABLE_DEVICE |
605                  AFI_PCIE_CONFIG_SM2TMS0_XBAR_CONFIG_MASK);
606         val |= AFI_PCIE_CONFIG_SM2TMS0_XBAR_CONFIG_DUAL;
607         afi_writel(val, AFI_PCIE_CONFIG);
608
609         val = afi_readl(AFI_FUSE) & ~AFI_FUSE_PCIE_T0_GEN2_DIS;
610         afi_writel(val, AFI_FUSE);
611
612         /* Initialze internal PHY, enable up to 16 PCIE lanes */
613         pads_writel(0x0, PADS_CTL_SEL);
614
615         /* override IDDQ to 1 on all 4 lanes */
616         val = pads_readl(PADS_CTL) | PADS_CTL_IDDQ_1L;
617         pads_writel(val, PADS_CTL);
618
619         /*
620          * set up PHY PLL inputs select PLLE output as refclock,
621          * set TX ref sel to div10 (not div5)
622          */
623         val = pads_readl(PADS_PLL_CTL);
624         val &= ~(PADS_PLL_CTL_REFCLK_MASK | PADS_PLL_CTL_TXCLKREF_MASK);
625         val |= (PADS_PLL_CTL_REFCLK_INTERNAL_CML | PADS_PLL_CTL_TXCLKREF_DIV10);
626         pads_writel(val, PADS_PLL_CTL);
627
628         /* take PLL out of reset  */
629         val = pads_readl(PADS_PLL_CTL) | PADS_PLL_CTL_RST_B4SM;
630         pads_writel(val, PADS_PLL_CTL);
631
632         /*
633          * Hack, set the clock voltage to the DEFAULT provided by hw folks.
634          * This doesn't exist in the documentation
635          */
636         pads_writel(0xfa5cfa5c, 0xc8);
637
638         /* Wait for the PLL to lock */
639         do {
640                 val = pads_readl(PADS_PLL_CTL);
641         } while (!(val & PADS_PLL_CTL_LOCKDET));
642
643         /* turn off IDDQ override */
644         val = pads_readl(PADS_CTL) & ~PADS_CTL_IDDQ_1L;
645         pads_writel(val, PADS_CTL);
646
647         /* enable TX/RX data */
648         val = pads_readl(PADS_CTL);
649         val |= (PADS_CTL_TX_DATA_EN_1L | PADS_CTL_RX_DATA_EN_1L);
650         pads_writel(val, PADS_CTL);
651
652         /* Take the PCIe interface module out of reset */
653         tegra_periph_reset_deassert(tegra_pcie.pcie_xclk);
654
655         /* Finally enable PCIe */
656         val = afi_readl(AFI_CONFIGURATION) | AFI_CONFIGURATION_EN_FPCI;
657         afi_writel(val, AFI_CONFIGURATION);
658
659         val = (AFI_INTR_EN_INI_SLVERR | AFI_INTR_EN_INI_DECERR |
660                AFI_INTR_EN_TGT_SLVERR | AFI_INTR_EN_TGT_DECERR |
661                AFI_INTR_EN_TGT_WRERR | AFI_INTR_EN_DFPCI_DECERR);
662         afi_writel(val, AFI_AFI_INTR_ENABLE);
663         afi_writel(0xffffffff, AFI_SM_INTR_ENABLE);
664
665         /* FIXME: No MSI for now, only INT */
666         afi_writel(AFI_INTR_MASK_INT_MASK, AFI_INTR_MASK);
667
668         /* Disable all execptions */
669         afi_writel(0, AFI_FPCI_ERROR_MASKS);
670
671         return;
672 }
673
674 static void tegra_pcie_xclk_clamp(bool clamp)
675 {
676         u32 reg;
677
678         reg = pmc_readl(PMC_SCRATCH42) & ~PMC_SCRATCH42_PCX_CLAMP;
679
680         if (clamp)
681                 reg |= PMC_SCRATCH42_PCX_CLAMP;
682
683         pmc_writel(reg, PMC_SCRATCH42);
684 }
685
686 static void tegra_pcie_power_off(void)
687 {
688         tegra_periph_reset_assert(tegra_pcie.pcie_xclk);
689         tegra_periph_reset_assert(tegra_pcie.afi_clk);
690         tegra_periph_reset_assert(tegra_pcie.pex_clk);
691
692         tegra_powergate_power_off(TEGRA_POWERGATE_PCIE);
693         tegra_pcie_xclk_clamp(true);
694 }
695
696 static int tegra_pcie_power_regate(void)
697 {
698         int err;
699
700         tegra_pcie_power_off();
701
702         tegra_pcie_xclk_clamp(true);
703
704         tegra_periph_reset_assert(tegra_pcie.pcie_xclk);
705         tegra_periph_reset_assert(tegra_pcie.afi_clk);
706
707         err = tegra_powergate_sequence_power_up(TEGRA_POWERGATE_PCIE,
708                                                 tegra_pcie.pex_clk);
709         if (err) {
710                 pr_err("PCIE: powerup sequence failed: %d\n", err);
711                 return err;
712         }
713
714         tegra_periph_reset_deassert(tegra_pcie.afi_clk);
715
716         tegra_pcie_xclk_clamp(false);
717
718         clk_enable(tegra_pcie.afi_clk);
719         clk_enable(tegra_pcie.pex_clk);
720         return clk_enable(tegra_pcie.pll_e);
721 }
722
723 static int tegra_pcie_clocks_get(void)
724 {
725         int err;
726
727         tegra_pcie.pex_clk = clk_get(NULL, "pex");
728         if (IS_ERR(tegra_pcie.pex_clk))
729                 return PTR_ERR(tegra_pcie.pex_clk);
730
731         tegra_pcie.afi_clk = clk_get(NULL, "afi");
732         if (IS_ERR(tegra_pcie.afi_clk)) {
733                 err = PTR_ERR(tegra_pcie.afi_clk);
734                 goto err_afi_clk;
735         }
736
737         tegra_pcie.pcie_xclk = clk_get(NULL, "pcie_xclk");
738         if (IS_ERR(tegra_pcie.pcie_xclk)) {
739                 err =  PTR_ERR(tegra_pcie.pcie_xclk);
740                 goto err_pcie_xclk;
741         }
742
743         tegra_pcie.pll_e = clk_get_sys(NULL, "pll_e");
744         if (IS_ERR(tegra_pcie.pll_e)) {
745                 err = PTR_ERR(tegra_pcie.pll_e);
746                 goto err_pll_e;
747         }
748
749         return 0;
750
751 err_pll_e:
752         clk_put(tegra_pcie.pcie_xclk);
753 err_pcie_xclk:
754         clk_put(tegra_pcie.afi_clk);
755 err_afi_clk:
756         clk_put(tegra_pcie.pex_clk);
757
758         return err;
759 }
760
761 static void tegra_pcie_clocks_put(void)
762 {
763         clk_put(tegra_pcie.pll_e);
764         clk_put(tegra_pcie.pcie_xclk);
765         clk_put(tegra_pcie.afi_clk);
766         clk_put(tegra_pcie.pex_clk);
767 }
768
769 static int __init tegra_pcie_get_resources(void)
770 {
771         struct resource *res_mmio = &tegra_pcie.res_mmio;
772         int err;
773
774         err = tegra_pcie_clocks_get();
775         if (err) {
776                 pr_err("PCIE: failed to get clocks: %d\n", err);
777                 return err;
778         }
779
780         err = tegra_pcie_power_regate();
781         if (err) {
782                 pr_err("PCIE: failed to power up: %d\n", err);
783                 goto err_pwr_on;
784         }
785
786         tegra_pcie.regs = ioremap_nocache(TEGRA_PCIE_BASE, PCIE_IOMAP_SZ);
787         if (tegra_pcie.regs == NULL) {
788                 pr_err("PCIE: Failed to map PCI/AFI registers\n");
789                 err = -ENOMEM;
790                 goto err_map_reg;
791         }
792
793         err = request_resource(&iomem_resource, res_mmio);
794         if (err) {
795                 pr_err("PCIE: Failed to request resources: %d\n", err);
796                 goto err_req_io;
797         }
798
799         tegra_pcie_io_base = ioremap_nocache(res_mmio->start,
800                                              resource_size(res_mmio));
801         if (tegra_pcie_io_base == NULL) {
802                 pr_err("PCIE: Failed to map IO\n");
803                 err = -ENOMEM;
804                 goto err_map_io;
805         }
806
807         err = request_irq(INT_PCIE_INTR, tegra_pcie_isr,
808                           IRQF_SHARED, "PCIE", &tegra_pcie);
809         if (err) {
810                 pr_err("PCIE: Failed to register IRQ: %d\n", err);
811                 goto err_irq;
812         }
813         set_irq_flags(INT_PCIE_INTR, IRQF_VALID);
814
815         return 0;
816
817 err_irq:
818         iounmap(tegra_pcie_io_base);
819 err_map_io:
820         release_resource(&tegra_pcie.res_mmio);
821 err_req_io:
822         iounmap(tegra_pcie.regs);
823 err_map_reg:
824         tegra_pcie_power_off();
825 err_pwr_on:
826         tegra_pcie_clocks_put();
827
828         return err;
829 }
830
831 /*
832  * FIXME: If there are no PCIe cards attached, then calling this function
833  * can result in the increase of the bootup time as there are big timeout
834  * loops.
835  */
836 #define TEGRA_PCIE_LINKUP_TIMEOUT       200     /* up to 1.2 seconds */
837 static bool tegra_pcie_check_link(struct tegra_pcie_port *pp, int idx,
838                                   u32 reset_reg)
839 {
840         u32 reg;
841         int retries = 3;
842         int timeout;
843
844         do {
845                 timeout = TEGRA_PCIE_LINKUP_TIMEOUT;
846                 while (timeout) {
847                         reg = readl(pp->base + RP_VEND_XP);
848
849                         if (reg & RP_VEND_XP_DL_UP)
850                                 break;
851
852                         mdelay(1);
853                         timeout--;
854                 }
855
856                 if (!timeout)  {
857                         pr_err("PCIE: port %d: link down, retrying\n", idx);
858                         goto retry;
859                 }
860
861                 timeout = TEGRA_PCIE_LINKUP_TIMEOUT;
862                 while (timeout) {
863                         reg = readl(pp->base + RP_LINK_CONTROL_STATUS);
864
865                         if (reg & 0x20000000)
866                                 return true;
867
868                         mdelay(1);
869                         timeout--;
870                 }
871
872 retry:
873                 /* Pulse the PEX reset */
874                 reg = afi_readl(reset_reg) | AFI_PEX_CTRL_RST;
875                 afi_writel(reg, reset_reg);
876                 mdelay(1);
877                 reg = afi_readl(reset_reg) & ~AFI_PEX_CTRL_RST;
878                 afi_writel(reg, reset_reg);
879
880                 retries--;
881         } while (retries);
882
883         return false;
884 }
885
886 static void __init tegra_pcie_add_port(int index, u32 offset, u32 reset_reg)
887 {
888         struct tegra_pcie_port *pp;
889
890         pp = tegra_pcie.port + tegra_pcie.num_ports;
891
892         pp->index = -1;
893         pp->base = tegra_pcie.regs + offset;
894         pp->link_up = tegra_pcie_check_link(pp, index, reset_reg);
895
896         if (!pp->link_up) {
897                 pp->base = NULL;
898                 printk(KERN_INFO "PCIE: port %d: link down, ignoring\n", index);
899                 return;
900         }
901
902         tegra_pcie.num_ports++;
903         pp->index = index;
904         pp->root_bus_nr = -1;
905         memset(pp->res, 0, sizeof(pp->res));
906 }
907
908 int __init tegra_pcie_init(bool init_port0, bool init_port1)
909 {
910         int err;
911
912         if (!(init_port0 || init_port1))
913                 return -ENODEV;
914
915         err = tegra_pcie_get_resources();
916         if (err)
917                 return err;
918
919         tegra_pcie_enable_controller();
920
921         /* setup the AFI address translations */
922         tegra_pcie_setup_translations();
923
924         if (init_port0)
925                 tegra_pcie_add_port(0, RP0_OFFSET, AFI_PEX0_CTRL);
926
927         if (init_port1)
928                 tegra_pcie_add_port(1, RP1_OFFSET, AFI_PEX1_CTRL);
929
930         pci_common_init(&tegra_pcie_hw);
931
932         return 0;
933 }