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