?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
jme: Do not enable NIC WoL functions on S0
[linux/fpc-iii.git] / drivers / pci / host / pci-tegra.c
blob0407b1d6bab8e608c573880edc11695ddf355d04
1 /*
2 * PCIe host controller driver for Tegra SoCs
3 *
4 * Copyright (c) 2010, CompuLab, Ltd.
5 * Author: Mike Rapoport <mike@compulab.co.il>
6 *
7 * Based on NVIDIA PCIe driver
8 * Copyright (c) 2008-2009, NVIDIA Corporation.
9 *
10 * Bits taken from arch/arm/mach-dove/pcie.c
11 *
12 * This program is free software; you can redistribute it and/or modify
13 * it under the terms of the GNU General Public License as published by
14 * the Free Software Foundation; either version 2 of the License, or
15 * (at your option) any later version.
16 *
17 * This program is distributed in the hope that it will be useful, but WITHOUT
18 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
19 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
20 * more details.
21 *
22 * You should have received a copy of the GNU General Public License along
23 * with this program; if not, write to the Free Software Foundation, Inc.,
24 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
25 */
26
27 #include <linux/clk.h>
28 #include <linux/delay.h>
29 #include <linux/export.h>
30 #include <linux/interrupt.h>
31 #include <linux/irq.h>
32 #include <linux/irqdomain.h>
33 #include <linux/kernel.h>
34 #include <linux/module.h>
35 #include <linux/msi.h>
36 #include <linux/of_address.h>
37 #include <linux/of_pci.h>
38 #include <linux/of_platform.h>
39 #include <linux/pci.h>
40 #include <linux/platform_device.h>
41 #include <linux/reset.h>
42 #include <linux/sizes.h>
43 #include <linux/slab.h>
44 #include <linux/tegra-cpuidle.h>
45 #include <linux/tegra-powergate.h>
46 #include <linux/vmalloc.h>
47 #include <linux/regulator/consumer.h>
48
49 #include <asm/mach/irq.h>
50 #include <asm/mach/map.h>
51 #include <asm/mach/pci.h>
52
53 #define INT_PCI_MSI_NR (8 * 32)
54
55 /* register definitions */
56
57 #define AFI_AXI_BAR0_SZ 0x00
58 #define AFI_AXI_BAR1_SZ 0x04
59 #define AFI_AXI_BAR2_SZ 0x08
60 #define AFI_AXI_BAR3_SZ 0x0c
61 #define AFI_AXI_BAR4_SZ 0x10
62 #define AFI_AXI_BAR5_SZ 0x14
63
64 #define AFI_AXI_BAR0_START 0x18
65 #define AFI_AXI_BAR1_START 0x1c
66 #define AFI_AXI_BAR2_START 0x20
67 #define AFI_AXI_BAR3_START 0x24
68 #define AFI_AXI_BAR4_START 0x28
69 #define AFI_AXI_BAR5_START 0x2c
70
71 #define AFI_FPCI_BAR0 0x30
72 #define AFI_FPCI_BAR1 0x34
73 #define AFI_FPCI_BAR2 0x38
74 #define AFI_FPCI_BAR3 0x3c
75 #define AFI_FPCI_BAR4 0x40
76 #define AFI_FPCI_BAR5 0x44
77
78 #define AFI_CACHE_BAR0_SZ 0x48
79 #define AFI_CACHE_BAR0_ST 0x4c
80 #define AFI_CACHE_BAR1_SZ 0x50
81 #define AFI_CACHE_BAR1_ST 0x54
82
83 #define AFI_MSI_BAR_SZ 0x60
84 #define AFI_MSI_FPCI_BAR_ST 0x64
85 #define AFI_MSI_AXI_BAR_ST 0x68
86
87 #define AFI_MSI_VEC0 0x6c
88 #define AFI_MSI_VEC1 0x70
89 #define AFI_MSI_VEC2 0x74
90 #define AFI_MSI_VEC3 0x78
91 #define AFI_MSI_VEC4 0x7c
92 #define AFI_MSI_VEC5 0x80
93 #define AFI_MSI_VEC6 0x84
94 #define AFI_MSI_VEC7 0x88
95
96 #define AFI_MSI_EN_VEC0 0x8c
97 #define AFI_MSI_EN_VEC1 0x90
98 #define AFI_MSI_EN_VEC2 0x94
99 #define AFI_MSI_EN_VEC3 0x98
100 #define AFI_MSI_EN_VEC4 0x9c
101 #define AFI_MSI_EN_VEC5 0xa0
102 #define AFI_MSI_EN_VEC6 0xa4
103 #define AFI_MSI_EN_VEC7 0xa8
104
105 #define AFI_CONFIGURATION 0xac
106 #define AFI_CONFIGURATION_EN_FPCI (1 << 0)
107
108 #define AFI_FPCI_ERROR_MASKS 0xb0
109
110 #define AFI_INTR_MASK 0xb4
111 #define AFI_INTR_MASK_INT_MASK (1 << 0)
112 #define AFI_INTR_MASK_MSI_MASK (1 << 8)
113
114 #define AFI_INTR_CODE 0xb8
115 #define AFI_INTR_CODE_MASK 0xf
116 #define AFI_INTR_AXI_SLAVE_ERROR 1
117 #define AFI_INTR_AXI_DECODE_ERROR 2
118 #define AFI_INTR_TARGET_ABORT 3
119 #define AFI_INTR_MASTER_ABORT 4
120 #define AFI_INTR_INVALID_WRITE 5
121 #define AFI_INTR_LEGACY 6
122 #define AFI_INTR_FPCI_DECODE_ERROR 7
123
124 #define AFI_INTR_SIGNATURE 0xbc
125 #define AFI_UPPER_FPCI_ADDRESS 0xc0
126 #define AFI_SM_INTR_ENABLE 0xc4
127 #define AFI_SM_INTR_INTA_ASSERT (1 << 0)
128 #define AFI_SM_INTR_INTB_ASSERT (1 << 1)
129 #define AFI_SM_INTR_INTC_ASSERT (1 << 2)
130 #define AFI_SM_INTR_INTD_ASSERT (1 << 3)
131 #define AFI_SM_INTR_INTA_DEASSERT (1 << 4)
132 #define AFI_SM_INTR_INTB_DEASSERT (1 << 5)
133 #define AFI_SM_INTR_INTC_DEASSERT (1 << 6)
134 #define AFI_SM_INTR_INTD_DEASSERT (1 << 7)
135
136 #define AFI_AFI_INTR_ENABLE 0xc8
137 #define AFI_INTR_EN_INI_SLVERR (1 << 0)
138 #define AFI_INTR_EN_INI_DECERR (1 << 1)
139 #define AFI_INTR_EN_TGT_SLVERR (1 << 2)
140 #define AFI_INTR_EN_TGT_DECERR (1 << 3)
141 #define AFI_INTR_EN_TGT_WRERR (1 << 4)
142 #define AFI_INTR_EN_DFPCI_DECERR (1 << 5)
143 #define AFI_INTR_EN_AXI_DECERR (1 << 6)
144 #define AFI_INTR_EN_FPCI_TIMEOUT (1 << 7)
145 #define AFI_INTR_EN_PRSNT_SENSE (1 << 8)
146
147 #define AFI_PCIE_CONFIG 0x0f8
148 #define AFI_PCIE_CONFIG_PCIE_DISABLE(x) (1 << ((x) + 1))
149 #define AFI_PCIE_CONFIG_PCIE_DISABLE_ALL 0xe
150 #define AFI_PCIE_CONFIG_SM2TMS0_XBAR_CONFIG_MASK (0xf << 20)
151 #define AFI_PCIE_CONFIG_SM2TMS0_XBAR_CONFIG_SINGLE (0x0 << 20)
152 #define AFI_PCIE_CONFIG_SM2TMS0_XBAR_CONFIG_420 (0x0 << 20)
153 #define AFI_PCIE_CONFIG_SM2TMS0_XBAR_CONFIG_DUAL (0x1 << 20)
154 #define AFI_PCIE_CONFIG_SM2TMS0_XBAR_CONFIG_222 (0x1 << 20)
155 #define AFI_PCIE_CONFIG_SM2TMS0_XBAR_CONFIG_411 (0x2 << 20)
156
157 #define AFI_FUSE 0x104
158 #define AFI_FUSE_PCIE_T0_GEN2_DIS (1 << 2)
159
160 #define AFI_PEX0_CTRL 0x110
161 #define AFI_PEX1_CTRL 0x118
162 #define AFI_PEX2_CTRL 0x128
163 #define AFI_PEX_CTRL_RST (1 << 0)
164 #define AFI_PEX_CTRL_CLKREQ_EN (1 << 1)
165 #define AFI_PEX_CTRL_REFCLK_EN (1 << 3)
166
167 #define AFI_PEXBIAS_CTRL_0 0x168
168
169 #define RP_VEND_XP 0x00000F00
170 #define RP_VEND_XP_DL_UP (1 << 30)
171
172 #define RP_LINK_CONTROL_STATUS 0x00000090
173 #define RP_LINK_CONTROL_STATUS_DL_LINK_ACTIVE 0x20000000
174 #define RP_LINK_CONTROL_STATUS_LINKSTAT_MASK 0x3fff0000
175
176 #define PADS_CTL_SEL 0x0000009C
177
178 #define PADS_CTL 0x000000A0
179 #define PADS_CTL_IDDQ_1L (1 << 0)
180 #define PADS_CTL_TX_DATA_EN_1L (1 << 6)
181 #define PADS_CTL_RX_DATA_EN_1L (1 << 10)
182
183 #define PADS_PLL_CTL_TEGRA20 0x000000B8
184 #define PADS_PLL_CTL_TEGRA30 0x000000B4
185 #define PADS_PLL_CTL_RST_B4SM (1 << 1)
186 #define PADS_PLL_CTL_LOCKDET (1 << 8)
187 #define PADS_PLL_CTL_REFCLK_MASK (0x3 << 16)
188 #define PADS_PLL_CTL_REFCLK_INTERNAL_CML (0 << 16)
189 #define PADS_PLL_CTL_REFCLK_INTERNAL_CMOS (1 << 16)
190 #define PADS_PLL_CTL_REFCLK_EXTERNAL (2 << 16)
191 #define PADS_PLL_CTL_TXCLKREF_MASK (0x1 << 20)
192 #define PADS_PLL_CTL_TXCLKREF_DIV10 (0 << 20)
193 #define PADS_PLL_CTL_TXCLKREF_DIV5 (1 << 20)
194 #define PADS_PLL_CTL_TXCLKREF_BUF_EN (1 << 22)
195
196 #define PADS_REFCLK_CFG0 0x000000C8
197 #define PADS_REFCLK_CFG1 0x000000CC
198
199 /*
200 * Fields in PADS_REFCLK_CFG*. Those registers form an array of 16-bit
201 * entries, one entry per PCIe port. These field definitions and desired
202 * values aren't in the TRM, but do come from NVIDIA.
203 */
204 #define PADS_REFCLK_CFG_TERM_SHIFT 2 /* 6:2 */
205 #define PADS_REFCLK_CFG_E_TERM_SHIFT 7
206 #define PADS_REFCLK_CFG_PREDI_SHIFT 8 /* 11:8 */
207 #define PADS_REFCLK_CFG_DRVI_SHIFT 12 /* 15:12 */
208
209 /* Default value provided by HW engineering is 0xfa5c */
210 #define PADS_REFCLK_CFG_VALUE \
211 ( \
212 (0x17 << PADS_REFCLK_CFG_TERM_SHIFT) | \
213 (0 << PADS_REFCLK_CFG_E_TERM_SHIFT) | \
214 (0xa << PADS_REFCLK_CFG_PREDI_SHIFT) | \
215 (0xf << PADS_REFCLK_CFG_DRVI_SHIFT) \
216 )
217
218 struct tegra_msi {
219 struct msi_chip chip;
220 DECLARE_BITMAP(used, INT_PCI_MSI_NR);
221 struct irq_domain *domain;
222 unsigned long pages;
223 struct mutex lock;
224 int irq;
225 };
226
227 /* used to differentiate between Tegra SoC generations */
228 struct tegra_pcie_soc_data {
229 unsigned int num_ports;
230 unsigned int msi_base_shift;
231 u32 pads_pll_ctl;
232 u32 tx_ref_sel;
233 bool has_pex_clkreq_en;
234 bool has_pex_bias_ctrl;
235 bool has_intr_prsnt_sense;
236 bool has_avdd_supply;
237 bool has_cml_clk;
238 };
239
240 static inline struct tegra_msi *to_tegra_msi(struct msi_chip *chip)
241 {
242 return container_of(chip, struct tegra_msi, chip);
243 }
244
245 struct tegra_pcie {
246 struct device *dev;
247
248 void __iomem *pads;
249 void __iomem *afi;
250 int irq;
251
252 struct list_head buses;
253 struct resource *cs;
254
255 struct resource io;
256 struct resource mem;
257 struct resource prefetch;
258 struct resource busn;
259
260 struct clk *pex_clk;
261 struct clk *afi_clk;
262 struct clk *pll_e;
263 struct clk *cml_clk;
264
265 struct reset_control *pex_rst;
266 struct reset_control *afi_rst;
267 struct reset_control *pcie_xrst;
268
269 struct tegra_msi msi;
270
271 struct list_head ports;
272 unsigned int num_ports;
273 u32 xbar_config;
274
275 struct regulator *pex_clk_supply;
276 struct regulator *vdd_supply;
277 struct regulator *avdd_supply;
278
279 const struct tegra_pcie_soc_data *soc_data;
280 };
281
282 struct tegra_pcie_port {
283 struct tegra_pcie *pcie;
284 struct list_head list;
285 struct resource regs;
286 void __iomem *base;
287 unsigned int index;
288 unsigned int lanes;
289 };
290
291 struct tegra_pcie_bus {
292 struct vm_struct *area;
293 struct list_head list;
294 unsigned int nr;
295 };
296
297 static inline struct tegra_pcie *sys_to_pcie(struct pci_sys_data *sys)
298 {
299 return sys->private_data;
300 }
301
302 static inline void afi_writel(struct tegra_pcie *pcie, u32 value,
303 unsigned long offset)
304 {
305 writel(value, pcie->afi + offset);
306 }
307
308 static inline u32 afi_readl(struct tegra_pcie *pcie, unsigned long offset)
309 {
310 return readl(pcie->afi + offset);
311 }
312
313 static inline void pads_writel(struct tegra_pcie *pcie, u32 value,
314 unsigned long offset)
315 {
316 writel(value, pcie->pads + offset);
317 }
318
319 static inline u32 pads_readl(struct tegra_pcie *pcie, unsigned long offset)
320 {
321 return readl(pcie->pads + offset);
322 }
323
324 /*
325 * The configuration space mapping on Tegra is somewhat similar to the ECAM
326 * defined by PCIe. However it deviates a bit in how the 4 bits for extended
327 * register accesses are mapped:
328 *
329 * [27:24] extended register number
330 * [23:16] bus number
331 * [15:11] device number
332 * [10: 8] function number
333 * [ 7: 0] register number
334 *
335 * Mapping the whole extended configuration space would require 256 MiB of
336 * virtual address space, only a small part of which will actually be used.
337 * To work around this, a 1 MiB of virtual addresses are allocated per bus
338 * when the bus is first accessed. When the physical range is mapped, the
339 * the bus number bits are hidden so that the extended register number bits
340 * appear as bits [19:16]. Therefore the virtual mapping looks like this:
341 *
342 * [19:16] extended register number
343 * [15:11] device number
344 * [10: 8] function number
345 * [ 7: 0] register number
346 *
347 * This is achieved by stitching together 16 chunks of 64 KiB of physical
348 * address space via the MMU.
349 */
350 static unsigned long tegra_pcie_conf_offset(unsigned int devfn, int where)
351 {
352 return ((where & 0xf00) << 8) | (PCI_SLOT(devfn) << 11) |
353 (PCI_FUNC(devfn) << 8) | (where & 0xfc);
354 }
355
356 static struct tegra_pcie_bus *tegra_pcie_bus_alloc(struct tegra_pcie *pcie,
357 unsigned int busnr)
358 {
359 pgprot_t prot = L_PTE_PRESENT | L_PTE_YOUNG | L_PTE_DIRTY | L_PTE_XN |
360 L_PTE_MT_DEV_SHARED | L_PTE_SHARED;
361 phys_addr_t cs = pcie->cs->start;
362 struct tegra_pcie_bus *bus;
363 unsigned int i;
364 int err;
365
366 bus = kzalloc(sizeof(*bus), GFP_KERNEL);
367 if (!bus)
368 return ERR_PTR(-ENOMEM);
369
370 INIT_LIST_HEAD(&bus->list);
371 bus->nr = busnr;
372
373 /* allocate 1 MiB of virtual addresses */
374 bus->area = get_vm_area(SZ_1M, VM_IOREMAP);
375 if (!bus->area) {
376 err = -ENOMEM;
377 goto free;
378 }
379
380 /* map each of the 16 chunks of 64 KiB each */
381 for (i = 0; i < 16; i++) {
382 unsigned long virt = (unsigned long)bus->area->addr +
383 i * SZ_64K;
384 phys_addr_t phys = cs + i * SZ_1M + busnr * SZ_64K;
385
386 err = ioremap_page_range(virt, virt + SZ_64K, phys, prot);
387 if (err < 0) {
388 dev_err(pcie->dev, "ioremap_page_range() failed: %d\n",
389 err);
390 goto unmap;
391 }
392 }
393
394 return bus;
395
396 unmap:
397 vunmap(bus->area->addr);
398 free:
399 kfree(bus);
400 return ERR_PTR(err);
401 }
402
403 /*
404 * Look up a virtual address mapping for the specified bus number. If no such
405 * mapping exists, try to create one.
406 */
407 static void __iomem *tegra_pcie_bus_map(struct tegra_pcie *pcie,
408 unsigned int busnr)
409 {
410 struct tegra_pcie_bus *bus;
411
412 list_for_each_entry(bus, &pcie->buses, list)
413 if (bus->nr == busnr)
414 return (void __iomem *)bus->area->addr;
415
416 bus = tegra_pcie_bus_alloc(pcie, busnr);
417 if (IS_ERR(bus))
418 return NULL;
419
420 list_add_tail(&bus->list, &pcie->buses);
421
422 return (void __iomem *)bus->area->addr;
423 }
424
425 static void __iomem *tegra_pcie_conf_address(struct pci_bus *bus,
426 unsigned int devfn,
427 int where)
428 {
429 struct tegra_pcie *pcie = sys_to_pcie(bus->sysdata);
430 void __iomem *addr = NULL;
431
432 if (bus->number == 0) {
433 unsigned int slot = PCI_SLOT(devfn);
434 struct tegra_pcie_port *port;
435
436 list_for_each_entry(port, &pcie->ports, list) {
437 if (port->index + 1 == slot) {
438 addr = port->base + (where & ~3);
439 break;
440 }
441 }
442 } else {
443 addr = tegra_pcie_bus_map(pcie, bus->number);
444 if (!addr) {
445 dev_err(pcie->dev,
446 "failed to map cfg. space for bus %u\n",
447 bus->number);
448 return NULL;
449 }
450
451 addr += tegra_pcie_conf_offset(devfn, where);
452 }
453
454 return addr;
455 }
456
457 static int tegra_pcie_read_conf(struct pci_bus *bus, unsigned int devfn,
458 int where, int size, u32 *value)
459 {
460 void __iomem *addr;
461
462 addr = tegra_pcie_conf_address(bus, devfn, where);
463 if (!addr) {
464 *value = 0xffffffff;
465 return PCIBIOS_DEVICE_NOT_FOUND;
466 }
467
468 *value = readl(addr);
469
470 if (size == 1)
471 *value = (*value >> (8 * (where & 3))) & 0xff;
472 else if (size == 2)
473 *value = (*value >> (8 * (where & 3))) & 0xffff;
474
475 return PCIBIOS_SUCCESSFUL;
476 }
477
478 static int tegra_pcie_write_conf(struct pci_bus *bus, unsigned int devfn,
479 int where, int size, u32 value)
480 {
481 void __iomem *addr;
482 u32 mask, tmp;
483
484 addr = tegra_pcie_conf_address(bus, devfn, where);
485 if (!addr)
486 return PCIBIOS_DEVICE_NOT_FOUND;
487
488 if (size == 4) {
489 writel(value, addr);
490 return PCIBIOS_SUCCESSFUL;
491 }
492
493 if (size == 2)
494 mask = ~(0xffff << ((where & 0x3) * 8));
495 else if (size == 1)
496 mask = ~(0xff << ((where & 0x3) * 8));
497 else
498 return PCIBIOS_BAD_REGISTER_NUMBER;
499
500 tmp = readl(addr) & mask;
501 tmp |= value << ((where & 0x3) * 8);
502 writel(tmp, addr);
503
504 return PCIBIOS_SUCCESSFUL;
505 }
506
507 static struct pci_ops tegra_pcie_ops = {
508 .read = tegra_pcie_read_conf,
509 .write = tegra_pcie_write_conf,
510 };
511
512 static unsigned long tegra_pcie_port_get_pex_ctrl(struct tegra_pcie_port *port)
513 {
514 unsigned long ret = 0;
515
516 switch (port->index) {
517 case 0:
518 ret = AFI_PEX0_CTRL;
519 break;
520
521 case 1:
522 ret = AFI_PEX1_CTRL;
523 break;
524
525 case 2:
526 ret = AFI_PEX2_CTRL;
527 break;
528 }
529
530 return ret;
531 }
532
533 static void tegra_pcie_port_reset(struct tegra_pcie_port *port)
534 {
535 unsigned long ctrl = tegra_pcie_port_get_pex_ctrl(port);
536 unsigned long value;
537
538 /* pulse reset signal */
539 value = afi_readl(port->pcie, ctrl);
540 value &= ~AFI_PEX_CTRL_RST;
541 afi_writel(port->pcie, value, ctrl);
542
543 usleep_range(1000, 2000);
544
545 value = afi_readl(port->pcie, ctrl);
546 value |= AFI_PEX_CTRL_RST;
547 afi_writel(port->pcie, value, ctrl);
548 }
549
550 static void tegra_pcie_port_enable(struct tegra_pcie_port *port)
551 {
552 const struct tegra_pcie_soc_data *soc = port->pcie->soc_data;
553 unsigned long ctrl = tegra_pcie_port_get_pex_ctrl(port);
554 unsigned long value;
555
556 /* enable reference clock */
557 value = afi_readl(port->pcie, ctrl);
558 value |= AFI_PEX_CTRL_REFCLK_EN;
559
560 if (soc->has_pex_clkreq_en)
561 value |= AFI_PEX_CTRL_CLKREQ_EN;
562
563 afi_writel(port->pcie, value, ctrl);
564
565 tegra_pcie_port_reset(port);
566 }
567
568 static void tegra_pcie_port_disable(struct tegra_pcie_port *port)
569 {
570 unsigned long ctrl = tegra_pcie_port_get_pex_ctrl(port);
571 unsigned long value;
572
573 /* assert port reset */
574 value = afi_readl(port->pcie, ctrl);
575 value &= ~AFI_PEX_CTRL_RST;
576 afi_writel(port->pcie, value, ctrl);
577
578 /* disable reference clock */
579 value = afi_readl(port->pcie, ctrl);
580 value &= ~AFI_PEX_CTRL_REFCLK_EN;
581 afi_writel(port->pcie, value, ctrl);
582 }
583
584 static void tegra_pcie_port_free(struct tegra_pcie_port *port)
585 {
586 struct tegra_pcie *pcie = port->pcie;
587
588 devm_iounmap(pcie->dev, port->base);
589 devm_release_mem_region(pcie->dev, port->regs.start,
590 resource_size(&port->regs));
591 list_del(&port->list);
592 devm_kfree(pcie->dev, port);
593 }
594
595 static void tegra_pcie_fixup_bridge(struct pci_dev *dev)
596 {
597 u16 reg;
598
599 if ((dev->class >> 16) == PCI_BASE_CLASS_BRIDGE) {
600 pci_read_config_word(dev, PCI_COMMAND, &reg);
601 reg |= (PCI_COMMAND_IO | PCI_COMMAND_MEMORY |
602 PCI_COMMAND_MASTER | PCI_COMMAND_SERR);
603 pci_write_config_word(dev, PCI_COMMAND, reg);
604 }
605 }
606 DECLARE_PCI_FIXUP_FINAL(PCI_ANY_ID, PCI_ANY_ID, tegra_pcie_fixup_bridge);
607
608 /* Tegra PCIE root complex wrongly reports device class */
609 static void tegra_pcie_fixup_class(struct pci_dev *dev)
610 {
611 dev->class = PCI_CLASS_BRIDGE_PCI << 8;
612 }
613 DECLARE_PCI_FIXUP_EARLY(PCI_VENDOR_ID_NVIDIA, 0x0bf0, tegra_pcie_fixup_class);
614 DECLARE_PCI_FIXUP_EARLY(PCI_VENDOR_ID_NVIDIA, 0x0bf1, tegra_pcie_fixup_class);
615 DECLARE_PCI_FIXUP_EARLY(PCI_VENDOR_ID_NVIDIA, 0x0e1c, tegra_pcie_fixup_class);
616 DECLARE_PCI_FIXUP_EARLY(PCI_VENDOR_ID_NVIDIA, 0x0e1d, tegra_pcie_fixup_class);
617
618 /* Tegra PCIE requires relaxed ordering */
619 static void tegra_pcie_relax_enable(struct pci_dev *dev)
620 {
621 pcie_capability_set_word(dev, PCI_EXP_DEVCTL, PCI_EXP_DEVCTL_RELAX_EN);
622 }
623 DECLARE_PCI_FIXUP_FINAL(PCI_ANY_ID, PCI_ANY_ID, tegra_pcie_relax_enable);
624
625 static int tegra_pcie_setup(int nr, struct pci_sys_data *sys)
626 {
627 struct tegra_pcie *pcie = sys_to_pcie(sys);
628
629 pci_add_resource_offset(&sys->resources, &pcie->mem, sys->mem_offset);
630 pci_add_resource_offset(&sys->resources, &pcie->prefetch,
631 sys->mem_offset);
632 pci_add_resource(&sys->resources, &pcie->busn);
633
634 pci_ioremap_io(nr * SZ_64K, pcie->io.start);
635
636 return 1;
637 }
638
639 static int tegra_pcie_map_irq(const struct pci_dev *pdev, u8 slot, u8 pin)
640 {
641 struct tegra_pcie *pcie = sys_to_pcie(pdev->bus->sysdata);
642 int irq;
643
644 tegra_cpuidle_pcie_irqs_in_use();
645
646 irq = of_irq_parse_and_map_pci(pdev, slot, pin);
647 if (!irq)
648 irq = pcie->irq;
649
650 return irq;
651 }
652
653 static void tegra_pcie_add_bus(struct pci_bus *bus)
654 {
655 if (IS_ENABLED(CONFIG_PCI_MSI)) {
656 struct tegra_pcie *pcie = sys_to_pcie(bus->sysdata);
657
658 bus->msi = &pcie->msi.chip;
659 }
660 }
661
662 static struct pci_bus *tegra_pcie_scan_bus(int nr, struct pci_sys_data *sys)
663 {
664 struct tegra_pcie *pcie = sys_to_pcie(sys);
665 struct pci_bus *bus;
666
667 bus = pci_create_root_bus(pcie->dev, sys->busnr, &tegra_pcie_ops, sys,
668 &sys->resources);
669 if (!bus)
670 return NULL;
671
672 pci_scan_child_bus(bus);
673
674 return bus;
675 }
676
677 static irqreturn_t tegra_pcie_isr(int irq, void *arg)
678 {
679 const char *err_msg[] = {
680 "Unknown",
681 "AXI slave error",
682 "AXI decode error",
683 "Target abort",
684 "Master abort",
685 "Invalid write",
686 "Response decoding error",
687 "AXI response decoding error",
688 "Transaction timeout",
689 };
690 struct tegra_pcie *pcie = arg;
691 u32 code, signature;
692
693 code = afi_readl(pcie, AFI_INTR_CODE) & AFI_INTR_CODE_MASK;
694 signature = afi_readl(pcie, AFI_INTR_SIGNATURE);
695 afi_writel(pcie, 0, AFI_INTR_CODE);
696
697 if (code == AFI_INTR_LEGACY)
698 return IRQ_NONE;
699
700 if (code >= ARRAY_SIZE(err_msg))
701 code = 0;
702
703 /*
704 * do not pollute kernel log with master abort reports since they
705 * happen a lot during enumeration
706 */
707 if (code == AFI_INTR_MASTER_ABORT)
708 dev_dbg(pcie->dev, "%s, signature: %08x\n", err_msg[code],
709 signature);
710 else
711 dev_err(pcie->dev, "%s, signature: %08x\n", err_msg[code],
712 signature);
713
714 if (code == AFI_INTR_TARGET_ABORT || code == AFI_INTR_MASTER_ABORT ||
715 code == AFI_INTR_FPCI_DECODE_ERROR) {
716 u32 fpci = afi_readl(pcie, AFI_UPPER_FPCI_ADDRESS) & 0xff;
717 u64 address = (u64)fpci << 32 | (signature & 0xfffffffc);
718
719 if (code == AFI_INTR_MASTER_ABORT)
720 dev_dbg(pcie->dev, " FPCI address: %10llx\n", address);
721 else
722 dev_err(pcie->dev, " FPCI address: %10llx\n", address);
723 }
724
725 return IRQ_HANDLED;
726 }
727
728 /*
729 * FPCI map is as follows:
730 * - 0xfdfc000000: I/O space
731 * - 0xfdfe000000: type 0 configuration space
732 * - 0xfdff000000: type 1 configuration space
733 * - 0xfe00000000: type 0 extended configuration space
734 * - 0xfe10000000: type 1 extended configuration space
735 */
736 static void tegra_pcie_setup_translations(struct tegra_pcie *pcie)
737 {
738 u32 fpci_bar, size, axi_address;
739
740 /* Bar 0: type 1 extended configuration space */
741 fpci_bar = 0xfe100000;
742 size = resource_size(pcie->cs);
743 axi_address = pcie->cs->start;
744 afi_writel(pcie, axi_address, AFI_AXI_BAR0_START);
745 afi_writel(pcie, size >> 12, AFI_AXI_BAR0_SZ);
746 afi_writel(pcie, fpci_bar, AFI_FPCI_BAR0);
747
748 /* Bar 1: downstream IO bar */
749 fpci_bar = 0xfdfc0000;
750 size = resource_size(&pcie->io);
751 axi_address = pcie->io.start;
752 afi_writel(pcie, axi_address, AFI_AXI_BAR1_START);
753 afi_writel(pcie, size >> 12, AFI_AXI_BAR1_SZ);
754 afi_writel(pcie, fpci_bar, AFI_FPCI_BAR1);
755
756 /* Bar 2: prefetchable memory BAR */
757 fpci_bar = (((pcie->prefetch.start >> 12) & 0x0fffffff) << 4) | 0x1;
758 size = resource_size(&pcie->prefetch);
759 axi_address = pcie->prefetch.start;
760 afi_writel(pcie, axi_address, AFI_AXI_BAR2_START);
761 afi_writel(pcie, size >> 12, AFI_AXI_BAR2_SZ);
762 afi_writel(pcie, fpci_bar, AFI_FPCI_BAR2);
763
764 /* Bar 3: non prefetchable memory BAR */
765 fpci_bar = (((pcie->mem.start >> 12) & 0x0fffffff) << 4) | 0x1;
766 size = resource_size(&pcie->mem);
767 axi_address = pcie->mem.start;
768 afi_writel(pcie, axi_address, AFI_AXI_BAR3_START);
769 afi_writel(pcie, size >> 12, AFI_AXI_BAR3_SZ);
770 afi_writel(pcie, fpci_bar, AFI_FPCI_BAR3);
771
772 /* NULL out the remaining BARs as they are not used */
773 afi_writel(pcie, 0, AFI_AXI_BAR4_START);
774 afi_writel(pcie, 0, AFI_AXI_BAR4_SZ);
775 afi_writel(pcie, 0, AFI_FPCI_BAR4);
776
777 afi_writel(pcie, 0, AFI_AXI_BAR5_START);
778 afi_writel(pcie, 0, AFI_AXI_BAR5_SZ);
779 afi_writel(pcie, 0, AFI_FPCI_BAR5);
780
781 /* map all upstream transactions as uncached */
782 afi_writel(pcie, PHYS_OFFSET, AFI_CACHE_BAR0_ST);
783 afi_writel(pcie, 0, AFI_CACHE_BAR0_SZ);
784 afi_writel(pcie, 0, AFI_CACHE_BAR1_ST);
785 afi_writel(pcie, 0, AFI_CACHE_BAR1_SZ);
786
787 /* MSI translations are setup only when needed */
788 afi_writel(pcie, 0, AFI_MSI_FPCI_BAR_ST);
789 afi_writel(pcie, 0, AFI_MSI_BAR_SZ);
790 afi_writel(pcie, 0, AFI_MSI_AXI_BAR_ST);
791 afi_writel(pcie, 0, AFI_MSI_BAR_SZ);
792 }
793
794 static int tegra_pcie_enable_controller(struct tegra_pcie *pcie)
795 {
796 const struct tegra_pcie_soc_data *soc = pcie->soc_data;
797 struct tegra_pcie_port *port;
798 unsigned int timeout;
799 unsigned long value;
800
801 /* power down PCIe slot clock bias pad */
802 if (soc->has_pex_bias_ctrl)
803 afi_writel(pcie, 0, AFI_PEXBIAS_CTRL_0);
804
805 /* configure mode and disable all ports */
806 value = afi_readl(pcie, AFI_PCIE_CONFIG);
807 value &= ~AFI_PCIE_CONFIG_SM2TMS0_XBAR_CONFIG_MASK;
808 value |= AFI_PCIE_CONFIG_PCIE_DISABLE_ALL | pcie->xbar_config;
809
810 list_for_each_entry(port, &pcie->ports, list)
811 value &= ~AFI_PCIE_CONFIG_PCIE_DISABLE(port->index);
812
813 afi_writel(pcie, value, AFI_PCIE_CONFIG);
814
815 value = afi_readl(pcie, AFI_FUSE);
816 value |= AFI_FUSE_PCIE_T0_GEN2_DIS;
817 afi_writel(pcie, value, AFI_FUSE);
818
819 /* initialize internal PHY, enable up to 16 PCIE lanes */
820 pads_writel(pcie, 0x0, PADS_CTL_SEL);
821
822 /* override IDDQ to 1 on all 4 lanes */
823 value = pads_readl(pcie, PADS_CTL);
824 value |= PADS_CTL_IDDQ_1L;
825 pads_writel(pcie, value, PADS_CTL);
826
827 /*
828 * Set up PHY PLL inputs select PLLE output as refclock,
829 * set TX ref sel to div10 (not div5).
830 */
831 value = pads_readl(pcie, soc->pads_pll_ctl);
832 value &= ~(PADS_PLL_CTL_REFCLK_MASK | PADS_PLL_CTL_TXCLKREF_MASK);
833 value |= PADS_PLL_CTL_REFCLK_INTERNAL_CML | soc->tx_ref_sel;
834 pads_writel(pcie, value, soc->pads_pll_ctl);
835
836 /* take PLL out of reset */
837 value = pads_readl(pcie, soc->pads_pll_ctl);
838 value |= PADS_PLL_CTL_RST_B4SM;
839 pads_writel(pcie, value, soc->pads_pll_ctl);
840
841 /* Configure the reference clock driver */
842 value = PADS_REFCLK_CFG_VALUE | (PADS_REFCLK_CFG_VALUE << 16);
843 pads_writel(pcie, value, PADS_REFCLK_CFG0);
844 if (soc->num_ports > 2)
845 pads_writel(pcie, PADS_REFCLK_CFG_VALUE, PADS_REFCLK_CFG1);
846
847 /* wait for the PLL to lock */
848 timeout = 300;
849 do {
850 value = pads_readl(pcie, soc->pads_pll_ctl);
851 usleep_range(1000, 2000);
852 if (--timeout == 0) {
853 pr_err("Tegra PCIe error: timeout waiting for PLL\n");
854 return -EBUSY;
855 }
856 } while (!(value & PADS_PLL_CTL_LOCKDET));
857
858 /* turn off IDDQ override */
859 value = pads_readl(pcie, PADS_CTL);
860 value &= ~PADS_CTL_IDDQ_1L;
861 pads_writel(pcie, value, PADS_CTL);
862
863 /* enable TX/RX data */
864 value = pads_readl(pcie, PADS_CTL);
865 value |= PADS_CTL_TX_DATA_EN_1L | PADS_CTL_RX_DATA_EN_1L;
866 pads_writel(pcie, value, PADS_CTL);
867
868 /* take the PCIe interface module out of reset */
869 reset_control_deassert(pcie->pcie_xrst);
870
871 /* finally enable PCIe */
872 value = afi_readl(pcie, AFI_CONFIGURATION);
873 value |= AFI_CONFIGURATION_EN_FPCI;
874 afi_writel(pcie, value, AFI_CONFIGURATION);
875
876 value = AFI_INTR_EN_INI_SLVERR | AFI_INTR_EN_INI_DECERR |
877 AFI_INTR_EN_TGT_SLVERR | AFI_INTR_EN_TGT_DECERR |
878 AFI_INTR_EN_TGT_WRERR | AFI_INTR_EN_DFPCI_DECERR;
879
880 if (soc->has_intr_prsnt_sense)
881 value |= AFI_INTR_EN_PRSNT_SENSE;
882
883 afi_writel(pcie, value, AFI_AFI_INTR_ENABLE);
884 afi_writel(pcie, 0xffffffff, AFI_SM_INTR_ENABLE);
885
886 /* don't enable MSI for now, only when needed */
887 afi_writel(pcie, AFI_INTR_MASK_INT_MASK, AFI_INTR_MASK);
888
889 /* disable all exceptions */
890 afi_writel(pcie, 0, AFI_FPCI_ERROR_MASKS);
891
892 return 0;
893 }
894
895 static void tegra_pcie_power_off(struct tegra_pcie *pcie)
896 {
897 const struct tegra_pcie_soc_data *soc = pcie->soc_data;
898 int err;
899
900 /* TODO: disable and unprepare clocks? */
901
902 reset_control_assert(pcie->pcie_xrst);
903 reset_control_assert(pcie->afi_rst);
904 reset_control_assert(pcie->pex_rst);
905
906 tegra_powergate_power_off(TEGRA_POWERGATE_PCIE);
907
908 if (soc->has_avdd_supply) {
909 err = regulator_disable(pcie->avdd_supply);
910 if (err < 0)
911 dev_warn(pcie->dev,
912 "failed to disable AVDD regulator: %d\n",
913 err);
914 }
915
916 err = regulator_disable(pcie->pex_clk_supply);
917 if (err < 0)
918 dev_warn(pcie->dev, "failed to disable pex-clk regulator: %d\n",
919 err);
920
921 err = regulator_disable(pcie->vdd_supply);
922 if (err < 0)
923 dev_warn(pcie->dev, "failed to disable VDD regulator: %d\n",
924 err);
925 }
926
927 static int tegra_pcie_power_on(struct tegra_pcie *pcie)
928 {
929 const struct tegra_pcie_soc_data *soc = pcie->soc_data;
930 int err;
931
932 reset_control_assert(pcie->pcie_xrst);
933 reset_control_assert(pcie->afi_rst);
934 reset_control_assert(pcie->pex_rst);
935
936 tegra_powergate_power_off(TEGRA_POWERGATE_PCIE);
937
938 /* enable regulators */
939 err = regulator_enable(pcie->vdd_supply);
940 if (err < 0) {
941 dev_err(pcie->dev, "failed to enable VDD regulator: %d\n", err);
942 return err;
943 }
944
945 err = regulator_enable(pcie->pex_clk_supply);
946 if (err < 0) {
947 dev_err(pcie->dev, "failed to enable pex-clk regulator: %d\n",
948 err);
949 return err;
950 }
951
952 if (soc->has_avdd_supply) {
953 err = regulator_enable(pcie->avdd_supply);
954 if (err < 0) {
955 dev_err(pcie->dev,
956 "failed to enable AVDD regulator: %d\n",
957 err);
958 return err;
959 }
960 }
961
962 err = tegra_powergate_sequence_power_up(TEGRA_POWERGATE_PCIE,
963 pcie->pex_clk,
964 pcie->pex_rst);
965 if (err) {
966 dev_err(pcie->dev, "powerup sequence failed: %d\n", err);
967 return err;
968 }
969
970 reset_control_deassert(pcie->afi_rst);
971
972 err = clk_prepare_enable(pcie->afi_clk);
973 if (err < 0) {
974 dev_err(pcie->dev, "failed to enable AFI clock: %d\n", err);
975 return err;
976 }
977
978 if (soc->has_cml_clk) {
979 err = clk_prepare_enable(pcie->cml_clk);
980 if (err < 0) {
981 dev_err(pcie->dev, "failed to enable CML clock: %d\n",
982 err);
983 return err;
984 }
985 }
986
987 err = clk_prepare_enable(pcie->pll_e);
988 if (err < 0) {
989 dev_err(pcie->dev, "failed to enable PLLE clock: %d\n", err);
990 return err;
991 }
992
993 return 0;
994 }
995
996 static int tegra_pcie_clocks_get(struct tegra_pcie *pcie)
997 {
998 const struct tegra_pcie_soc_data *soc = pcie->soc_data;
999
1000 pcie->pex_clk = devm_clk_get(pcie->dev, "pex");
1001 if (IS_ERR(pcie->pex_clk))
1002 return PTR_ERR(pcie->pex_clk);
1003
1004 pcie->afi_clk = devm_clk_get(pcie->dev, "afi");
1005 if (IS_ERR(pcie->afi_clk))
1006 return PTR_ERR(pcie->afi_clk);
1007
1008 pcie->pll_e = devm_clk_get(pcie->dev, "pll_e");
1009 if (IS_ERR(pcie->pll_e))
1010 return PTR_ERR(pcie->pll_e);
1011
1012 if (soc->has_cml_clk) {
1013 pcie->cml_clk = devm_clk_get(pcie->dev, "cml");
1014 if (IS_ERR(pcie->cml_clk))
1015 return PTR_ERR(pcie->cml_clk);
1016 }
1017
1018 return 0;
1019 }
1020
1021 static int tegra_pcie_resets_get(struct tegra_pcie *pcie)
1022 {
1023 pcie->pex_rst = devm_reset_control_get(pcie->dev, "pex");
1024 if (IS_ERR(pcie->pex_rst))
1025 return PTR_ERR(pcie->pex_rst);
1026
1027 pcie->afi_rst = devm_reset_control_get(pcie->dev, "afi");
1028 if (IS_ERR(pcie->afi_rst))
1029 return PTR_ERR(pcie->afi_rst);
1030
1031 pcie->pcie_xrst = devm_reset_control_get(pcie->dev, "pcie_x");
1032 if (IS_ERR(pcie->pcie_xrst))
1033 return PTR_ERR(pcie->pcie_xrst);
1034
1035 return 0;
1036 }
1037
1038 static int tegra_pcie_get_resources(struct tegra_pcie *pcie)
1039 {
1040 struct platform_device *pdev = to_platform_device(pcie->dev);
1041 struct resource *pads, *afi, *res;
1042 int err;
1043
1044 err = tegra_pcie_clocks_get(pcie);
1045 if (err) {
1046 dev_err(&pdev->dev, "failed to get clocks: %d\n", err);
1047 return err;
1048 }
1049
1050 err = tegra_pcie_resets_get(pcie);
1051 if (err) {
1052 dev_err(&pdev->dev, "failed to get resets: %d\n", err);
1053 return err;
1054 }
1055
1056 err = tegra_pcie_power_on(pcie);
1057 if (err) {
1058 dev_err(&pdev->dev, "failed to power up: %d\n", err);
1059 return err;
1060 }
1061
1062 pads = platform_get_resource_byname(pdev, IORESOURCE_MEM, "pads");
1063 pcie->pads = devm_ioremap_resource(&pdev->dev, pads);
1064 if (IS_ERR(pcie->pads)) {
1065 err = PTR_ERR(pcie->pads);
1066 goto poweroff;
1067 }
1068
1069 afi = platform_get_resource_byname(pdev, IORESOURCE_MEM, "afi");
1070 pcie->afi = devm_ioremap_resource(&pdev->dev, afi);
1071 if (IS_ERR(pcie->afi)) {
1072 err = PTR_ERR(pcie->afi);
1073 goto poweroff;
1074 }
1075
1076 /* request configuration space, but remap later, on demand */
1077 res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "cs");
1078 if (!res) {
1079 err = -EADDRNOTAVAIL;
1080 goto poweroff;
1081 }
1082
1083 pcie->cs = devm_request_mem_region(pcie->dev, res->start,
1084 resource_size(res), res->name);
1085 if (!pcie->cs) {
1086 err = -EADDRNOTAVAIL;
1087 goto poweroff;
1088 }
1089
1090 /* request interrupt */
1091 err = platform_get_irq_byname(pdev, "intr");
1092 if (err < 0) {
1093 dev_err(&pdev->dev, "failed to get IRQ: %d\n", err);
1094 goto poweroff;
1095 }
1096
1097 pcie->irq = err;
1098
1099 err = request_irq(pcie->irq, tegra_pcie_isr, IRQF_SHARED, "PCIE", pcie);
1100 if (err) {
1101 dev_err(&pdev->dev, "failed to register IRQ: %d\n", err);
1102 goto poweroff;
1103 }
1104
1105 return 0;
1106
1107 poweroff:
1108 tegra_pcie_power_off(pcie);
1109 return err;
1110 }
1111
1112 static int tegra_pcie_put_resources(struct tegra_pcie *pcie)
1113 {
1114 if (pcie->irq > 0)
1115 free_irq(pcie->irq, pcie);
1116
1117 tegra_pcie_power_off(pcie);
1118 return 0;
1119 }
1120
1121 static int tegra_msi_alloc(struct tegra_msi *chip)
1122 {
1123 int msi;
1124
1125 mutex_lock(&chip->lock);
1126
1127 msi = find_first_zero_bit(chip->used, INT_PCI_MSI_NR);
1128 if (msi < INT_PCI_MSI_NR)
1129 set_bit(msi, chip->used);
1130 else
1131 msi = -ENOSPC;
1132
1133 mutex_unlock(&chip->lock);
1134
1135 return msi;
1136 }
1137
1138 static void tegra_msi_free(struct tegra_msi *chip, unsigned long irq)
1139 {
1140 struct device *dev = chip->chip.dev;
1141
1142 mutex_lock(&chip->lock);
1143
1144 if (!test_bit(irq, chip->used))
1145 dev_err(dev, "trying to free unused MSI#%lu\n", irq);
1146 else
1147 clear_bit(irq, chip->used);
1148
1149 mutex_unlock(&chip->lock);
1150 }
1151
1152 static irqreturn_t tegra_pcie_msi_irq(int irq, void *data)
1153 {
1154 struct tegra_pcie *pcie = data;
1155 struct tegra_msi *msi = &pcie->msi;
1156 unsigned int i, processed = 0;
1157
1158 for (i = 0; i < 8; i++) {
1159 unsigned long reg = afi_readl(pcie, AFI_MSI_VEC0 + i * 4);
1160
1161 while (reg) {
1162 unsigned int offset = find_first_bit(&reg, 32);
1163 unsigned int index = i * 32 + offset;
1164 unsigned int irq;
1165
1166 /* clear the interrupt */
1167 afi_writel(pcie, 1 << offset, AFI_MSI_VEC0 + i * 4);
1168
1169 irq = irq_find_mapping(msi->domain, index);
1170 if (irq) {
1171 if (test_bit(index, msi->used))
1172 generic_handle_irq(irq);
1173 else
1174 dev_info(pcie->dev, "unhandled MSI\n");
1175 } else {
1176 /*
1177 * that's weird who triggered this?
1178 * just clear it
1179 */
1180 dev_info(pcie->dev, "unexpected MSI\n");
1181 }
1182
1183 /* see if there's any more pending in this vector */
1184 reg = afi_readl(pcie, AFI_MSI_VEC0 + i * 4);
1185
1186 processed++;
1187 }
1188 }
1189
1190 return processed > 0 ? IRQ_HANDLED : IRQ_NONE;
1191 }
1192
1193 static int tegra_msi_setup_irq(struct msi_chip *chip, struct pci_dev *pdev,
1194 struct msi_desc *desc)
1195 {
1196 struct tegra_msi *msi = to_tegra_msi(chip);
1197 struct msi_msg msg;
1198 unsigned int irq;
1199 int hwirq;
1200
1201 hwirq = tegra_msi_alloc(msi);
1202 if (hwirq < 0)
1203 return hwirq;
1204
1205 irq = irq_create_mapping(msi->domain, hwirq);
1206 if (!irq)
1207 return -EINVAL;
1208
1209 irq_set_msi_desc(irq, desc);
1210
1211 msg.address_lo = virt_to_phys((void *)msi->pages);
1212 /* 32 bit address only */
1213 msg.address_hi = 0;
1214 msg.data = hwirq;
1215
1216 write_msi_msg(irq, &msg);
1217
1218 return 0;
1219 }
1220
1221 static void tegra_msi_teardown_irq(struct msi_chip *chip, unsigned int irq)
1222 {
1223 struct tegra_msi *msi = to_tegra_msi(chip);
1224 struct irq_data *d = irq_get_irq_data(irq);
1225
1226 tegra_msi_free(msi, d->hwirq);
1227 }
1228
1229 static struct irq_chip tegra_msi_irq_chip = {
1230 .name = "Tegra PCIe MSI",
1231 .irq_enable = unmask_msi_irq,
1232 .irq_disable = mask_msi_irq,
1233 .irq_mask = mask_msi_irq,
1234 .irq_unmask = unmask_msi_irq,
1235 };
1236
1237 static int tegra_msi_map(struct irq_domain *domain, unsigned int irq,
1238 irq_hw_number_t hwirq)
1239 {
1240 irq_set_chip_and_handler(irq, &tegra_msi_irq_chip, handle_simple_irq);
1241 irq_set_chip_data(irq, domain->host_data);
1242 set_irq_flags(irq, IRQF_VALID);
1243
1244 tegra_cpuidle_pcie_irqs_in_use();
1245
1246 return 0;
1247 }
1248
1249 static const struct irq_domain_ops msi_domain_ops = {
1250 .map = tegra_msi_map,
1251 };
1252
1253 static int tegra_pcie_enable_msi(struct tegra_pcie *pcie)
1254 {
1255 struct platform_device *pdev = to_platform_device(pcie->dev);
1256 const struct tegra_pcie_soc_data *soc = pcie->soc_data;
1257 struct tegra_msi *msi = &pcie->msi;
1258 unsigned long base;
1259 int err;
1260 u32 reg;
1261
1262 mutex_init(&msi->lock);
1263
1264 msi->chip.dev = pcie->dev;
1265 msi->chip.setup_irq = tegra_msi_setup_irq;
1266 msi->chip.teardown_irq = tegra_msi_teardown_irq;
1267
1268 msi->domain = irq_domain_add_linear(pcie->dev->of_node, INT_PCI_MSI_NR,
1269 &msi_domain_ops, &msi->chip);
1270 if (!msi->domain) {
1271 dev_err(&pdev->dev, "failed to create IRQ domain\n");
1272 return -ENOMEM;
1273 }
1274
1275 err = platform_get_irq_byname(pdev, "msi");
1276 if (err < 0) {
1277 dev_err(&pdev->dev, "failed to get IRQ: %d\n", err);
1278 goto err;
1279 }
1280
1281 msi->irq = err;
1282
1283 err = request_irq(msi->irq, tegra_pcie_msi_irq, IRQF_NO_THREAD,
1284 tegra_msi_irq_chip.name, pcie);
1285 if (err < 0) {
1286 dev_err(&pdev->dev, "failed to request IRQ: %d\n", err);
1287 goto err;
1288 }
1289
1290 /* setup AFI/FPCI range */
1291 msi->pages = __get_free_pages(GFP_KERNEL, 0);
1292 base = virt_to_phys((void *)msi->pages);
1293
1294 afi_writel(pcie, base >> soc->msi_base_shift, AFI_MSI_FPCI_BAR_ST);
1295 afi_writel(pcie, base, AFI_MSI_AXI_BAR_ST);
1296 /* this register is in 4K increments */
1297 afi_writel(pcie, 1, AFI_MSI_BAR_SZ);
1298
1299 /* enable all MSI vectors */
1300 afi_writel(pcie, 0xffffffff, AFI_MSI_EN_VEC0);
1301 afi_writel(pcie, 0xffffffff, AFI_MSI_EN_VEC1);
1302 afi_writel(pcie, 0xffffffff, AFI_MSI_EN_VEC2);
1303 afi_writel(pcie, 0xffffffff, AFI_MSI_EN_VEC3);
1304 afi_writel(pcie, 0xffffffff, AFI_MSI_EN_VEC4);
1305 afi_writel(pcie, 0xffffffff, AFI_MSI_EN_VEC5);
1306 afi_writel(pcie, 0xffffffff, AFI_MSI_EN_VEC6);
1307 afi_writel(pcie, 0xffffffff, AFI_MSI_EN_VEC7);
1308
1309 /* and unmask the MSI interrupt */
1310 reg = afi_readl(pcie, AFI_INTR_MASK);
1311 reg |= AFI_INTR_MASK_MSI_MASK;
1312 afi_writel(pcie, reg, AFI_INTR_MASK);
1313
1314 return 0;
1315
1316 err:
1317 irq_domain_remove(msi->domain);
1318 return err;
1319 }
1320
1321 static int tegra_pcie_disable_msi(struct tegra_pcie *pcie)
1322 {
1323 struct tegra_msi *msi = &pcie->msi;
1324 unsigned int i, irq;
1325 u32 value;
1326
1327 /* mask the MSI interrupt */
1328 value = afi_readl(pcie, AFI_INTR_MASK);
1329 value &= ~AFI_INTR_MASK_MSI_MASK;
1330 afi_writel(pcie, value, AFI_INTR_MASK);
1331
1332 /* disable all MSI vectors */
1333 afi_writel(pcie, 0, AFI_MSI_EN_VEC0);
1334 afi_writel(pcie, 0, AFI_MSI_EN_VEC1);
1335 afi_writel(pcie, 0, AFI_MSI_EN_VEC2);
1336 afi_writel(pcie, 0, AFI_MSI_EN_VEC3);
1337 afi_writel(pcie, 0, AFI_MSI_EN_VEC4);
1338 afi_writel(pcie, 0, AFI_MSI_EN_VEC5);
1339 afi_writel(pcie, 0, AFI_MSI_EN_VEC6);
1340 afi_writel(pcie, 0, AFI_MSI_EN_VEC7);
1341
1342 free_pages(msi->pages, 0);
1343
1344 if (msi->irq > 0)
1345 free_irq(msi->irq, pcie);
1346
1347 for (i = 0; i < INT_PCI_MSI_NR; i++) {
1348 irq = irq_find_mapping(msi->domain, i);
1349 if (irq > 0)
1350 irq_dispose_mapping(irq);
1351 }
1352
1353 irq_domain_remove(msi->domain);
1354
1355 return 0;
1356 }
1357
1358 static int tegra_pcie_get_xbar_config(struct tegra_pcie *pcie, u32 lanes,
1359 u32 *xbar)
1360 {
1361 struct device_node *np = pcie->dev->of_node;
1362
1363 if (of_device_is_compatible(np, "nvidia,tegra30-pcie")) {
1364 switch (lanes) {
1365 case 0x00000204:
1366 dev_info(pcie->dev, "4x1, 2x1 configuration\n");
1367 *xbar = AFI_PCIE_CONFIG_SM2TMS0_XBAR_CONFIG_420;
1368 return 0;
1369
1370 case 0x00020202:
1371 dev_info(pcie->dev, "2x3 configuration\n");
1372 *xbar = AFI_PCIE_CONFIG_SM2TMS0_XBAR_CONFIG_222;
1373 return 0;
1374
1375 case 0x00010104:
1376 dev_info(pcie->dev, "4x1, 1x2 configuration\n");
1377 *xbar = AFI_PCIE_CONFIG_SM2TMS0_XBAR_CONFIG_411;
1378 return 0;
1379 }
1380 } else if (of_device_is_compatible(np, "nvidia,tegra20-pcie")) {
1381 switch (lanes) {
1382 case 0x00000004:
1383 dev_info(pcie->dev, "single-mode configuration\n");
1384 *xbar = AFI_PCIE_CONFIG_SM2TMS0_XBAR_CONFIG_SINGLE;
1385 return 0;
1386
1387 case 0x00000202:
1388 dev_info(pcie->dev, "dual-mode configuration\n");
1389 *xbar = AFI_PCIE_CONFIG_SM2TMS0_XBAR_CONFIG_DUAL;
1390 return 0;
1391 }
1392 }
1393
1394 return -EINVAL;
1395 }
1396
1397 static int tegra_pcie_parse_dt(struct tegra_pcie *pcie)
1398 {
1399 const struct tegra_pcie_soc_data *soc = pcie->soc_data;
1400 struct device_node *np = pcie->dev->of_node, *port;
1401 struct of_pci_range_parser parser;
1402 struct of_pci_range range;
1403 struct resource res;
1404 u32 lanes = 0;
1405 int err;
1406
1407 if (of_pci_range_parser_init(&parser, np)) {
1408 dev_err(pcie->dev, "missing \"ranges\" property\n");
1409 return -EINVAL;
1410 }
1411
1412 pcie->vdd_supply = devm_regulator_get(pcie->dev, "vdd");
1413 if (IS_ERR(pcie->vdd_supply))
1414 return PTR_ERR(pcie->vdd_supply);
1415
1416 pcie->pex_clk_supply = devm_regulator_get(pcie->dev, "pex-clk");
1417 if (IS_ERR(pcie->pex_clk_supply))
1418 return PTR_ERR(pcie->pex_clk_supply);
1419
1420 if (soc->has_avdd_supply) {
1421 pcie->avdd_supply = devm_regulator_get(pcie->dev, "avdd");
1422 if (IS_ERR(pcie->avdd_supply))
1423 return PTR_ERR(pcie->avdd_supply);
1424 }
1425
1426 for_each_of_pci_range(&parser, &range) {
1427 of_pci_range_to_resource(&range, np, &res);
1428
1429 switch (res.flags & IORESOURCE_TYPE_BITS) {
1430 case IORESOURCE_IO:
1431 memcpy(&pcie->io, &res, sizeof(res));
1432 pcie->io.name = "I/O";
1433 break;
1434
1435 case IORESOURCE_MEM:
1436 if (res.flags & IORESOURCE_PREFETCH) {
1437 memcpy(&pcie->prefetch, &res, sizeof(res));
1438 pcie->prefetch.name = "PREFETCH";
1439 } else {
1440 memcpy(&pcie->mem, &res, sizeof(res));
1441 pcie->mem.name = "MEM";
1442 }
1443 break;
1444 }
1445 }
1446
1447 err = of_pci_parse_bus_range(np, &pcie->busn);
1448 if (err < 0) {
1449 dev_err(pcie->dev, "failed to parse ranges property: %d\n",
1450 err);
1451 pcie->busn.name = np->name;
1452 pcie->busn.start = 0;
1453 pcie->busn.end = 0xff;
1454 pcie->busn.flags = IORESOURCE_BUS;
1455 }
1456
1457 /* parse root ports */
1458 for_each_child_of_node(np, port) {
1459 struct tegra_pcie_port *rp;
1460 unsigned int index;
1461 u32 value;
1462
1463 err = of_pci_get_devfn(port);
1464 if (err < 0) {
1465 dev_err(pcie->dev, "failed to parse address: %d\n",
1466 err);
1467 return err;
1468 }
1469
1470 index = PCI_SLOT(err);
1471
1472 if (index < 1 || index > soc->num_ports) {
1473 dev_err(pcie->dev, "invalid port number: %d\n", index);
1474 return -EINVAL;
1475 }
1476
1477 index--;
1478
1479 err = of_property_read_u32(port, "nvidia,num-lanes", &value);
1480 if (err < 0) {
1481 dev_err(pcie->dev, "failed to parse # of lanes: %d\n",
1482 err);
1483 return err;
1484 }
1485
1486 if (value > 16) {
1487 dev_err(pcie->dev, "invalid # of lanes: %u\n", value);
1488 return -EINVAL;
1489 }
1490
1491 lanes |= value << (index << 3);
1492
1493 if (!of_device_is_available(port))
1494 continue;
1495
1496 rp = devm_kzalloc(pcie->dev, sizeof(*rp), GFP_KERNEL);
1497 if (!rp)
1498 return -ENOMEM;
1499
1500 err = of_address_to_resource(port, 0, &rp->regs);
1501 if (err < 0) {
1502 dev_err(pcie->dev, "failed to parse address: %d\n",
1503 err);
1504 return err;
1505 }
1506
1507 INIT_LIST_HEAD(&rp->list);
1508 rp->index = index;
1509 rp->lanes = value;
1510 rp->pcie = pcie;
1511
1512 rp->base = devm_ioremap_resource(pcie->dev, &rp->regs);
1513 if (IS_ERR(rp->base))
1514 return PTR_ERR(rp->base);
1515
1516 list_add_tail(&rp->list, &pcie->ports);
1517 }
1518
1519 err = tegra_pcie_get_xbar_config(pcie, lanes, &pcie->xbar_config);
1520 if (err < 0) {
1521 dev_err(pcie->dev, "invalid lane configuration\n");
1522 return err;
1523 }
1524
1525 return 0;
1526 }
1527
1528 /*
1529 * FIXME: If there are no PCIe cards attached, then calling this function
1530 * can result in the increase of the bootup time as there are big timeout
1531 * loops.
1532 */
1533 #define TEGRA_PCIE_LINKUP_TIMEOUT 200 /* up to 1.2 seconds */
1534 static bool tegra_pcie_port_check_link(struct tegra_pcie_port *port)
1535 {
1536 unsigned int retries = 3;
1537 unsigned long value;
1538
1539 do {
1540 unsigned int timeout = TEGRA_PCIE_LINKUP_TIMEOUT;
1541
1542 do {
1543 value = readl(port->base + RP_VEND_XP);
1544
1545 if (value & RP_VEND_XP_DL_UP)
1546 break;
1547
1548 usleep_range(1000, 2000);
1549 } while (--timeout);
1550
1551 if (!timeout) {
1552 dev_err(port->pcie->dev, "link %u down, retrying\n",
1553 port->index);
1554 goto retry;
1555 }
1556
1557 timeout = TEGRA_PCIE_LINKUP_TIMEOUT;
1558
1559 do {
1560 value = readl(port->base + RP_LINK_CONTROL_STATUS);
1561
1562 if (value & RP_LINK_CONTROL_STATUS_DL_LINK_ACTIVE)
1563 return true;
1564
1565 usleep_range(1000, 2000);
1566 } while (--timeout);
1567
1568 retry:
1569 tegra_pcie_port_reset(port);
1570 } while (--retries);
1571
1572 return false;
1573 }
1574
1575 static int tegra_pcie_enable(struct tegra_pcie *pcie)
1576 {
1577 struct tegra_pcie_port *port, *tmp;
1578 struct hw_pci hw;
1579
1580 list_for_each_entry_safe(port, tmp, &pcie->ports, list) {
1581 dev_info(pcie->dev, "probing port %u, using %u lanes\n",
1582 port->index, port->lanes);
1583
1584 tegra_pcie_port_enable(port);
1585
1586 if (tegra_pcie_port_check_link(port))
1587 continue;
1588
1589 dev_info(pcie->dev, "link %u down, ignoring\n", port->index);
1590
1591 tegra_pcie_port_disable(port);
1592 tegra_pcie_port_free(port);
1593 }
1594
1595 memset(&hw, 0, sizeof(hw));
1596
1597 hw.nr_controllers = 1;
1598 hw.private_data = (void **)&pcie;
1599 hw.setup = tegra_pcie_setup;
1600 hw.map_irq = tegra_pcie_map_irq;
1601 hw.add_bus = tegra_pcie_add_bus;
1602 hw.scan = tegra_pcie_scan_bus;
1603 hw.ops = &tegra_pcie_ops;
1604
1605 pci_common_init_dev(pcie->dev, &hw);
1606
1607 return 0;
1608 }
1609
1610 static const struct tegra_pcie_soc_data tegra20_pcie_data = {
1611 .num_ports = 2,
1612 .msi_base_shift = 0,
1613 .pads_pll_ctl = PADS_PLL_CTL_TEGRA20,
1614 .tx_ref_sel = PADS_PLL_CTL_TXCLKREF_DIV10,
1615 .has_pex_clkreq_en = false,
1616 .has_pex_bias_ctrl = false,
1617 .has_intr_prsnt_sense = false,
1618 .has_avdd_supply = false,
1619 .has_cml_clk = false,
1620 };
1621
1622 static const struct tegra_pcie_soc_data tegra30_pcie_data = {
1623 .num_ports = 3,
1624 .msi_base_shift = 8,
1625 .pads_pll_ctl = PADS_PLL_CTL_TEGRA30,
1626 .tx_ref_sel = PADS_PLL_CTL_TXCLKREF_BUF_EN,
1627 .has_pex_clkreq_en = true,
1628 .has_pex_bias_ctrl = true,
1629 .has_intr_prsnt_sense = true,
1630 .has_avdd_supply = true,
1631 .has_cml_clk = true,
1632 };
1633
1634 static const struct of_device_id tegra_pcie_of_match[] = {
1635 { .compatible = "nvidia,tegra30-pcie", .data = &tegra30_pcie_data },
1636 { .compatible = "nvidia,tegra20-pcie", .data = &tegra20_pcie_data },
1637 { },
1638 };
1639 MODULE_DEVICE_TABLE(of, tegra_pcie_of_match);
1640
1641 static int tegra_pcie_probe(struct platform_device *pdev)
1642 {
1643 const struct of_device_id *match;
1644 struct tegra_pcie *pcie;
1645 int err;
1646
1647 match = of_match_device(tegra_pcie_of_match, &pdev->dev);
1648 if (!match)
1649 return -ENODEV;
1650
1651 pcie = devm_kzalloc(&pdev->dev, sizeof(*pcie), GFP_KERNEL);
1652 if (!pcie)
1653 return -ENOMEM;
1654
1655 INIT_LIST_HEAD(&pcie->buses);
1656 INIT_LIST_HEAD(&pcie->ports);
1657 pcie->soc_data = match->data;
1658 pcie->dev = &pdev->dev;
1659
1660 err = tegra_pcie_parse_dt(pcie);
1661 if (err < 0)
1662 return err;
1663
1664 pcibios_min_mem = 0;
1665
1666 err = tegra_pcie_get_resources(pcie);
1667 if (err < 0) {
1668 dev_err(&pdev->dev, "failed to request resources: %d\n", err);
1669 return err;
1670 }
1671
1672 err = tegra_pcie_enable_controller(pcie);
1673 if (err)
1674 goto put_resources;
1675
1676 /* setup the AFI address translations */
1677 tegra_pcie_setup_translations(pcie);
1678
1679 if (IS_ENABLED(CONFIG_PCI_MSI)) {
1680 err = tegra_pcie_enable_msi(pcie);
1681 if (err < 0) {
1682 dev_err(&pdev->dev,
1683 "failed to enable MSI support: %d\n",
1684 err);
1685 goto put_resources;
1686 }
1687 }
1688
1689 err = tegra_pcie_enable(pcie);
1690 if (err < 0) {
1691 dev_err(&pdev->dev, "failed to enable PCIe ports: %d\n", err);
1692 goto disable_msi;
1693 }
1694
1695 platform_set_drvdata(pdev, pcie);
1696 return 0;
1697
1698 disable_msi:
1699 if (IS_ENABLED(CONFIG_PCI_MSI))
1700 tegra_pcie_disable_msi(pcie);
1701 put_resources:
1702 tegra_pcie_put_resources(pcie);
1703 return err;
1704 }
1705
1706 static struct platform_driver tegra_pcie_driver = {
1707 .driver = {
1708 .name = "tegra-pcie",
1709 .owner = THIS_MODULE,
1710 .of_match_table = tegra_pcie_of_match,
1711 .suppress_bind_attrs = true,
1712 },
1713 .probe = tegra_pcie_probe,
1714 };
1715 module_platform_driver(tegra_pcie_driver);
1716
1717 MODULE_AUTHOR("Thierry Reding <treding@nvidia.com>");
1718 MODULE_DESCRIPTION("NVIDIA Tegra PCIe driver");
1719 MODULE_LICENSE("GPLv2");
Linux with added FPC-III support