?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
mmc: host: sh_mobile_sdhi: move card_busy from tmio to sdhi
[linux/fpc-iii.git] / drivers / pci / host / pci-tegra.c
blob6de0757b11e4641b2a79b05fd62d19083656419e
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 * Author: Thierry Reding <treding@nvidia.com>
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/clk.h>
30 #include <linux/debugfs.h>
31 #include <linux/delay.h>
32 #include <linux/export.h>
33 #include <linux/interrupt.h>
34 #include <linux/irq.h>
35 #include <linux/irqdomain.h>
36 #include <linux/kernel.h>
37 #include <linux/init.h>
38 #include <linux/msi.h>
39 #include <linux/of_address.h>
40 #include <linux/of_pci.h>
41 #include <linux/of_platform.h>
42 #include <linux/pci.h>
43 #include <linux/phy/phy.h>
44 #include <linux/platform_device.h>
45 #include <linux/reset.h>
46 #include <linux/sizes.h>
47 #include <linux/slab.h>
48 #include <linux/vmalloc.h>
49 #include <linux/regulator/consumer.h>
50
51 #include <soc/tegra/cpuidle.h>
52 #include <soc/tegra/pmc.h>
53
54 #include <asm/mach/irq.h>
55 #include <asm/mach/map.h>
56 #include <asm/mach/pci.h>
57
58 #define INT_PCI_MSI_NR (8 * 32)
59
60 /* register definitions */
61
62 #define AFI_AXI_BAR0_SZ 0x00
63 #define AFI_AXI_BAR1_SZ 0x04
64 #define AFI_AXI_BAR2_SZ 0x08
65 #define AFI_AXI_BAR3_SZ 0x0c
66 #define AFI_AXI_BAR4_SZ 0x10
67 #define AFI_AXI_BAR5_SZ 0x14
68
69 #define AFI_AXI_BAR0_START 0x18
70 #define AFI_AXI_BAR1_START 0x1c
71 #define AFI_AXI_BAR2_START 0x20
72 #define AFI_AXI_BAR3_START 0x24
73 #define AFI_AXI_BAR4_START 0x28
74 #define AFI_AXI_BAR5_START 0x2c
75
76 #define AFI_FPCI_BAR0 0x30
77 #define AFI_FPCI_BAR1 0x34
78 #define AFI_FPCI_BAR2 0x38
79 #define AFI_FPCI_BAR3 0x3c
80 #define AFI_FPCI_BAR4 0x40
81 #define AFI_FPCI_BAR5 0x44
82
83 #define AFI_CACHE_BAR0_SZ 0x48
84 #define AFI_CACHE_BAR0_ST 0x4c
85 #define AFI_CACHE_BAR1_SZ 0x50
86 #define AFI_CACHE_BAR1_ST 0x54
87
88 #define AFI_MSI_BAR_SZ 0x60
89 #define AFI_MSI_FPCI_BAR_ST 0x64
90 #define AFI_MSI_AXI_BAR_ST 0x68
91
92 #define AFI_MSI_VEC0 0x6c
93 #define AFI_MSI_VEC1 0x70
94 #define AFI_MSI_VEC2 0x74
95 #define AFI_MSI_VEC3 0x78
96 #define AFI_MSI_VEC4 0x7c
97 #define AFI_MSI_VEC5 0x80
98 #define AFI_MSI_VEC6 0x84
99 #define AFI_MSI_VEC7 0x88
100
101 #define AFI_MSI_EN_VEC0 0x8c
102 #define AFI_MSI_EN_VEC1 0x90
103 #define AFI_MSI_EN_VEC2 0x94
104 #define AFI_MSI_EN_VEC3 0x98
105 #define AFI_MSI_EN_VEC4 0x9c
106 #define AFI_MSI_EN_VEC5 0xa0
107 #define AFI_MSI_EN_VEC6 0xa4
108 #define AFI_MSI_EN_VEC7 0xa8
109
110 #define AFI_CONFIGURATION 0xac
111 #define AFI_CONFIGURATION_EN_FPCI (1 << 0)
112
113 #define AFI_FPCI_ERROR_MASKS 0xb0
114
115 #define AFI_INTR_MASK 0xb4
116 #define AFI_INTR_MASK_INT_MASK (1 << 0)
117 #define AFI_INTR_MASK_MSI_MASK (1 << 8)
118
119 #define AFI_INTR_CODE 0xb8
120 #define AFI_INTR_CODE_MASK 0xf
121 #define AFI_INTR_INI_SLAVE_ERROR 1
122 #define AFI_INTR_INI_DECODE_ERROR 2
123 #define AFI_INTR_TARGET_ABORT 3
124 #define AFI_INTR_MASTER_ABORT 4
125 #define AFI_INTR_INVALID_WRITE 5
126 #define AFI_INTR_LEGACY 6
127 #define AFI_INTR_FPCI_DECODE_ERROR 7
128 #define AFI_INTR_AXI_DECODE_ERROR 8
129 #define AFI_INTR_FPCI_TIMEOUT 9
130 #define AFI_INTR_PE_PRSNT_SENSE 10
131 #define AFI_INTR_PE_CLKREQ_SENSE 11
132 #define AFI_INTR_CLKCLAMP_SENSE 12
133 #define AFI_INTR_RDY4PD_SENSE 13
134 #define AFI_INTR_P2P_ERROR 14
135
136 #define AFI_INTR_SIGNATURE 0xbc
137 #define AFI_UPPER_FPCI_ADDRESS 0xc0
138 #define AFI_SM_INTR_ENABLE 0xc4
139 #define AFI_SM_INTR_INTA_ASSERT (1 << 0)
140 #define AFI_SM_INTR_INTB_ASSERT (1 << 1)
141 #define AFI_SM_INTR_INTC_ASSERT (1 << 2)
142 #define AFI_SM_INTR_INTD_ASSERT (1 << 3)
143 #define AFI_SM_INTR_INTA_DEASSERT (1 << 4)
144 #define AFI_SM_INTR_INTB_DEASSERT (1 << 5)
145 #define AFI_SM_INTR_INTC_DEASSERT (1 << 6)
146 #define AFI_SM_INTR_INTD_DEASSERT (1 << 7)
147
148 #define AFI_AFI_INTR_ENABLE 0xc8
149 #define AFI_INTR_EN_INI_SLVERR (1 << 0)
150 #define AFI_INTR_EN_INI_DECERR (1 << 1)
151 #define AFI_INTR_EN_TGT_SLVERR (1 << 2)
152 #define AFI_INTR_EN_TGT_DECERR (1 << 3)
153 #define AFI_INTR_EN_TGT_WRERR (1 << 4)
154 #define AFI_INTR_EN_DFPCI_DECERR (1 << 5)
155 #define AFI_INTR_EN_AXI_DECERR (1 << 6)
156 #define AFI_INTR_EN_FPCI_TIMEOUT (1 << 7)
157 #define AFI_INTR_EN_PRSNT_SENSE (1 << 8)
158
159 #define AFI_PCIE_CONFIG 0x0f8
160 #define AFI_PCIE_CONFIG_PCIE_DISABLE(x) (1 << ((x) + 1))
161 #define AFI_PCIE_CONFIG_PCIE_DISABLE_ALL 0xe
162 #define AFI_PCIE_CONFIG_SM2TMS0_XBAR_CONFIG_MASK (0xf << 20)
163 #define AFI_PCIE_CONFIG_SM2TMS0_XBAR_CONFIG_SINGLE (0x0 << 20)
164 #define AFI_PCIE_CONFIG_SM2TMS0_XBAR_CONFIG_420 (0x0 << 20)
165 #define AFI_PCIE_CONFIG_SM2TMS0_XBAR_CONFIG_X2_X1 (0x0 << 20)
166 #define AFI_PCIE_CONFIG_SM2TMS0_XBAR_CONFIG_DUAL (0x1 << 20)
167 #define AFI_PCIE_CONFIG_SM2TMS0_XBAR_CONFIG_222 (0x1 << 20)
168 #define AFI_PCIE_CONFIG_SM2TMS0_XBAR_CONFIG_X4_X1 (0x1 << 20)
169 #define AFI_PCIE_CONFIG_SM2TMS0_XBAR_CONFIG_411 (0x2 << 20)
170
171 #define AFI_FUSE 0x104
172 #define AFI_FUSE_PCIE_T0_GEN2_DIS (1 << 2)
173
174 #define AFI_PEX0_CTRL 0x110
175 #define AFI_PEX1_CTRL 0x118
176 #define AFI_PEX2_CTRL 0x128
177 #define AFI_PEX_CTRL_RST (1 << 0)
178 #define AFI_PEX_CTRL_CLKREQ_EN (1 << 1)
179 #define AFI_PEX_CTRL_REFCLK_EN (1 << 3)
180 #define AFI_PEX_CTRL_OVERRIDE_EN (1 << 4)
181
182 #define AFI_PLLE_CONTROL 0x160
183 #define AFI_PLLE_CONTROL_BYPASS_PADS2PLLE_CONTROL (1 << 9)
184 #define AFI_PLLE_CONTROL_PADS2PLLE_CONTROL_EN (1 << 1)
185
186 #define AFI_PEXBIAS_CTRL_0 0x168
187
188 #define RP_VEND_XP 0x00000f00
189 #define RP_VEND_XP_DL_UP (1 << 30)
190
191 #define RP_PRIV_MISC 0x00000fe0
192 #define RP_PRIV_MISC_PRSNT_MAP_EP_PRSNT (0xe << 0)
193 #define RP_PRIV_MISC_PRSNT_MAP_EP_ABSNT (0xf << 0)
194
195 #define RP_LINK_CONTROL_STATUS 0x00000090
196 #define RP_LINK_CONTROL_STATUS_DL_LINK_ACTIVE 0x20000000
197 #define RP_LINK_CONTROL_STATUS_LINKSTAT_MASK 0x3fff0000
198
199 #define PADS_CTL_SEL 0x0000009c
200
201 #define PADS_CTL 0x000000a0
202 #define PADS_CTL_IDDQ_1L (1 << 0)
203 #define PADS_CTL_TX_DATA_EN_1L (1 << 6)
204 #define PADS_CTL_RX_DATA_EN_1L (1 << 10)
205
206 #define PADS_PLL_CTL_TEGRA20 0x000000b8
207 #define PADS_PLL_CTL_TEGRA30 0x000000b4
208 #define PADS_PLL_CTL_RST_B4SM (1 << 1)
209 #define PADS_PLL_CTL_LOCKDET (1 << 8)
210 #define PADS_PLL_CTL_REFCLK_MASK (0x3 << 16)
211 #define PADS_PLL_CTL_REFCLK_INTERNAL_CML (0 << 16)
212 #define PADS_PLL_CTL_REFCLK_INTERNAL_CMOS (1 << 16)
213 #define PADS_PLL_CTL_REFCLK_EXTERNAL (2 << 16)
214 #define PADS_PLL_CTL_TXCLKREF_MASK (0x1 << 20)
215 #define PADS_PLL_CTL_TXCLKREF_DIV10 (0 << 20)
216 #define PADS_PLL_CTL_TXCLKREF_DIV5 (1 << 20)
217 #define PADS_PLL_CTL_TXCLKREF_BUF_EN (1 << 22)
218
219 #define PADS_REFCLK_CFG0 0x000000c8
220 #define PADS_REFCLK_CFG1 0x000000cc
221 #define PADS_REFCLK_BIAS 0x000000d0
222
223 /*
224 * Fields in PADS_REFCLK_CFG*. Those registers form an array of 16-bit
225 * entries, one entry per PCIe port. These field definitions and desired
226 * values aren't in the TRM, but do come from NVIDIA.
227 */
228 #define PADS_REFCLK_CFG_TERM_SHIFT 2 /* 6:2 */
229 #define PADS_REFCLK_CFG_E_TERM_SHIFT 7
230 #define PADS_REFCLK_CFG_PREDI_SHIFT 8 /* 11:8 */
231 #define PADS_REFCLK_CFG_DRVI_SHIFT 12 /* 15:12 */
232
233 struct tegra_msi {
234 struct msi_controller chip;
235 DECLARE_BITMAP(used, INT_PCI_MSI_NR);
236 struct irq_domain *domain;
237 unsigned long pages;
238 struct mutex lock;
239 int irq;
240 };
241
242 /* used to differentiate between Tegra SoC generations */
243 struct tegra_pcie_soc_data {
244 unsigned int num_ports;
245 unsigned int msi_base_shift;
246 u32 pads_pll_ctl;
247 u32 tx_ref_sel;
248 u32 pads_refclk_cfg0;
249 u32 pads_refclk_cfg1;
250 bool has_pex_clkreq_en;
251 bool has_pex_bias_ctrl;
252 bool has_intr_prsnt_sense;
253 bool has_cml_clk;
254 bool has_gen2;
255 };
256
257 static inline struct tegra_msi *to_tegra_msi(struct msi_controller *chip)
258 {
259 return container_of(chip, struct tegra_msi, chip);
260 }
261
262 struct tegra_pcie {
263 struct device *dev;
264
265 void __iomem *pads;
266 void __iomem *afi;
267 int irq;
268
269 struct list_head buses;
270 struct resource *cs;
271
272 struct resource io;
273 struct resource pio;
274 struct resource mem;
275 struct resource prefetch;
276 struct resource busn;
277
278 struct {
279 resource_size_t mem;
280 resource_size_t io;
281 } offset;
282
283 struct clk *pex_clk;
284 struct clk *afi_clk;
285 struct clk *pll_e;
286 struct clk *cml_clk;
287
288 struct reset_control *pex_rst;
289 struct reset_control *afi_rst;
290 struct reset_control *pcie_xrst;
291
292 bool legacy_phy;
293 struct phy *phy;
294
295 struct tegra_msi msi;
296
297 struct list_head ports;
298 u32 xbar_config;
299
300 struct regulator_bulk_data *supplies;
301 unsigned int num_supplies;
302
303 const struct tegra_pcie_soc_data *soc_data;
304 struct dentry *debugfs;
305 };
306
307 struct tegra_pcie_port {
308 struct tegra_pcie *pcie;
309 struct device_node *np;
310 struct list_head list;
311 struct resource regs;
312 void __iomem *base;
313 unsigned int index;
314 unsigned int lanes;
315
316 struct phy **phys;
317 };
318
319 struct tegra_pcie_bus {
320 struct vm_struct *area;
321 struct list_head list;
322 unsigned int nr;
323 };
324
325 static inline struct tegra_pcie *sys_to_pcie(struct pci_sys_data *sys)
326 {
327 return sys->private_data;
328 }
329
330 static inline void afi_writel(struct tegra_pcie *pcie, u32 value,
331 unsigned long offset)
332 {
333 writel(value, pcie->afi + offset);
334 }
335
336 static inline u32 afi_readl(struct tegra_pcie *pcie, unsigned long offset)
337 {
338 return readl(pcie->afi + offset);
339 }
340
341 static inline void pads_writel(struct tegra_pcie *pcie, u32 value,
342 unsigned long offset)
343 {
344 writel(value, pcie->pads + offset);
345 }
346
347 static inline u32 pads_readl(struct tegra_pcie *pcie, unsigned long offset)
348 {
349 return readl(pcie->pads + offset);
350 }
351
352 /*
353 * The configuration space mapping on Tegra is somewhat similar to the ECAM
354 * defined by PCIe. However it deviates a bit in how the 4 bits for extended
355 * register accesses are mapped:
356 *
357 * [27:24] extended register number
358 * [23:16] bus number
359 * [15:11] device number
360 * [10: 8] function number
361 * [ 7: 0] register number
362 *
363 * Mapping the whole extended configuration space would require 256 MiB of
364 * virtual address space, only a small part of which will actually be used.
365 * To work around this, a 1 MiB of virtual addresses are allocated per bus
366 * when the bus is first accessed. When the physical range is mapped, the
367 * the bus number bits are hidden so that the extended register number bits
368 * appear as bits [19:16]. Therefore the virtual mapping looks like this:
369 *
370 * [19:16] extended register number
371 * [15:11] device number
372 * [10: 8] function number
373 * [ 7: 0] register number
374 *
375 * This is achieved by stitching together 16 chunks of 64 KiB of physical
376 * address space via the MMU.
377 */
378 static unsigned long tegra_pcie_conf_offset(unsigned int devfn, int where)
379 {
380 return ((where & 0xf00) << 8) | (PCI_SLOT(devfn) << 11) |
381 (PCI_FUNC(devfn) << 8) | (where & 0xfc);
382 }
383
384 static struct tegra_pcie_bus *tegra_pcie_bus_alloc(struct tegra_pcie *pcie,
385 unsigned int busnr)
386 {
387 pgprot_t prot = __pgprot(L_PTE_PRESENT | L_PTE_YOUNG | L_PTE_DIRTY |
388 L_PTE_XN | L_PTE_MT_DEV_SHARED | L_PTE_SHARED);
389 phys_addr_t cs = pcie->cs->start;
390 struct tegra_pcie_bus *bus;
391 unsigned int i;
392 int err;
393
394 bus = kzalloc(sizeof(*bus), GFP_KERNEL);
395 if (!bus)
396 return ERR_PTR(-ENOMEM);
397
398 INIT_LIST_HEAD(&bus->list);
399 bus->nr = busnr;
400
401 /* allocate 1 MiB of virtual addresses */
402 bus->area = get_vm_area(SZ_1M, VM_IOREMAP);
403 if (!bus->area) {
404 err = -ENOMEM;
405 goto free;
406 }
407
408 /* map each of the 16 chunks of 64 KiB each */
409 for (i = 0; i < 16; i++) {
410 unsigned long virt = (unsigned long)bus->area->addr +
411 i * SZ_64K;
412 phys_addr_t phys = cs + i * SZ_16M + busnr * SZ_64K;
413
414 err = ioremap_page_range(virt, virt + SZ_64K, phys, prot);
415 if (err < 0) {
416 dev_err(pcie->dev, "ioremap_page_range() failed: %d\n",
417 err);
418 goto unmap;
419 }
420 }
421
422 return bus;
423
424 unmap:
425 vunmap(bus->area->addr);
426 free:
427 kfree(bus);
428 return ERR_PTR(err);
429 }
430
431 static int tegra_pcie_add_bus(struct pci_bus *bus)
432 {
433 struct tegra_pcie *pcie = sys_to_pcie(bus->sysdata);
434 struct tegra_pcie_bus *b;
435
436 b = tegra_pcie_bus_alloc(pcie, bus->number);
437 if (IS_ERR(b))
438 return PTR_ERR(b);
439
440 list_add_tail(&b->list, &pcie->buses);
441
442 return 0;
443 }
444
445 static void tegra_pcie_remove_bus(struct pci_bus *child)
446 {
447 struct tegra_pcie *pcie = sys_to_pcie(child->sysdata);
448 struct tegra_pcie_bus *bus, *tmp;
449
450 list_for_each_entry_safe(bus, tmp, &pcie->buses, list) {
451 if (bus->nr == child->number) {
452 vunmap(bus->area->addr);
453 list_del(&bus->list);
454 kfree(bus);
455 break;
456 }
457 }
458 }
459
460 static void __iomem *tegra_pcie_map_bus(struct pci_bus *bus,
461 unsigned int devfn,
462 int where)
463 {
464 struct tegra_pcie *pcie = sys_to_pcie(bus->sysdata);
465 void __iomem *addr = NULL;
466
467 if (bus->number == 0) {
468 unsigned int slot = PCI_SLOT(devfn);
469 struct tegra_pcie_port *port;
470
471 list_for_each_entry(port, &pcie->ports, list) {
472 if (port->index + 1 == slot) {
473 addr = port->base + (where & ~3);
474 break;
475 }
476 }
477 } else {
478 struct tegra_pcie_bus *b;
479
480 list_for_each_entry(b, &pcie->buses, list)
481 if (b->nr == bus->number)
482 addr = (void __iomem *)b->area->addr;
483
484 if (!addr) {
485 dev_err(pcie->dev,
486 "failed to map cfg. space for bus %u\n",
487 bus->number);
488 return NULL;
489 }
490
491 addr += tegra_pcie_conf_offset(devfn, where);
492 }
493
494 return addr;
495 }
496
497 static struct pci_ops tegra_pcie_ops = {
498 .add_bus = tegra_pcie_add_bus,
499 .remove_bus = tegra_pcie_remove_bus,
500 .map_bus = tegra_pcie_map_bus,
501 .read = pci_generic_config_read32,
502 .write = pci_generic_config_write32,
503 };
504
505 static unsigned long tegra_pcie_port_get_pex_ctrl(struct tegra_pcie_port *port)
506 {
507 unsigned long ret = 0;
508
509 switch (port->index) {
510 case 0:
511 ret = AFI_PEX0_CTRL;
512 break;
513
514 case 1:
515 ret = AFI_PEX1_CTRL;
516 break;
517
518 case 2:
519 ret = AFI_PEX2_CTRL;
520 break;
521 }
522
523 return ret;
524 }
525
526 static void tegra_pcie_port_reset(struct tegra_pcie_port *port)
527 {
528 unsigned long ctrl = tegra_pcie_port_get_pex_ctrl(port);
529 unsigned long value;
530
531 /* pulse reset signal */
532 value = afi_readl(port->pcie, ctrl);
533 value &= ~AFI_PEX_CTRL_RST;
534 afi_writel(port->pcie, value, ctrl);
535
536 usleep_range(1000, 2000);
537
538 value = afi_readl(port->pcie, ctrl);
539 value |= AFI_PEX_CTRL_RST;
540 afi_writel(port->pcie, value, ctrl);
541 }
542
543 static void tegra_pcie_port_enable(struct tegra_pcie_port *port)
544 {
545 const struct tegra_pcie_soc_data *soc = port->pcie->soc_data;
546 unsigned long ctrl = tegra_pcie_port_get_pex_ctrl(port);
547 unsigned long value;
548
549 /* enable reference clock */
550 value = afi_readl(port->pcie, ctrl);
551 value |= AFI_PEX_CTRL_REFCLK_EN;
552
553 if (soc->has_pex_clkreq_en)
554 value |= AFI_PEX_CTRL_CLKREQ_EN;
555
556 value |= AFI_PEX_CTRL_OVERRIDE_EN;
557
558 afi_writel(port->pcie, value, ctrl);
559
560 tegra_pcie_port_reset(port);
561 }
562
563 static void tegra_pcie_port_disable(struct tegra_pcie_port *port)
564 {
565 const struct tegra_pcie_soc_data *soc = port->pcie->soc_data;
566 unsigned long ctrl = tegra_pcie_port_get_pex_ctrl(port);
567 unsigned long value;
568
569 /* assert port reset */
570 value = afi_readl(port->pcie, ctrl);
571 value &= ~AFI_PEX_CTRL_RST;
572 afi_writel(port->pcie, value, ctrl);
573
574 /* disable reference clock */
575 value = afi_readl(port->pcie, ctrl);
576
577 if (soc->has_pex_clkreq_en)
578 value &= ~AFI_PEX_CTRL_CLKREQ_EN;
579
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 /* Tegra PCIE root complex wrongly reports device class */
596 static void tegra_pcie_fixup_class(struct pci_dev *dev)
597 {
598 dev->class = PCI_CLASS_BRIDGE_PCI << 8;
599 }
600 DECLARE_PCI_FIXUP_EARLY(PCI_VENDOR_ID_NVIDIA, 0x0bf0, tegra_pcie_fixup_class);
601 DECLARE_PCI_FIXUP_EARLY(PCI_VENDOR_ID_NVIDIA, 0x0bf1, tegra_pcie_fixup_class);
602 DECLARE_PCI_FIXUP_EARLY(PCI_VENDOR_ID_NVIDIA, 0x0e1c, tegra_pcie_fixup_class);
603 DECLARE_PCI_FIXUP_EARLY(PCI_VENDOR_ID_NVIDIA, 0x0e1d, tegra_pcie_fixup_class);
604
605 /* Tegra PCIE requires relaxed ordering */
606 static void tegra_pcie_relax_enable(struct pci_dev *dev)
607 {
608 pcie_capability_set_word(dev, PCI_EXP_DEVCTL, PCI_EXP_DEVCTL_RELAX_EN);
609 }
610 DECLARE_PCI_FIXUP_FINAL(PCI_ANY_ID, PCI_ANY_ID, tegra_pcie_relax_enable);
611
612 static int tegra_pcie_setup(int nr, struct pci_sys_data *sys)
613 {
614 struct tegra_pcie *pcie = sys_to_pcie(sys);
615 int err;
616
617 sys->mem_offset = pcie->offset.mem;
618 sys->io_offset = pcie->offset.io;
619
620 err = devm_request_resource(pcie->dev, &iomem_resource, &pcie->io);
621 if (err < 0)
622 return err;
623
624 pci_add_resource_offset(&sys->resources, &pcie->pio, sys->io_offset);
625 pci_add_resource_offset(&sys->resources, &pcie->mem, sys->mem_offset);
626 pci_add_resource_offset(&sys->resources, &pcie->prefetch,
627 sys->mem_offset);
628 pci_add_resource(&sys->resources, &pcie->busn);
629
630 err = devm_request_pci_bus_resources(pcie->dev, &sys->resources);
631 if (err < 0)
632 return err;
633
634 pci_remap_iospace(&pcie->pio, pcie->io.start);
635 return 1;
636 }
637
638 static int tegra_pcie_map_irq(const struct pci_dev *pdev, u8 slot, u8 pin)
639 {
640 struct tegra_pcie *pcie = sys_to_pcie(pdev->bus->sysdata);
641 int irq;
642
643 tegra_cpuidle_pcie_irqs_in_use();
644
645 irq = of_irq_parse_and_map_pci(pdev, slot, pin);
646 if (!irq)
647 irq = pcie->irq;
648
649 return irq;
650 }
651
652 static irqreturn_t tegra_pcie_isr(int irq, void *arg)
653 {
654 const char *err_msg[] = {
655 "Unknown",
656 "AXI slave error",
657 "AXI decode error",
658 "Target abort",
659 "Master abort",
660 "Invalid write",
661 "Legacy interrupt",
662 "Response decoding error",
663 "AXI response decoding error",
664 "Transaction timeout",
665 "Slot present pin change",
666 "Slot clock request change",
667 "TMS clock ramp change",
668 "TMS ready for power down",
669 "Peer2Peer error",
670 };
671 struct tegra_pcie *pcie = arg;
672 u32 code, signature;
673
674 code = afi_readl(pcie, AFI_INTR_CODE) & AFI_INTR_CODE_MASK;
675 signature = afi_readl(pcie, AFI_INTR_SIGNATURE);
676 afi_writel(pcie, 0, AFI_INTR_CODE);
677
678 if (code == AFI_INTR_LEGACY)
679 return IRQ_NONE;
680
681 if (code >= ARRAY_SIZE(err_msg))
682 code = 0;
683
684 /*
685 * do not pollute kernel log with master abort reports since they
686 * happen a lot during enumeration
687 */
688 if (code == AFI_INTR_MASTER_ABORT)
689 dev_dbg(pcie->dev, "%s, signature: %08x\n", err_msg[code],
690 signature);
691 else
692 dev_err(pcie->dev, "%s, signature: %08x\n", err_msg[code],
693 signature);
694
695 if (code == AFI_INTR_TARGET_ABORT || code == AFI_INTR_MASTER_ABORT ||
696 code == AFI_INTR_FPCI_DECODE_ERROR) {
697 u32 fpci = afi_readl(pcie, AFI_UPPER_FPCI_ADDRESS) & 0xff;
698 u64 address = (u64)fpci << 32 | (signature & 0xfffffffc);
699
700 if (code == AFI_INTR_MASTER_ABORT)
701 dev_dbg(pcie->dev, " FPCI address: %10llx\n", address);
702 else
703 dev_err(pcie->dev, " FPCI address: %10llx\n", address);
704 }
705
706 return IRQ_HANDLED;
707 }
708
709 /*
710 * FPCI map is as follows:
711 * - 0xfdfc000000: I/O space
712 * - 0xfdfe000000: type 0 configuration space
713 * - 0xfdff000000: type 1 configuration space
714 * - 0xfe00000000: type 0 extended configuration space
715 * - 0xfe10000000: type 1 extended configuration space
716 */
717 static void tegra_pcie_setup_translations(struct tegra_pcie *pcie)
718 {
719 u32 fpci_bar, size, axi_address;
720
721 /* Bar 0: type 1 extended configuration space */
722 fpci_bar = 0xfe100000;
723 size = resource_size(pcie->cs);
724 axi_address = pcie->cs->start;
725 afi_writel(pcie, axi_address, AFI_AXI_BAR0_START);
726 afi_writel(pcie, size >> 12, AFI_AXI_BAR0_SZ);
727 afi_writel(pcie, fpci_bar, AFI_FPCI_BAR0);
728
729 /* Bar 1: downstream IO bar */
730 fpci_bar = 0xfdfc0000;
731 size = resource_size(&pcie->io);
732 axi_address = pcie->io.start;
733 afi_writel(pcie, axi_address, AFI_AXI_BAR1_START);
734 afi_writel(pcie, size >> 12, AFI_AXI_BAR1_SZ);
735 afi_writel(pcie, fpci_bar, AFI_FPCI_BAR1);
736
737 /* Bar 2: prefetchable memory BAR */
738 fpci_bar = (((pcie->prefetch.start >> 12) & 0x0fffffff) << 4) | 0x1;
739 size = resource_size(&pcie->prefetch);
740 axi_address = pcie->prefetch.start;
741 afi_writel(pcie, axi_address, AFI_AXI_BAR2_START);
742 afi_writel(pcie, size >> 12, AFI_AXI_BAR2_SZ);
743 afi_writel(pcie, fpci_bar, AFI_FPCI_BAR2);
744
745 /* Bar 3: non prefetchable memory BAR */
746 fpci_bar = (((pcie->mem.start >> 12) & 0x0fffffff) << 4) | 0x1;
747 size = resource_size(&pcie->mem);
748 axi_address = pcie->mem.start;
749 afi_writel(pcie, axi_address, AFI_AXI_BAR3_START);
750 afi_writel(pcie, size >> 12, AFI_AXI_BAR3_SZ);
751 afi_writel(pcie, fpci_bar, AFI_FPCI_BAR3);
752
753 /* NULL out the remaining BARs as they are not used */
754 afi_writel(pcie, 0, AFI_AXI_BAR4_START);
755 afi_writel(pcie, 0, AFI_AXI_BAR4_SZ);
756 afi_writel(pcie, 0, AFI_FPCI_BAR4);
757
758 afi_writel(pcie, 0, AFI_AXI_BAR5_START);
759 afi_writel(pcie, 0, AFI_AXI_BAR5_SZ);
760 afi_writel(pcie, 0, AFI_FPCI_BAR5);
761
762 /* map all upstream transactions as uncached */
763 afi_writel(pcie, 0, AFI_CACHE_BAR0_ST);
764 afi_writel(pcie, 0, AFI_CACHE_BAR0_SZ);
765 afi_writel(pcie, 0, AFI_CACHE_BAR1_ST);
766 afi_writel(pcie, 0, AFI_CACHE_BAR1_SZ);
767
768 /* MSI translations are setup only when needed */
769 afi_writel(pcie, 0, AFI_MSI_FPCI_BAR_ST);
770 afi_writel(pcie, 0, AFI_MSI_BAR_SZ);
771 afi_writel(pcie, 0, AFI_MSI_AXI_BAR_ST);
772 afi_writel(pcie, 0, AFI_MSI_BAR_SZ);
773 }
774
775 static int tegra_pcie_pll_wait(struct tegra_pcie *pcie, unsigned long timeout)
776 {
777 const struct tegra_pcie_soc_data *soc = pcie->soc_data;
778 u32 value;
779
780 timeout = jiffies + msecs_to_jiffies(timeout);
781
782 while (time_before(jiffies, timeout)) {
783 value = pads_readl(pcie, soc->pads_pll_ctl);
784 if (value & PADS_PLL_CTL_LOCKDET)
785 return 0;
786 }
787
788 return -ETIMEDOUT;
789 }
790
791 static int tegra_pcie_phy_enable(struct tegra_pcie *pcie)
792 {
793 const struct tegra_pcie_soc_data *soc = pcie->soc_data;
794 u32 value;
795 int err;
796
797 /* initialize internal PHY, enable up to 16 PCIE lanes */
798 pads_writel(pcie, 0x0, PADS_CTL_SEL);
799
800 /* override IDDQ to 1 on all 4 lanes */
801 value = pads_readl(pcie, PADS_CTL);
802 value |= PADS_CTL_IDDQ_1L;
803 pads_writel(pcie, value, PADS_CTL);
804
805 /*
806 * Set up PHY PLL inputs select PLLE output as refclock,
807 * set TX ref sel to div10 (not div5).
808 */
809 value = pads_readl(pcie, soc->pads_pll_ctl);
810 value &= ~(PADS_PLL_CTL_REFCLK_MASK | PADS_PLL_CTL_TXCLKREF_MASK);
811 value |= PADS_PLL_CTL_REFCLK_INTERNAL_CML | soc->tx_ref_sel;
812 pads_writel(pcie, value, soc->pads_pll_ctl);
813
814 /* reset PLL */
815 value = pads_readl(pcie, soc->pads_pll_ctl);
816 value &= ~PADS_PLL_CTL_RST_B4SM;
817 pads_writel(pcie, value, soc->pads_pll_ctl);
818
819 usleep_range(20, 100);
820
821 /* take PLL out of reset */
822 value = pads_readl(pcie, soc->pads_pll_ctl);
823 value |= PADS_PLL_CTL_RST_B4SM;
824 pads_writel(pcie, value, soc->pads_pll_ctl);
825
826 /* wait for the PLL to lock */
827 err = tegra_pcie_pll_wait(pcie, 500);
828 if (err < 0) {
829 dev_err(pcie->dev, "PLL failed to lock: %d\n", err);
830 return err;
831 }
832
833 /* turn off IDDQ override */
834 value = pads_readl(pcie, PADS_CTL);
835 value &= ~PADS_CTL_IDDQ_1L;
836 pads_writel(pcie, value, PADS_CTL);
837
838 /* enable TX/RX data */
839 value = pads_readl(pcie, PADS_CTL);
840 value |= PADS_CTL_TX_DATA_EN_1L | PADS_CTL_RX_DATA_EN_1L;
841 pads_writel(pcie, value, PADS_CTL);
842
843 return 0;
844 }
845
846 static int tegra_pcie_phy_disable(struct tegra_pcie *pcie)
847 {
848 const struct tegra_pcie_soc_data *soc = pcie->soc_data;
849 u32 value;
850
851 /* disable TX/RX data */
852 value = pads_readl(pcie, PADS_CTL);
853 value &= ~(PADS_CTL_TX_DATA_EN_1L | PADS_CTL_RX_DATA_EN_1L);
854 pads_writel(pcie, value, PADS_CTL);
855
856 /* override IDDQ */
857 value = pads_readl(pcie, PADS_CTL);
858 value |= PADS_CTL_IDDQ_1L;
859 pads_writel(pcie, PADS_CTL, value);
860
861 /* reset PLL */
862 value = pads_readl(pcie, soc->pads_pll_ctl);
863 value &= ~PADS_PLL_CTL_RST_B4SM;
864 pads_writel(pcie, value, soc->pads_pll_ctl);
865
866 usleep_range(20, 100);
867
868 return 0;
869 }
870
871 static int tegra_pcie_port_phy_power_on(struct tegra_pcie_port *port)
872 {
873 struct device *dev = port->pcie->dev;
874 unsigned int i;
875 int err;
876
877 for (i = 0; i < port->lanes; i++) {
878 err = phy_power_on(port->phys[i]);
879 if (err < 0) {
880 dev_err(dev, "failed to power on PHY#%u: %d\n", i,
881 err);
882 return err;
883 }
884 }
885
886 return 0;
887 }
888
889 static int tegra_pcie_port_phy_power_off(struct tegra_pcie_port *port)
890 {
891 struct device *dev = port->pcie->dev;
892 unsigned int i;
893 int err;
894
895 for (i = 0; i < port->lanes; i++) {
896 err = phy_power_off(port->phys[i]);
897 if (err < 0) {
898 dev_err(dev, "failed to power off PHY#%u: %d\n", i,
899 err);
900 return err;
901 }
902 }
903
904 return 0;
905 }
906
907 static int tegra_pcie_phy_power_on(struct tegra_pcie *pcie)
908 {
909 const struct tegra_pcie_soc_data *soc = pcie->soc_data;
910 struct tegra_pcie_port *port;
911 int err;
912
913 if (pcie->legacy_phy) {
914 if (pcie->phy)
915 err = phy_power_on(pcie->phy);
916 else
917 err = tegra_pcie_phy_enable(pcie);
918
919 if (err < 0)
920 dev_err(pcie->dev, "failed to power on PHY: %d\n", err);
921
922 return err;
923 }
924
925 list_for_each_entry(port, &pcie->ports, list) {
926 err = tegra_pcie_port_phy_power_on(port);
927 if (err < 0) {
928 dev_err(pcie->dev,
929 "failed to power on PCIe port %u PHY: %d\n",
930 port->index, err);
931 return err;
932 }
933 }
934
935 /* Configure the reference clock driver */
936 pads_writel(pcie, soc->pads_refclk_cfg0, PADS_REFCLK_CFG0);
937
938 if (soc->num_ports > 2)
939 pads_writel(pcie, soc->pads_refclk_cfg1, PADS_REFCLK_CFG1);
940
941 return 0;
942 }
943
944 static int tegra_pcie_phy_power_off(struct tegra_pcie *pcie)
945 {
946 struct tegra_pcie_port *port;
947 int err;
948
949 if (pcie->legacy_phy) {
950 if (pcie->phy)
951 err = phy_power_off(pcie->phy);
952 else
953 err = tegra_pcie_phy_disable(pcie);
954
955 if (err < 0)
956 dev_err(pcie->dev, "failed to power off PHY: %d\n",
957 err);
958
959 return err;
960 }
961
962 list_for_each_entry(port, &pcie->ports, list) {
963 err = tegra_pcie_port_phy_power_off(port);
964 if (err < 0) {
965 dev_err(pcie->dev,
966 "failed to power off PCIe port %u PHY: %d\n",
967 port->index, err);
968 return err;
969 }
970 }
971
972 return 0;
973 }
974
975 static int tegra_pcie_enable_controller(struct tegra_pcie *pcie)
976 {
977 const struct tegra_pcie_soc_data *soc = pcie->soc_data;
978 struct tegra_pcie_port *port;
979 unsigned long value;
980 int err;
981
982 /* enable PLL power down */
983 if (pcie->phy) {
984 value = afi_readl(pcie, AFI_PLLE_CONTROL);
985 value &= ~AFI_PLLE_CONTROL_BYPASS_PADS2PLLE_CONTROL;
986 value |= AFI_PLLE_CONTROL_PADS2PLLE_CONTROL_EN;
987 afi_writel(pcie, value, AFI_PLLE_CONTROL);
988 }
989
990 /* power down PCIe slot clock bias pad */
991 if (soc->has_pex_bias_ctrl)
992 afi_writel(pcie, 0, AFI_PEXBIAS_CTRL_0);
993
994 /* configure mode and disable all ports */
995 value = afi_readl(pcie, AFI_PCIE_CONFIG);
996 value &= ~AFI_PCIE_CONFIG_SM2TMS0_XBAR_CONFIG_MASK;
997 value |= AFI_PCIE_CONFIG_PCIE_DISABLE_ALL | pcie->xbar_config;
998
999 list_for_each_entry(port, &pcie->ports, list)
1000 value &= ~AFI_PCIE_CONFIG_PCIE_DISABLE(port->index);
1001
1002 afi_writel(pcie, value, AFI_PCIE_CONFIG);
1003
1004 if (soc->has_gen2) {
1005 value = afi_readl(pcie, AFI_FUSE);
1006 value &= ~AFI_FUSE_PCIE_T0_GEN2_DIS;
1007 afi_writel(pcie, value, AFI_FUSE);
1008 } else {
1009 value = afi_readl(pcie, AFI_FUSE);
1010 value |= AFI_FUSE_PCIE_T0_GEN2_DIS;
1011 afi_writel(pcie, value, AFI_FUSE);
1012 }
1013
1014 err = tegra_pcie_phy_power_on(pcie);
1015 if (err < 0) {
1016 dev_err(pcie->dev, "failed to power on PHY(s): %d\n", err);
1017 return err;
1018 }
1019
1020 /* take the PCIe interface module out of reset */
1021 reset_control_deassert(pcie->pcie_xrst);
1022
1023 /* finally enable PCIe */
1024 value = afi_readl(pcie, AFI_CONFIGURATION);
1025 value |= AFI_CONFIGURATION_EN_FPCI;
1026 afi_writel(pcie, value, AFI_CONFIGURATION);
1027
1028 value = AFI_INTR_EN_INI_SLVERR | AFI_INTR_EN_INI_DECERR |
1029 AFI_INTR_EN_TGT_SLVERR | AFI_INTR_EN_TGT_DECERR |
1030 AFI_INTR_EN_TGT_WRERR | AFI_INTR_EN_DFPCI_DECERR;
1031
1032 if (soc->has_intr_prsnt_sense)
1033 value |= AFI_INTR_EN_PRSNT_SENSE;
1034
1035 afi_writel(pcie, value, AFI_AFI_INTR_ENABLE);
1036 afi_writel(pcie, 0xffffffff, AFI_SM_INTR_ENABLE);
1037
1038 /* don't enable MSI for now, only when needed */
1039 afi_writel(pcie, AFI_INTR_MASK_INT_MASK, AFI_INTR_MASK);
1040
1041 /* disable all exceptions */
1042 afi_writel(pcie, 0, AFI_FPCI_ERROR_MASKS);
1043
1044 return 0;
1045 }
1046
1047 static void tegra_pcie_power_off(struct tegra_pcie *pcie)
1048 {
1049 int err;
1050
1051 /* TODO: disable and unprepare clocks? */
1052
1053 err = tegra_pcie_phy_power_off(pcie);
1054 if (err < 0)
1055 dev_err(pcie->dev, "failed to power off PHY(s): %d\n", err);
1056
1057 reset_control_assert(pcie->pcie_xrst);
1058 reset_control_assert(pcie->afi_rst);
1059 reset_control_assert(pcie->pex_rst);
1060
1061 tegra_powergate_power_off(TEGRA_POWERGATE_PCIE);
1062
1063 err = regulator_bulk_disable(pcie->num_supplies, pcie->supplies);
1064 if (err < 0)
1065 dev_warn(pcie->dev, "failed to disable regulators: %d\n", err);
1066 }
1067
1068 static int tegra_pcie_power_on(struct tegra_pcie *pcie)
1069 {
1070 const struct tegra_pcie_soc_data *soc = pcie->soc_data;
1071 int err;
1072
1073 reset_control_assert(pcie->pcie_xrst);
1074 reset_control_assert(pcie->afi_rst);
1075 reset_control_assert(pcie->pex_rst);
1076
1077 tegra_powergate_power_off(TEGRA_POWERGATE_PCIE);
1078
1079 /* enable regulators */
1080 err = regulator_bulk_enable(pcie->num_supplies, pcie->supplies);
1081 if (err < 0)
1082 dev_err(pcie->dev, "failed to enable regulators: %d\n", err);
1083
1084 err = tegra_powergate_sequence_power_up(TEGRA_POWERGATE_PCIE,
1085 pcie->pex_clk,
1086 pcie->pex_rst);
1087 if (err) {
1088 dev_err(pcie->dev, "powerup sequence failed: %d\n", err);
1089 return err;
1090 }
1091
1092 reset_control_deassert(pcie->afi_rst);
1093
1094 err = clk_prepare_enable(pcie->afi_clk);
1095 if (err < 0) {
1096 dev_err(pcie->dev, "failed to enable AFI clock: %d\n", err);
1097 return err;
1098 }
1099
1100 if (soc->has_cml_clk) {
1101 err = clk_prepare_enable(pcie->cml_clk);
1102 if (err < 0) {
1103 dev_err(pcie->dev, "failed to enable CML clock: %d\n",
1104 err);
1105 return err;
1106 }
1107 }
1108
1109 err = clk_prepare_enable(pcie->pll_e);
1110 if (err < 0) {
1111 dev_err(pcie->dev, "failed to enable PLLE clock: %d\n", err);
1112 return err;
1113 }
1114
1115 return 0;
1116 }
1117
1118 static int tegra_pcie_clocks_get(struct tegra_pcie *pcie)
1119 {
1120 const struct tegra_pcie_soc_data *soc = pcie->soc_data;
1121
1122 pcie->pex_clk = devm_clk_get(pcie->dev, "pex");
1123 if (IS_ERR(pcie->pex_clk))
1124 return PTR_ERR(pcie->pex_clk);
1125
1126 pcie->afi_clk = devm_clk_get(pcie->dev, "afi");
1127 if (IS_ERR(pcie->afi_clk))
1128 return PTR_ERR(pcie->afi_clk);
1129
1130 pcie->pll_e = devm_clk_get(pcie->dev, "pll_e");
1131 if (IS_ERR(pcie->pll_e))
1132 return PTR_ERR(pcie->pll_e);
1133
1134 if (soc->has_cml_clk) {
1135 pcie->cml_clk = devm_clk_get(pcie->dev, "cml");
1136 if (IS_ERR(pcie->cml_clk))
1137 return PTR_ERR(pcie->cml_clk);
1138 }
1139
1140 return 0;
1141 }
1142
1143 static int tegra_pcie_resets_get(struct tegra_pcie *pcie)
1144 {
1145 pcie->pex_rst = devm_reset_control_get(pcie->dev, "pex");
1146 if (IS_ERR(pcie->pex_rst))
1147 return PTR_ERR(pcie->pex_rst);
1148
1149 pcie->afi_rst = devm_reset_control_get(pcie->dev, "afi");
1150 if (IS_ERR(pcie->afi_rst))
1151 return PTR_ERR(pcie->afi_rst);
1152
1153 pcie->pcie_xrst = devm_reset_control_get(pcie->dev, "pcie_x");
1154 if (IS_ERR(pcie->pcie_xrst))
1155 return PTR_ERR(pcie->pcie_xrst);
1156
1157 return 0;
1158 }
1159
1160 static int tegra_pcie_phys_get_legacy(struct tegra_pcie *pcie)
1161 {
1162 int err;
1163
1164 pcie->phy = devm_phy_optional_get(pcie->dev, "pcie");
1165 if (IS_ERR(pcie->phy)) {
1166 err = PTR_ERR(pcie->phy);
1167 dev_err(pcie->dev, "failed to get PHY: %d\n", err);
1168 return err;
1169 }
1170
1171 err = phy_init(pcie->phy);
1172 if (err < 0) {
1173 dev_err(pcie->dev, "failed to initialize PHY: %d\n", err);
1174 return err;
1175 }
1176
1177 pcie->legacy_phy = true;
1178
1179 return 0;
1180 }
1181
1182 static struct phy *devm_of_phy_optional_get_index(struct device *dev,
1183 struct device_node *np,
1184 const char *consumer,
1185 unsigned int index)
1186 {
1187 struct phy *phy;
1188 char *name;
1189
1190 name = kasprintf(GFP_KERNEL, "%s-%u", consumer, index);
1191 if (!name)
1192 return ERR_PTR(-ENOMEM);
1193
1194 phy = devm_of_phy_get(dev, np, name);
1195 kfree(name);
1196
1197 if (IS_ERR(phy) && PTR_ERR(phy) == -ENODEV)
1198 phy = NULL;
1199
1200 return phy;
1201 }
1202
1203 static int tegra_pcie_port_get_phys(struct tegra_pcie_port *port)
1204 {
1205 struct device *dev = port->pcie->dev;
1206 struct phy *phy;
1207 unsigned int i;
1208 int err;
1209
1210 port->phys = devm_kcalloc(dev, sizeof(phy), port->lanes, GFP_KERNEL);
1211 if (!port->phys)
1212 return -ENOMEM;
1213
1214 for (i = 0; i < port->lanes; i++) {
1215 phy = devm_of_phy_optional_get_index(dev, port->np, "pcie", i);
1216 if (IS_ERR(phy)) {
1217 dev_err(dev, "failed to get PHY#%u: %ld\n", i,
1218 PTR_ERR(phy));
1219 return PTR_ERR(phy);
1220 }
1221
1222 err = phy_init(phy);
1223 if (err < 0) {
1224 dev_err(dev, "failed to initialize PHY#%u: %d\n", i,
1225 err);
1226 return err;
1227 }
1228
1229 port->phys[i] = phy;
1230 }
1231
1232 return 0;
1233 }
1234
1235 static int tegra_pcie_phys_get(struct tegra_pcie *pcie)
1236 {
1237 const struct tegra_pcie_soc_data *soc = pcie->soc_data;
1238 struct device_node *np = pcie->dev->of_node;
1239 struct tegra_pcie_port *port;
1240 int err;
1241
1242 if (!soc->has_gen2 || of_find_property(np, "phys", NULL) != NULL)
1243 return tegra_pcie_phys_get_legacy(pcie);
1244
1245 list_for_each_entry(port, &pcie->ports, list) {
1246 err = tegra_pcie_port_get_phys(port);
1247 if (err < 0)
1248 return err;
1249 }
1250
1251 return 0;
1252 }
1253
1254 static int tegra_pcie_get_resources(struct tegra_pcie *pcie)
1255 {
1256 struct platform_device *pdev = to_platform_device(pcie->dev);
1257 struct resource *pads, *afi, *res;
1258 int err;
1259
1260 err = tegra_pcie_clocks_get(pcie);
1261 if (err) {
1262 dev_err(&pdev->dev, "failed to get clocks: %d\n", err);
1263 return err;
1264 }
1265
1266 err = tegra_pcie_resets_get(pcie);
1267 if (err) {
1268 dev_err(&pdev->dev, "failed to get resets: %d\n", err);
1269 return err;
1270 }
1271
1272 err = tegra_pcie_phys_get(pcie);
1273 if (err < 0) {
1274 dev_err(&pdev->dev, "failed to get PHYs: %d\n", err);
1275 return err;
1276 }
1277
1278 err = tegra_pcie_power_on(pcie);
1279 if (err) {
1280 dev_err(&pdev->dev, "failed to power up: %d\n", err);
1281 return err;
1282 }
1283
1284 pads = platform_get_resource_byname(pdev, IORESOURCE_MEM, "pads");
1285 pcie->pads = devm_ioremap_resource(&pdev->dev, pads);
1286 if (IS_ERR(pcie->pads)) {
1287 err = PTR_ERR(pcie->pads);
1288 goto poweroff;
1289 }
1290
1291 afi = platform_get_resource_byname(pdev, IORESOURCE_MEM, "afi");
1292 pcie->afi = devm_ioremap_resource(&pdev->dev, afi);
1293 if (IS_ERR(pcie->afi)) {
1294 err = PTR_ERR(pcie->afi);
1295 goto poweroff;
1296 }
1297
1298 /* request configuration space, but remap later, on demand */
1299 res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "cs");
1300 if (!res) {
1301 err = -EADDRNOTAVAIL;
1302 goto poweroff;
1303 }
1304
1305 pcie->cs = devm_request_mem_region(pcie->dev, res->start,
1306 resource_size(res), res->name);
1307 if (!pcie->cs) {
1308 err = -EADDRNOTAVAIL;
1309 goto poweroff;
1310 }
1311
1312 /* request interrupt */
1313 err = platform_get_irq_byname(pdev, "intr");
1314 if (err < 0) {
1315 dev_err(&pdev->dev, "failed to get IRQ: %d\n", err);
1316 goto poweroff;
1317 }
1318
1319 pcie->irq = err;
1320
1321 err = request_irq(pcie->irq, tegra_pcie_isr, IRQF_SHARED, "PCIE", pcie);
1322 if (err) {
1323 dev_err(&pdev->dev, "failed to register IRQ: %d\n", err);
1324 goto poweroff;
1325 }
1326
1327 return 0;
1328
1329 poweroff:
1330 tegra_pcie_power_off(pcie);
1331 return err;
1332 }
1333
1334 static int tegra_pcie_put_resources(struct tegra_pcie *pcie)
1335 {
1336 int err;
1337
1338 if (pcie->irq > 0)
1339 free_irq(pcie->irq, pcie);
1340
1341 tegra_pcie_power_off(pcie);
1342
1343 err = phy_exit(pcie->phy);
1344 if (err < 0)
1345 dev_err(pcie->dev, "failed to teardown PHY: %d\n", err);
1346
1347 return 0;
1348 }
1349
1350 static int tegra_msi_alloc(struct tegra_msi *chip)
1351 {
1352 int msi;
1353
1354 mutex_lock(&chip->lock);
1355
1356 msi = find_first_zero_bit(chip->used, INT_PCI_MSI_NR);
1357 if (msi < INT_PCI_MSI_NR)
1358 set_bit(msi, chip->used);
1359 else
1360 msi = -ENOSPC;
1361
1362 mutex_unlock(&chip->lock);
1363
1364 return msi;
1365 }
1366
1367 static void tegra_msi_free(struct tegra_msi *chip, unsigned long irq)
1368 {
1369 struct device *dev = chip->chip.dev;
1370
1371 mutex_lock(&chip->lock);
1372
1373 if (!test_bit(irq, chip->used))
1374 dev_err(dev, "trying to free unused MSI#%lu\n", irq);
1375 else
1376 clear_bit(irq, chip->used);
1377
1378 mutex_unlock(&chip->lock);
1379 }
1380
1381 static irqreturn_t tegra_pcie_msi_irq(int irq, void *data)
1382 {
1383 struct tegra_pcie *pcie = data;
1384 struct tegra_msi *msi = &pcie->msi;
1385 unsigned int i, processed = 0;
1386
1387 for (i = 0; i < 8; i++) {
1388 unsigned long reg = afi_readl(pcie, AFI_MSI_VEC0 + i * 4);
1389
1390 while (reg) {
1391 unsigned int offset = find_first_bit(&reg, 32);
1392 unsigned int index = i * 32 + offset;
1393 unsigned int irq;
1394
1395 /* clear the interrupt */
1396 afi_writel(pcie, 1 << offset, AFI_MSI_VEC0 + i * 4);
1397
1398 irq = irq_find_mapping(msi->domain, index);
1399 if (irq) {
1400 if (test_bit(index, msi->used))
1401 generic_handle_irq(irq);
1402 else
1403 dev_info(pcie->dev, "unhandled MSI\n");
1404 } else {
1405 /*
1406 * that's weird who triggered this?
1407 * just clear it
1408 */
1409 dev_info(pcie->dev, "unexpected MSI\n");
1410 }
1411
1412 /* see if there's any more pending in this vector */
1413 reg = afi_readl(pcie, AFI_MSI_VEC0 + i * 4);
1414
1415 processed++;
1416 }
1417 }
1418
1419 return processed > 0 ? IRQ_HANDLED : IRQ_NONE;
1420 }
1421
1422 static int tegra_msi_setup_irq(struct msi_controller *chip,
1423 struct pci_dev *pdev, struct msi_desc *desc)
1424 {
1425 struct tegra_msi *msi = to_tegra_msi(chip);
1426 struct msi_msg msg;
1427 unsigned int irq;
1428 int hwirq;
1429
1430 hwirq = tegra_msi_alloc(msi);
1431 if (hwirq < 0)
1432 return hwirq;
1433
1434 irq = irq_create_mapping(msi->domain, hwirq);
1435 if (!irq) {
1436 tegra_msi_free(msi, hwirq);
1437 return -EINVAL;
1438 }
1439
1440 irq_set_msi_desc(irq, desc);
1441
1442 msg.address_lo = virt_to_phys((void *)msi->pages);
1443 /* 32 bit address only */
1444 msg.address_hi = 0;
1445 msg.data = hwirq;
1446
1447 pci_write_msi_msg(irq, &msg);
1448
1449 return 0;
1450 }
1451
1452 static void tegra_msi_teardown_irq(struct msi_controller *chip,
1453 unsigned int irq)
1454 {
1455 struct tegra_msi *msi = to_tegra_msi(chip);
1456 struct irq_data *d = irq_get_irq_data(irq);
1457 irq_hw_number_t hwirq = irqd_to_hwirq(d);
1458
1459 irq_dispose_mapping(irq);
1460 tegra_msi_free(msi, hwirq);
1461 }
1462
1463 static struct irq_chip tegra_msi_irq_chip = {
1464 .name = "Tegra PCIe MSI",
1465 .irq_enable = pci_msi_unmask_irq,
1466 .irq_disable = pci_msi_mask_irq,
1467 .irq_mask = pci_msi_mask_irq,
1468 .irq_unmask = pci_msi_unmask_irq,
1469 };
1470
1471 static int tegra_msi_map(struct irq_domain *domain, unsigned int irq,
1472 irq_hw_number_t hwirq)
1473 {
1474 irq_set_chip_and_handler(irq, &tegra_msi_irq_chip, handle_simple_irq);
1475 irq_set_chip_data(irq, domain->host_data);
1476
1477 tegra_cpuidle_pcie_irqs_in_use();
1478
1479 return 0;
1480 }
1481
1482 static const struct irq_domain_ops msi_domain_ops = {
1483 .map = tegra_msi_map,
1484 };
1485
1486 static int tegra_pcie_enable_msi(struct tegra_pcie *pcie)
1487 {
1488 struct platform_device *pdev = to_platform_device(pcie->dev);
1489 const struct tegra_pcie_soc_data *soc = pcie->soc_data;
1490 struct tegra_msi *msi = &pcie->msi;
1491 unsigned long base;
1492 int err;
1493 u32 reg;
1494
1495 mutex_init(&msi->lock);
1496
1497 msi->chip.dev = pcie->dev;
1498 msi->chip.setup_irq = tegra_msi_setup_irq;
1499 msi->chip.teardown_irq = tegra_msi_teardown_irq;
1500
1501 msi->domain = irq_domain_add_linear(pcie->dev->of_node, INT_PCI_MSI_NR,
1502 &msi_domain_ops, &msi->chip);
1503 if (!msi->domain) {
1504 dev_err(&pdev->dev, "failed to create IRQ domain\n");
1505 return -ENOMEM;
1506 }
1507
1508 err = platform_get_irq_byname(pdev, "msi");
1509 if (err < 0) {
1510 dev_err(&pdev->dev, "failed to get IRQ: %d\n", err);
1511 goto err;
1512 }
1513
1514 msi->irq = err;
1515
1516 err = request_irq(msi->irq, tegra_pcie_msi_irq, IRQF_NO_THREAD,
1517 tegra_msi_irq_chip.name, pcie);
1518 if (err < 0) {
1519 dev_err(&pdev->dev, "failed to request IRQ: %d\n", err);
1520 goto err;
1521 }
1522
1523 /* setup AFI/FPCI range */
1524 msi->pages = __get_free_pages(GFP_KERNEL, 0);
1525 base = virt_to_phys((void *)msi->pages);
1526
1527 afi_writel(pcie, base >> soc->msi_base_shift, AFI_MSI_FPCI_BAR_ST);
1528 afi_writel(pcie, base, AFI_MSI_AXI_BAR_ST);
1529 /* this register is in 4K increments */
1530 afi_writel(pcie, 1, AFI_MSI_BAR_SZ);
1531
1532 /* enable all MSI vectors */
1533 afi_writel(pcie, 0xffffffff, AFI_MSI_EN_VEC0);
1534 afi_writel(pcie, 0xffffffff, AFI_MSI_EN_VEC1);
1535 afi_writel(pcie, 0xffffffff, AFI_MSI_EN_VEC2);
1536 afi_writel(pcie, 0xffffffff, AFI_MSI_EN_VEC3);
1537 afi_writel(pcie, 0xffffffff, AFI_MSI_EN_VEC4);
1538 afi_writel(pcie, 0xffffffff, AFI_MSI_EN_VEC5);
1539 afi_writel(pcie, 0xffffffff, AFI_MSI_EN_VEC6);
1540 afi_writel(pcie, 0xffffffff, AFI_MSI_EN_VEC7);
1541
1542 /* and unmask the MSI interrupt */
1543 reg = afi_readl(pcie, AFI_INTR_MASK);
1544 reg |= AFI_INTR_MASK_MSI_MASK;
1545 afi_writel(pcie, reg, AFI_INTR_MASK);
1546
1547 return 0;
1548
1549 err:
1550 irq_domain_remove(msi->domain);
1551 return err;
1552 }
1553
1554 static int tegra_pcie_disable_msi(struct tegra_pcie *pcie)
1555 {
1556 struct tegra_msi *msi = &pcie->msi;
1557 unsigned int i, irq;
1558 u32 value;
1559
1560 /* mask the MSI interrupt */
1561 value = afi_readl(pcie, AFI_INTR_MASK);
1562 value &= ~AFI_INTR_MASK_MSI_MASK;
1563 afi_writel(pcie, value, AFI_INTR_MASK);
1564
1565 /* disable all MSI vectors */
1566 afi_writel(pcie, 0, AFI_MSI_EN_VEC0);
1567 afi_writel(pcie, 0, AFI_MSI_EN_VEC1);
1568 afi_writel(pcie, 0, AFI_MSI_EN_VEC2);
1569 afi_writel(pcie, 0, AFI_MSI_EN_VEC3);
1570 afi_writel(pcie, 0, AFI_MSI_EN_VEC4);
1571 afi_writel(pcie, 0, AFI_MSI_EN_VEC5);
1572 afi_writel(pcie, 0, AFI_MSI_EN_VEC6);
1573 afi_writel(pcie, 0, AFI_MSI_EN_VEC7);
1574
1575 free_pages(msi->pages, 0);
1576
1577 if (msi->irq > 0)
1578 free_irq(msi->irq, pcie);
1579
1580 for (i = 0; i < INT_PCI_MSI_NR; i++) {
1581 irq = irq_find_mapping(msi->domain, i);
1582 if (irq > 0)
1583 irq_dispose_mapping(irq);
1584 }
1585
1586 irq_domain_remove(msi->domain);
1587
1588 return 0;
1589 }
1590
1591 static int tegra_pcie_get_xbar_config(struct tegra_pcie *pcie, u32 lanes,
1592 u32 *xbar)
1593 {
1594 struct device_node *np = pcie->dev->of_node;
1595
1596 if (of_device_is_compatible(np, "nvidia,tegra124-pcie")) {
1597 switch (lanes) {
1598 case 0x0000104:
1599 dev_info(pcie->dev, "4x1, 1x1 configuration\n");
1600 *xbar = AFI_PCIE_CONFIG_SM2TMS0_XBAR_CONFIG_X4_X1;
1601 return 0;
1602
1603 case 0x0000102:
1604 dev_info(pcie->dev, "2x1, 1x1 configuration\n");
1605 *xbar = AFI_PCIE_CONFIG_SM2TMS0_XBAR_CONFIG_X2_X1;
1606 return 0;
1607 }
1608 } else if (of_device_is_compatible(np, "nvidia,tegra30-pcie")) {
1609 switch (lanes) {
1610 case 0x00000204:
1611 dev_info(pcie->dev, "4x1, 2x1 configuration\n");
1612 *xbar = AFI_PCIE_CONFIG_SM2TMS0_XBAR_CONFIG_420;
1613 return 0;
1614
1615 case 0x00020202:
1616 dev_info(pcie->dev, "2x3 configuration\n");
1617 *xbar = AFI_PCIE_CONFIG_SM2TMS0_XBAR_CONFIG_222;
1618 return 0;
1619
1620 case 0x00010104:
1621 dev_info(pcie->dev, "4x1, 1x2 configuration\n");
1622 *xbar = AFI_PCIE_CONFIG_SM2TMS0_XBAR_CONFIG_411;
1623 return 0;
1624 }
1625 } else if (of_device_is_compatible(np, "nvidia,tegra20-pcie")) {
1626 switch (lanes) {
1627 case 0x00000004:
1628 dev_info(pcie->dev, "single-mode configuration\n");
1629 *xbar = AFI_PCIE_CONFIG_SM2TMS0_XBAR_CONFIG_SINGLE;
1630 return 0;
1631
1632 case 0x00000202:
1633 dev_info(pcie->dev, "dual-mode configuration\n");
1634 *xbar = AFI_PCIE_CONFIG_SM2TMS0_XBAR_CONFIG_DUAL;
1635 return 0;
1636 }
1637 }
1638
1639 return -EINVAL;
1640 }
1641
1642 /*
1643 * Check whether a given set of supplies is available in a device tree node.
1644 * This is used to check whether the new or the legacy device tree bindings
1645 * should be used.
1646 */
1647 static bool of_regulator_bulk_available(struct device_node *np,
1648 struct regulator_bulk_data *supplies,
1649 unsigned int num_supplies)
1650 {
1651 char property[32];
1652 unsigned int i;
1653
1654 for (i = 0; i < num_supplies; i++) {
1655 snprintf(property, 32, "%s-supply", supplies[i].supply);
1656
1657 if (of_find_property(np, property, NULL) == NULL)
1658 return false;
1659 }
1660
1661 return true;
1662 }
1663
1664 /*
1665 * Old versions of the device tree binding for this device used a set of power
1666 * supplies that didn't match the hardware inputs. This happened to work for a
1667 * number of cases but is not future proof. However to preserve backwards-
1668 * compatibility with old device trees, this function will try to use the old
1669 * set of supplies.
1670 */
1671 static int tegra_pcie_get_legacy_regulators(struct tegra_pcie *pcie)
1672 {
1673 struct device_node *np = pcie->dev->of_node;
1674
1675 if (of_device_is_compatible(np, "nvidia,tegra30-pcie"))
1676 pcie->num_supplies = 3;
1677 else if (of_device_is_compatible(np, "nvidia,tegra20-pcie"))
1678 pcie->num_supplies = 2;
1679
1680 if (pcie->num_supplies == 0) {
1681 dev_err(pcie->dev, "device %s not supported in legacy mode\n",
1682 np->full_name);
1683 return -ENODEV;
1684 }
1685
1686 pcie->supplies = devm_kcalloc(pcie->dev, pcie->num_supplies,
1687 sizeof(*pcie->supplies),
1688 GFP_KERNEL);
1689 if (!pcie->supplies)
1690 return -ENOMEM;
1691
1692 pcie->supplies[0].supply = "pex-clk";
1693 pcie->supplies[1].supply = "vdd";
1694
1695 if (pcie->num_supplies > 2)
1696 pcie->supplies[2].supply = "avdd";
1697
1698 return devm_regulator_bulk_get(pcie->dev, pcie->num_supplies,
1699 pcie->supplies);
1700 }
1701
1702 /*
1703 * Obtains the list of regulators required for a particular generation of the
1704 * IP block.
1705 *
1706 * This would've been nice to do simply by providing static tables for use
1707 * with the regulator_bulk_*() API, but unfortunately Tegra30 is a bit quirky
1708 * in that it has two pairs or AVDD_PEX and VDD_PEX supplies (PEXA and PEXB)
1709 * and either seems to be optional depending on which ports are being used.
1710 */
1711 static int tegra_pcie_get_regulators(struct tegra_pcie *pcie, u32 lane_mask)
1712 {
1713 struct device_node *np = pcie->dev->of_node;
1714 unsigned int i = 0;
1715
1716 if (of_device_is_compatible(np, "nvidia,tegra124-pcie")) {
1717 pcie->num_supplies = 7;
1718
1719 pcie->supplies = devm_kcalloc(pcie->dev, pcie->num_supplies,
1720 sizeof(*pcie->supplies),
1721 GFP_KERNEL);
1722 if (!pcie->supplies)
1723 return -ENOMEM;
1724
1725 pcie->supplies[i++].supply = "avddio-pex";
1726 pcie->supplies[i++].supply = "dvddio-pex";
1727 pcie->supplies[i++].supply = "avdd-pex-pll";
1728 pcie->supplies[i++].supply = "hvdd-pex";
1729 pcie->supplies[i++].supply = "hvdd-pex-pll-e";
1730 pcie->supplies[i++].supply = "vddio-pex-ctl";
1731 pcie->supplies[i++].supply = "avdd-pll-erefe";
1732 } else if (of_device_is_compatible(np, "nvidia,tegra30-pcie")) {
1733 bool need_pexa = false, need_pexb = false;
1734
1735 /* VDD_PEXA and AVDD_PEXA supply lanes 0 to 3 */
1736 if (lane_mask & 0x0f)
1737 need_pexa = true;
1738
1739 /* VDD_PEXB and AVDD_PEXB supply lanes 4 to 5 */
1740 if (lane_mask & 0x30)
1741 need_pexb = true;
1742
1743 pcie->num_supplies = 4 + (need_pexa ? 2 : 0) +
1744 (need_pexb ? 2 : 0);
1745
1746 pcie->supplies = devm_kcalloc(pcie->dev, pcie->num_supplies,
1747 sizeof(*pcie->supplies),
1748 GFP_KERNEL);
1749 if (!pcie->supplies)
1750 return -ENOMEM;
1751
1752 pcie->supplies[i++].supply = "avdd-pex-pll";
1753 pcie->supplies[i++].supply = "hvdd-pex";
1754 pcie->supplies[i++].supply = "vddio-pex-ctl";
1755 pcie->supplies[i++].supply = "avdd-plle";
1756
1757 if (need_pexa) {
1758 pcie->supplies[i++].supply = "avdd-pexa";
1759 pcie->supplies[i++].supply = "vdd-pexa";
1760 }
1761
1762 if (need_pexb) {
1763 pcie->supplies[i++].supply = "avdd-pexb";
1764 pcie->supplies[i++].supply = "vdd-pexb";
1765 }
1766 } else if (of_device_is_compatible(np, "nvidia,tegra20-pcie")) {
1767 pcie->num_supplies = 5;
1768
1769 pcie->supplies = devm_kcalloc(pcie->dev, pcie->num_supplies,
1770 sizeof(*pcie->supplies),
1771 GFP_KERNEL);
1772 if (!pcie->supplies)
1773 return -ENOMEM;
1774
1775 pcie->supplies[0].supply = "avdd-pex";
1776 pcie->supplies[1].supply = "vdd-pex";
1777 pcie->supplies[2].supply = "avdd-pex-pll";
1778 pcie->supplies[3].supply = "avdd-plle";
1779 pcie->supplies[4].supply = "vddio-pex-clk";
1780 }
1781
1782 if (of_regulator_bulk_available(pcie->dev->of_node, pcie->supplies,
1783 pcie->num_supplies))
1784 return devm_regulator_bulk_get(pcie->dev, pcie->num_supplies,
1785 pcie->supplies);
1786
1787 /*
1788 * If not all regulators are available for this new scheme, assume
1789 * that the device tree complies with an older version of the device
1790 * tree binding.
1791 */
1792 dev_info(pcie->dev, "using legacy DT binding for power supplies\n");
1793
1794 devm_kfree(pcie->dev, pcie->supplies);
1795 pcie->num_supplies = 0;
1796
1797 return tegra_pcie_get_legacy_regulators(pcie);
1798 }
1799
1800 static int tegra_pcie_parse_dt(struct tegra_pcie *pcie)
1801 {
1802 const struct tegra_pcie_soc_data *soc = pcie->soc_data;
1803 struct device_node *np = pcie->dev->of_node, *port;
1804 struct of_pci_range_parser parser;
1805 struct of_pci_range range;
1806 u32 lanes = 0, mask = 0;
1807 unsigned int lane = 0;
1808 struct resource res;
1809 int err;
1810
1811 if (of_pci_range_parser_init(&parser, np)) {
1812 dev_err(pcie->dev, "missing \"ranges\" property\n");
1813 return -EINVAL;
1814 }
1815
1816 for_each_of_pci_range(&parser, &range) {
1817 err = of_pci_range_to_resource(&range, np, &res);
1818 if (err < 0)
1819 return err;
1820
1821 switch (res.flags & IORESOURCE_TYPE_BITS) {
1822 case IORESOURCE_IO:
1823 /* Track the bus -> CPU I/O mapping offset. */
1824 pcie->offset.io = res.start - range.pci_addr;
1825
1826 memcpy(&pcie->pio, &res, sizeof(res));
1827 pcie->pio.name = np->full_name;
1828
1829 /*
1830 * The Tegra PCIe host bridge uses this to program the
1831 * mapping of the I/O space to the physical address,
1832 * so we override the .start and .end fields here that
1833 * of_pci_range_to_resource() converted to I/O space.
1834 * We also set the IORESOURCE_MEM type to clarify that
1835 * the resource is in the physical memory space.
1836 */
1837 pcie->io.start = range.cpu_addr;
1838 pcie->io.end = range.cpu_addr + range.size - 1;
1839 pcie->io.flags = IORESOURCE_MEM;
1840 pcie->io.name = "I/O";
1841
1842 memcpy(&res, &pcie->io, sizeof(res));
1843 break;
1844
1845 case IORESOURCE_MEM:
1846 /*
1847 * Track the bus -> CPU memory mapping offset. This
1848 * assumes that the prefetchable and non-prefetchable
1849 * regions will be the last of type IORESOURCE_MEM in
1850 * the ranges property.
1851 * */
1852 pcie->offset.mem = res.start - range.pci_addr;
1853
1854 if (res.flags & IORESOURCE_PREFETCH) {
1855 memcpy(&pcie->prefetch, &res, sizeof(res));
1856 pcie->prefetch.name = "prefetchable";
1857 } else {
1858 memcpy(&pcie->mem, &res, sizeof(res));
1859 pcie->mem.name = "non-prefetchable";
1860 }
1861 break;
1862 }
1863 }
1864
1865 err = of_pci_parse_bus_range(np, &pcie->busn);
1866 if (err < 0) {
1867 dev_err(pcie->dev, "failed to parse ranges property: %d\n",
1868 err);
1869 pcie->busn.name = np->name;
1870 pcie->busn.start = 0;
1871 pcie->busn.end = 0xff;
1872 pcie->busn.flags = IORESOURCE_BUS;
1873 }
1874
1875 /* parse root ports */
1876 for_each_child_of_node(np, port) {
1877 struct tegra_pcie_port *rp;
1878 unsigned int index;
1879 u32 value;
1880
1881 err = of_pci_get_devfn(port);
1882 if (err < 0) {
1883 dev_err(pcie->dev, "failed to parse address: %d\n",
1884 err);
1885 return err;
1886 }
1887
1888 index = PCI_SLOT(err);
1889
1890 if (index < 1 || index > soc->num_ports) {
1891 dev_err(pcie->dev, "invalid port number: %d\n", index);
1892 return -EINVAL;
1893 }
1894
1895 index--;
1896
1897 err = of_property_read_u32(port, "nvidia,num-lanes", &value);
1898 if (err < 0) {
1899 dev_err(pcie->dev, "failed to parse # of lanes: %d\n",
1900 err);
1901 return err;
1902 }
1903
1904 if (value > 16) {
1905 dev_err(pcie->dev, "invalid # of lanes: %u\n", value);
1906 return -EINVAL;
1907 }
1908
1909 lanes |= value << (index << 3);
1910
1911 if (!of_device_is_available(port)) {
1912 lane += value;
1913 continue;
1914 }
1915
1916 mask |= ((1 << value) - 1) << lane;
1917 lane += value;
1918
1919 rp = devm_kzalloc(pcie->dev, sizeof(*rp), GFP_KERNEL);
1920 if (!rp)
1921 return -ENOMEM;
1922
1923 err = of_address_to_resource(port, 0, &rp->regs);
1924 if (err < 0) {
1925 dev_err(pcie->dev, "failed to parse address: %d\n",
1926 err);
1927 return err;
1928 }
1929
1930 INIT_LIST_HEAD(&rp->list);
1931 rp->index = index;
1932 rp->lanes = value;
1933 rp->pcie = pcie;
1934 rp->np = port;
1935
1936 rp->base = devm_ioremap_resource(pcie->dev, &rp->regs);
1937 if (IS_ERR(rp->base))
1938 return PTR_ERR(rp->base);
1939
1940 list_add_tail(&rp->list, &pcie->ports);
1941 }
1942
1943 err = tegra_pcie_get_xbar_config(pcie, lanes, &pcie->xbar_config);
1944 if (err < 0) {
1945 dev_err(pcie->dev, "invalid lane configuration\n");
1946 return err;
1947 }
1948
1949 err = tegra_pcie_get_regulators(pcie, mask);
1950 if (err < 0)
1951 return err;
1952
1953 return 0;
1954 }
1955
1956 /*
1957 * FIXME: If there are no PCIe cards attached, then calling this function
1958 * can result in the increase of the bootup time as there are big timeout
1959 * loops.
1960 */
1961 #define TEGRA_PCIE_LINKUP_TIMEOUT 200 /* up to 1.2 seconds */
1962 static bool tegra_pcie_port_check_link(struct tegra_pcie_port *port)
1963 {
1964 unsigned int retries = 3;
1965 unsigned long value;
1966
1967 /* override presence detection */
1968 value = readl(port->base + RP_PRIV_MISC);
1969 value &= ~RP_PRIV_MISC_PRSNT_MAP_EP_ABSNT;
1970 value |= RP_PRIV_MISC_PRSNT_MAP_EP_PRSNT;
1971 writel(value, port->base + RP_PRIV_MISC);
1972
1973 do {
1974 unsigned int timeout = TEGRA_PCIE_LINKUP_TIMEOUT;
1975
1976 do {
1977 value = readl(port->base + RP_VEND_XP);
1978
1979 if (value & RP_VEND_XP_DL_UP)
1980 break;
1981
1982 usleep_range(1000, 2000);
1983 } while (--timeout);
1984
1985 if (!timeout) {
1986 dev_err(port->pcie->dev, "link %u down, retrying\n",
1987 port->index);
1988 goto retry;
1989 }
1990
1991 timeout = TEGRA_PCIE_LINKUP_TIMEOUT;
1992
1993 do {
1994 value = readl(port->base + RP_LINK_CONTROL_STATUS);
1995
1996 if (value & RP_LINK_CONTROL_STATUS_DL_LINK_ACTIVE)
1997 return true;
1998
1999 usleep_range(1000, 2000);
2000 } while (--timeout);
2001
2002 retry:
2003 tegra_pcie_port_reset(port);
2004 } while (--retries);
2005
2006 return false;
2007 }
2008
2009 static int tegra_pcie_enable(struct tegra_pcie *pcie)
2010 {
2011 struct tegra_pcie_port *port, *tmp;
2012 struct hw_pci hw;
2013
2014 list_for_each_entry_safe(port, tmp, &pcie->ports, list) {
2015 dev_info(pcie->dev, "probing port %u, using %u lanes\n",
2016 port->index, port->lanes);
2017
2018 tegra_pcie_port_enable(port);
2019
2020 if (tegra_pcie_port_check_link(port))
2021 continue;
2022
2023 dev_info(pcie->dev, "link %u down, ignoring\n", port->index);
2024
2025 tegra_pcie_port_disable(port);
2026 tegra_pcie_port_free(port);
2027 }
2028
2029 memset(&hw, 0, sizeof(hw));
2030
2031 #ifdef CONFIG_PCI_MSI
2032 hw.msi_ctrl = &pcie->msi.chip;
2033 #endif
2034
2035 hw.nr_controllers = 1;
2036 hw.private_data = (void **)&pcie;
2037 hw.setup = tegra_pcie_setup;
2038 hw.map_irq = tegra_pcie_map_irq;
2039 hw.ops = &tegra_pcie_ops;
2040
2041 pci_common_init_dev(pcie->dev, &hw);
2042
2043 return 0;
2044 }
2045
2046 static const struct tegra_pcie_soc_data tegra20_pcie_data = {
2047 .num_ports = 2,
2048 .msi_base_shift = 0,
2049 .pads_pll_ctl = PADS_PLL_CTL_TEGRA20,
2050 .tx_ref_sel = PADS_PLL_CTL_TXCLKREF_DIV10,
2051 .pads_refclk_cfg0 = 0xfa5cfa5c,
2052 .has_pex_clkreq_en = false,
2053 .has_pex_bias_ctrl = false,
2054 .has_intr_prsnt_sense = false,
2055 .has_cml_clk = false,
2056 .has_gen2 = false,
2057 };
2058
2059 static const struct tegra_pcie_soc_data tegra30_pcie_data = {
2060 .num_ports = 3,
2061 .msi_base_shift = 8,
2062 .pads_pll_ctl = PADS_PLL_CTL_TEGRA30,
2063 .tx_ref_sel = PADS_PLL_CTL_TXCLKREF_BUF_EN,
2064 .pads_refclk_cfg0 = 0xfa5cfa5c,
2065 .pads_refclk_cfg1 = 0xfa5cfa5c,
2066 .has_pex_clkreq_en = true,
2067 .has_pex_bias_ctrl = true,
2068 .has_intr_prsnt_sense = true,
2069 .has_cml_clk = true,
2070 .has_gen2 = false,
2071 };
2072
2073 static const struct tegra_pcie_soc_data tegra124_pcie_data = {
2074 .num_ports = 2,
2075 .msi_base_shift = 8,
2076 .pads_pll_ctl = PADS_PLL_CTL_TEGRA30,
2077 .tx_ref_sel = PADS_PLL_CTL_TXCLKREF_BUF_EN,
2078 .pads_refclk_cfg0 = 0x44ac44ac,
2079 .has_pex_clkreq_en = true,
2080 .has_pex_bias_ctrl = true,
2081 .has_intr_prsnt_sense = true,
2082 .has_cml_clk = true,
2083 .has_gen2 = true,
2084 };
2085
2086 static const struct of_device_id tegra_pcie_of_match[] = {
2087 { .compatible = "nvidia,tegra124-pcie", .data = &tegra124_pcie_data },
2088 { .compatible = "nvidia,tegra30-pcie", .data = &tegra30_pcie_data },
2089 { .compatible = "nvidia,tegra20-pcie", .data = &tegra20_pcie_data },
2090 { },
2091 };
2092
2093 static void *tegra_pcie_ports_seq_start(struct seq_file *s, loff_t *pos)
2094 {
2095 struct tegra_pcie *pcie = s->private;
2096
2097 if (list_empty(&pcie->ports))
2098 return NULL;
2099
2100 seq_printf(s, "Index Status\n");
2101
2102 return seq_list_start(&pcie->ports, *pos);
2103 }
2104
2105 static void *tegra_pcie_ports_seq_next(struct seq_file *s, void *v, loff_t *pos)
2106 {
2107 struct tegra_pcie *pcie = s->private;
2108
2109 return seq_list_next(v, &pcie->ports, pos);
2110 }
2111
2112 static void tegra_pcie_ports_seq_stop(struct seq_file *s, void *v)
2113 {
2114 }
2115
2116 static int tegra_pcie_ports_seq_show(struct seq_file *s, void *v)
2117 {
2118 bool up = false, active = false;
2119 struct tegra_pcie_port *port;
2120 unsigned int value;
2121
2122 port = list_entry(v, struct tegra_pcie_port, list);
2123
2124 value = readl(port->base + RP_VEND_XP);
2125
2126 if (value & RP_VEND_XP_DL_UP)
2127 up = true;
2128
2129 value = readl(port->base + RP_LINK_CONTROL_STATUS);
2130
2131 if (value & RP_LINK_CONTROL_STATUS_DL_LINK_ACTIVE)
2132 active = true;
2133
2134 seq_printf(s, "%2u ", port->index);
2135
2136 if (up)
2137 seq_printf(s, "up");
2138
2139 if (active) {
2140 if (up)
2141 seq_printf(s, ", ");
2142
2143 seq_printf(s, "active");
2144 }
2145
2146 seq_printf(s, "\n");
2147 return 0;
2148 }
2149
2150 static const struct seq_operations tegra_pcie_ports_seq_ops = {
2151 .start = tegra_pcie_ports_seq_start,
2152 .next = tegra_pcie_ports_seq_next,
2153 .stop = tegra_pcie_ports_seq_stop,
2154 .show = tegra_pcie_ports_seq_show,
2155 };
2156
2157 static int tegra_pcie_ports_open(struct inode *inode, struct file *file)
2158 {
2159 struct tegra_pcie *pcie = inode->i_private;
2160 struct seq_file *s;
2161 int err;
2162
2163 err = seq_open(file, &tegra_pcie_ports_seq_ops);
2164 if (err)
2165 return err;
2166
2167 s = file->private_data;
2168 s->private = pcie;
2169
2170 return 0;
2171 }
2172
2173 static const struct file_operations tegra_pcie_ports_ops = {
2174 .owner = THIS_MODULE,
2175 .open = tegra_pcie_ports_open,
2176 .read = seq_read,
2177 .llseek = seq_lseek,
2178 .release = seq_release,
2179 };
2180
2181 static int tegra_pcie_debugfs_init(struct tegra_pcie *pcie)
2182 {
2183 struct dentry *file;
2184
2185 pcie->debugfs = debugfs_create_dir("pcie", NULL);
2186 if (!pcie->debugfs)
2187 return -ENOMEM;
2188
2189 file = debugfs_create_file("ports", S_IFREG | S_IRUGO, pcie->debugfs,
2190 pcie, &tegra_pcie_ports_ops);
2191 if (!file)
2192 goto remove;
2193
2194 return 0;
2195
2196 remove:
2197 debugfs_remove_recursive(pcie->debugfs);
2198 pcie->debugfs = NULL;
2199 return -ENOMEM;
2200 }
2201
2202 static int tegra_pcie_probe(struct platform_device *pdev)
2203 {
2204 const struct of_device_id *match;
2205 struct tegra_pcie *pcie;
2206 int err;
2207
2208 match = of_match_device(tegra_pcie_of_match, &pdev->dev);
2209 if (!match)
2210 return -ENODEV;
2211
2212 pcie = devm_kzalloc(&pdev->dev, sizeof(*pcie), GFP_KERNEL);
2213 if (!pcie)
2214 return -ENOMEM;
2215
2216 INIT_LIST_HEAD(&pcie->buses);
2217 INIT_LIST_HEAD(&pcie->ports);
2218 pcie->soc_data = match->data;
2219 pcie->dev = &pdev->dev;
2220
2221 err = tegra_pcie_parse_dt(pcie);
2222 if (err < 0)
2223 return err;
2224
2225 err = tegra_pcie_get_resources(pcie);
2226 if (err < 0) {
2227 dev_err(&pdev->dev, "failed to request resources: %d\n", err);
2228 return err;
2229 }
2230
2231 err = tegra_pcie_enable_controller(pcie);
2232 if (err)
2233 goto put_resources;
2234
2235 /* setup the AFI address translations */
2236 tegra_pcie_setup_translations(pcie);
2237
2238 if (IS_ENABLED(CONFIG_PCI_MSI)) {
2239 err = tegra_pcie_enable_msi(pcie);
2240 if (err < 0) {
2241 dev_err(&pdev->dev,
2242 "failed to enable MSI support: %d\n",
2243 err);
2244 goto put_resources;
2245 }
2246 }
2247
2248 err = tegra_pcie_enable(pcie);
2249 if (err < 0) {
2250 dev_err(&pdev->dev, "failed to enable PCIe ports: %d\n", err);
2251 goto disable_msi;
2252 }
2253
2254 if (IS_ENABLED(CONFIG_DEBUG_FS)) {
2255 err = tegra_pcie_debugfs_init(pcie);
2256 if (err < 0)
2257 dev_err(&pdev->dev, "failed to setup debugfs: %d\n",
2258 err);
2259 }
2260
2261 platform_set_drvdata(pdev, pcie);
2262 return 0;
2263
2264 disable_msi:
2265 if (IS_ENABLED(CONFIG_PCI_MSI))
2266 tegra_pcie_disable_msi(pcie);
2267 put_resources:
2268 tegra_pcie_put_resources(pcie);
2269 return err;
2270 }
2271
2272 static struct platform_driver tegra_pcie_driver = {
2273 .driver = {
2274 .name = "tegra-pcie",
2275 .of_match_table = tegra_pcie_of_match,
2276 .suppress_bind_attrs = true,
2277 },
2278 .probe = tegra_pcie_probe,
2279 };
2280 builtin_platform_driver(tegra_pcie_driver);
Linux with added FPC-III support