?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
mm: move shmem prototypes to shmem_fs.h
[linux/fpc-iii.git] / arch / arm / mach-tegra / pcie.c
blob2941212b853c8942f377c2cc84953f879d947785
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 }
Linux with added FPC-III support