?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
clk: ux500: pass clock base adresses in init call
[linux-2.6.git] / arch / arm / mach-tegra / pcie.c
blobb60165f1ca02c56b76b78323a0d03119b871e9b8
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 #include <linux/clk/tegra.h>
37
38 #include <asm/sizes.h>
39 #include <asm/mach/pci.h>
40
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 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 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 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 }
Linus' kernel tree