2 * PCIe driver for Marvell Armada 370 and Armada XP SoCs
4 * This file is licensed under the terms of the GNU General Public
5 * License version 2. This program is licensed "as is" without any
6 * warranty of any kind, whether express or implied.
9 #include <linux/kernel.h>
10 #include <linux/pci.h>
11 #include <linux/clk.h>
12 #include <linux/delay.h>
13 #include <linux/gpio.h>
14 #include <linux/module.h>
15 #include <linux/mbus.h>
16 #include <linux/msi.h>
17 #include <linux/slab.h>
18 #include <linux/platform_device.h>
19 #include <linux/of_address.h>
20 #include <linux/of_irq.h>
21 #include <linux/of_gpio.h>
22 #include <linux/of_pci.h>
23 #include <linux/of_platform.h>
26 * PCIe unit register offsets.
28 #define PCIE_DEV_ID_OFF 0x0000
29 #define PCIE_CMD_OFF 0x0004
30 #define PCIE_DEV_REV_OFF 0x0008
31 #define PCIE_BAR_LO_OFF(n) (0x0010 + ((n) << 3))
32 #define PCIE_BAR_HI_OFF(n) (0x0014 + ((n) << 3))
33 #define PCIE_HEADER_LOG_4_OFF 0x0128
34 #define PCIE_BAR_CTRL_OFF(n) (0x1804 + (((n) - 1) * 4))
35 #define PCIE_WIN04_CTRL_OFF(n) (0x1820 + ((n) << 4))
36 #define PCIE_WIN04_BASE_OFF(n) (0x1824 + ((n) << 4))
37 #define PCIE_WIN04_REMAP_OFF(n) (0x182c + ((n) << 4))
38 #define PCIE_WIN5_CTRL_OFF 0x1880
39 #define PCIE_WIN5_BASE_OFF 0x1884
40 #define PCIE_WIN5_REMAP_OFF 0x188c
41 #define PCIE_CONF_ADDR_OFF 0x18f8
42 #define PCIE_CONF_ADDR_EN 0x80000000
43 #define PCIE_CONF_REG(r) ((((r) & 0xf00) << 16) | ((r) & 0xfc))
44 #define PCIE_CONF_BUS(b) (((b) & 0xff) << 16)
45 #define PCIE_CONF_DEV(d) (((d) & 0x1f) << 11)
46 #define PCIE_CONF_FUNC(f) (((f) & 0x7) << 8)
47 #define PCIE_CONF_ADDR(bus, devfn, where) \
48 (PCIE_CONF_BUS(bus) | PCIE_CONF_DEV(PCI_SLOT(devfn)) | \
49 PCIE_CONF_FUNC(PCI_FUNC(devfn)) | PCIE_CONF_REG(where) | \
51 #define PCIE_CONF_DATA_OFF 0x18fc
52 #define PCIE_MASK_OFF 0x1910
53 #define PCIE_MASK_ENABLE_INTS 0x0f000000
54 #define PCIE_CTRL_OFF 0x1a00
55 #define PCIE_CTRL_X1_MODE 0x0001
56 #define PCIE_STAT_OFF 0x1a04
57 #define PCIE_STAT_BUS 0xff00
58 #define PCIE_STAT_DEV 0x1f0000
59 #define PCIE_STAT_LINK_DOWN BIT(0)
60 #define PCIE_DEBUG_CTRL 0x1a60
61 #define PCIE_DEBUG_SOFT_RESET BIT(20)
63 /* PCI configuration space of a PCI-to-PCI bridge */
64 struct mvebu_sw_pci_bridge
{
79 u8 secondary_latency_timer
;
96 struct mvebu_pcie_port
;
98 /* Structure representing all PCIe interfaces */
100 struct platform_device
*pdev
;
101 struct mvebu_pcie_port
*ports
;
102 struct msi_controller
*msi
;
104 struct resource realio
;
106 struct resource busn
;
110 /* Structure representing one PCIe interface */
111 struct mvebu_pcie_port
{
117 unsigned int mem_target
;
118 unsigned int mem_attr
;
119 unsigned int io_target
;
120 unsigned int io_attr
;
123 int reset_active_low
;
125 struct mvebu_sw_pci_bridge bridge
;
126 struct device_node
*dn
;
127 struct mvebu_pcie
*pcie
;
128 phys_addr_t memwin_base
;
130 phys_addr_t iowin_base
;
135 static inline void mvebu_writel(struct mvebu_pcie_port
*port
, u32 val
, u32 reg
)
137 writel(val
, port
->base
+ reg
);
140 static inline u32
mvebu_readl(struct mvebu_pcie_port
*port
, u32 reg
)
142 return readl(port
->base
+ reg
);
145 static inline bool mvebu_has_ioport(struct mvebu_pcie_port
*port
)
147 return port
->io_target
!= -1 && port
->io_attr
!= -1;
150 static bool mvebu_pcie_link_up(struct mvebu_pcie_port
*port
)
152 return !(mvebu_readl(port
, PCIE_STAT_OFF
) & PCIE_STAT_LINK_DOWN
);
155 static void mvebu_pcie_set_local_bus_nr(struct mvebu_pcie_port
*port
, int nr
)
159 stat
= mvebu_readl(port
, PCIE_STAT_OFF
);
160 stat
&= ~PCIE_STAT_BUS
;
162 mvebu_writel(port
, stat
, PCIE_STAT_OFF
);
165 static void mvebu_pcie_set_local_dev_nr(struct mvebu_pcie_port
*port
, int nr
)
169 stat
= mvebu_readl(port
, PCIE_STAT_OFF
);
170 stat
&= ~PCIE_STAT_DEV
;
172 mvebu_writel(port
, stat
, PCIE_STAT_OFF
);
176 * Setup PCIE BARs and Address Decode Wins:
177 * BAR[0,2] -> disabled, BAR[1] -> covers all DRAM banks
178 * WIN[0-3] -> DRAM bank[0-3]
180 static void mvebu_pcie_setup_wins(struct mvebu_pcie_port
*port
)
182 const struct mbus_dram_target_info
*dram
;
186 dram
= mv_mbus_dram_info();
188 /* First, disable and clear BARs and windows. */
189 for (i
= 1; i
< 3; i
++) {
190 mvebu_writel(port
, 0, PCIE_BAR_CTRL_OFF(i
));
191 mvebu_writel(port
, 0, PCIE_BAR_LO_OFF(i
));
192 mvebu_writel(port
, 0, PCIE_BAR_HI_OFF(i
));
195 for (i
= 0; i
< 5; i
++) {
196 mvebu_writel(port
, 0, PCIE_WIN04_CTRL_OFF(i
));
197 mvebu_writel(port
, 0, PCIE_WIN04_BASE_OFF(i
));
198 mvebu_writel(port
, 0, PCIE_WIN04_REMAP_OFF(i
));
201 mvebu_writel(port
, 0, PCIE_WIN5_CTRL_OFF
);
202 mvebu_writel(port
, 0, PCIE_WIN5_BASE_OFF
);
203 mvebu_writel(port
, 0, PCIE_WIN5_REMAP_OFF
);
205 /* Setup windows for DDR banks. Count total DDR size on the fly. */
207 for (i
= 0; i
< dram
->num_cs
; i
++) {
208 const struct mbus_dram_window
*cs
= dram
->cs
+ i
;
210 mvebu_writel(port
, cs
->base
& 0xffff0000,
211 PCIE_WIN04_BASE_OFF(i
));
212 mvebu_writel(port
, 0, PCIE_WIN04_REMAP_OFF(i
));
214 ((cs
->size
- 1) & 0xffff0000) |
215 (cs
->mbus_attr
<< 8) |
216 (dram
->mbus_dram_target_id
<< 4) | 1,
217 PCIE_WIN04_CTRL_OFF(i
));
222 /* Round up 'size' to the nearest power of two. */
223 if ((size
& (size
- 1)) != 0)
224 size
= 1 << fls(size
);
226 /* Setup BAR[1] to all DRAM banks. */
227 mvebu_writel(port
, dram
->cs
[0].base
, PCIE_BAR_LO_OFF(1));
228 mvebu_writel(port
, 0, PCIE_BAR_HI_OFF(1));
229 mvebu_writel(port
, ((size
- 1) & 0xffff0000) | 1,
230 PCIE_BAR_CTRL_OFF(1));
233 static void mvebu_pcie_setup_hw(struct mvebu_pcie_port
*port
)
237 /* Point PCIe unit MBUS decode windows to DRAM space. */
238 mvebu_pcie_setup_wins(port
);
240 /* Master + slave enable. */
241 cmd
= mvebu_readl(port
, PCIE_CMD_OFF
);
242 cmd
|= PCI_COMMAND_IO
;
243 cmd
|= PCI_COMMAND_MEMORY
;
244 cmd
|= PCI_COMMAND_MASTER
;
245 mvebu_writel(port
, cmd
, PCIE_CMD_OFF
);
247 /* Enable interrupt lines A-D. */
248 mask
= mvebu_readl(port
, PCIE_MASK_OFF
);
249 mask
|= PCIE_MASK_ENABLE_INTS
;
250 mvebu_writel(port
, mask
, PCIE_MASK_OFF
);
253 static int mvebu_pcie_hw_rd_conf(struct mvebu_pcie_port
*port
,
255 u32 devfn
, int where
, int size
, u32
*val
)
257 void __iomem
*conf_data
= port
->base
+ PCIE_CONF_DATA_OFF
;
259 mvebu_writel(port
, PCIE_CONF_ADDR(bus
->number
, devfn
, where
),
264 *val
= readb_relaxed(conf_data
+ (where
& 3));
267 *val
= readw_relaxed(conf_data
+ (where
& 2));
270 *val
= readl_relaxed(conf_data
);
274 return PCIBIOS_SUCCESSFUL
;
277 static int mvebu_pcie_hw_wr_conf(struct mvebu_pcie_port
*port
,
279 u32 devfn
, int where
, int size
, u32 val
)
281 void __iomem
*conf_data
= port
->base
+ PCIE_CONF_DATA_OFF
;
283 mvebu_writel(port
, PCIE_CONF_ADDR(bus
->number
, devfn
, where
),
288 writeb(val
, conf_data
+ (where
& 3));
291 writew(val
, conf_data
+ (where
& 2));
294 writel(val
, conf_data
);
297 return PCIBIOS_BAD_REGISTER_NUMBER
;
300 return PCIBIOS_SUCCESSFUL
;
304 * Remove windows, starting from the largest ones to the smallest
307 static void mvebu_pcie_del_windows(struct mvebu_pcie_port
*port
,
308 phys_addr_t base
, size_t size
)
311 size_t sz
= 1 << (fls(size
) - 1);
313 mvebu_mbus_del_window(base
, sz
);
320 * MBus windows can only have a power of two size, but PCI BARs do not
321 * have this constraint. Therefore, we have to split the PCI BAR into
322 * areas each having a power of two size. We start from the largest
323 * one (i.e highest order bit set in the size).
325 static void mvebu_pcie_add_windows(struct mvebu_pcie_port
*port
,
326 unsigned int target
, unsigned int attribute
,
327 phys_addr_t base
, size_t size
,
330 size_t size_mapped
= 0;
333 size_t sz
= 1 << (fls(size
) - 1);
336 ret
= mvebu_mbus_add_window_remap_by_id(target
, attribute
, base
,
339 phys_addr_t end
= base
+ sz
- 1;
341 dev_err(&port
->pcie
->pdev
->dev
,
342 "Could not create MBus window at [mem %pa-%pa]: %d\n",
344 mvebu_pcie_del_windows(port
, base
- size_mapped
,
352 if (remap
!= MVEBU_MBUS_NO_REMAP
)
357 static void mvebu_pcie_handle_iobase_change(struct mvebu_pcie_port
*port
)
361 /* Are the new iobase/iolimit values invalid? */
362 if (port
->bridge
.iolimit
< port
->bridge
.iobase
||
363 port
->bridge
.iolimitupper
< port
->bridge
.iobaseupper
||
364 !(port
->bridge
.command
& PCI_COMMAND_IO
)) {
366 /* If a window was configured, remove it */
367 if (port
->iowin_base
) {
368 mvebu_pcie_del_windows(port
, port
->iowin_base
,
370 port
->iowin_base
= 0;
371 port
->iowin_size
= 0;
377 if (!mvebu_has_ioport(port
)) {
378 dev_WARN(&port
->pcie
->pdev
->dev
,
379 "Attempt to set IO when IO is disabled\n");
384 * We read the PCI-to-PCI bridge emulated registers, and
385 * calculate the base address and size of the address decoding
386 * window to setup, according to the PCI-to-PCI bridge
387 * specifications. iobase is the bus address, port->iowin_base
388 * is the CPU address.
390 iobase
= ((port
->bridge
.iobase
& 0xF0) << 8) |
391 (port
->bridge
.iobaseupper
<< 16);
392 port
->iowin_base
= port
->pcie
->io
.start
+ iobase
;
393 port
->iowin_size
= ((0xFFF | ((port
->bridge
.iolimit
& 0xF0) << 8) |
394 (port
->bridge
.iolimitupper
<< 16)) -
397 mvebu_pcie_add_windows(port
, port
->io_target
, port
->io_attr
,
398 port
->iowin_base
, port
->iowin_size
,
402 static void mvebu_pcie_handle_membase_change(struct mvebu_pcie_port
*port
)
404 /* Are the new membase/memlimit values invalid? */
405 if (port
->bridge
.memlimit
< port
->bridge
.membase
||
406 !(port
->bridge
.command
& PCI_COMMAND_MEMORY
)) {
408 /* If a window was configured, remove it */
409 if (port
->memwin_base
) {
410 mvebu_pcie_del_windows(port
, port
->memwin_base
,
412 port
->memwin_base
= 0;
413 port
->memwin_size
= 0;
420 * We read the PCI-to-PCI bridge emulated registers, and
421 * calculate the base address and size of the address decoding
422 * window to setup, according to the PCI-to-PCI bridge
425 port
->memwin_base
= ((port
->bridge
.membase
& 0xFFF0) << 16);
427 (((port
->bridge
.memlimit
& 0xFFF0) << 16) | 0xFFFFF) -
428 port
->memwin_base
+ 1;
430 mvebu_pcie_add_windows(port
, port
->mem_target
, port
->mem_attr
,
431 port
->memwin_base
, port
->memwin_size
,
432 MVEBU_MBUS_NO_REMAP
);
436 * Initialize the configuration space of the PCI-to-PCI bridge
437 * associated with the given PCIe interface.
439 static void mvebu_sw_pci_bridge_init(struct mvebu_pcie_port
*port
)
441 struct mvebu_sw_pci_bridge
*bridge
= &port
->bridge
;
443 memset(bridge
, 0, sizeof(struct mvebu_sw_pci_bridge
));
445 bridge
->class = PCI_CLASS_BRIDGE_PCI
;
446 bridge
->vendor
= PCI_VENDOR_ID_MARVELL
;
447 bridge
->device
= mvebu_readl(port
, PCIE_DEV_ID_OFF
) >> 16;
448 bridge
->revision
= mvebu_readl(port
, PCIE_DEV_REV_OFF
) & 0xff;
449 bridge
->header_type
= PCI_HEADER_TYPE_BRIDGE
;
450 bridge
->cache_line_size
= 0x10;
452 /* We support 32 bits I/O addressing */
453 bridge
->iobase
= PCI_IO_RANGE_TYPE_32
;
454 bridge
->iolimit
= PCI_IO_RANGE_TYPE_32
;
458 * Read the configuration space of the PCI-to-PCI bridge associated to
459 * the given PCIe interface.
461 static int mvebu_sw_pci_bridge_read(struct mvebu_pcie_port
*port
,
462 unsigned int where
, int size
, u32
*value
)
464 struct mvebu_sw_pci_bridge
*bridge
= &port
->bridge
;
466 switch (where
& ~3) {
468 *value
= bridge
->device
<< 16 | bridge
->vendor
;
472 *value
= bridge
->command
;
475 case PCI_CLASS_REVISION
:
476 *value
= bridge
->class << 16 | bridge
->interface
<< 8 |
480 case PCI_CACHE_LINE_SIZE
:
481 *value
= bridge
->bist
<< 24 | bridge
->header_type
<< 16 |
482 bridge
->latency_timer
<< 8 | bridge
->cache_line_size
;
485 case PCI_BASE_ADDRESS_0
... PCI_BASE_ADDRESS_1
:
486 *value
= bridge
->bar
[((where
& ~3) - PCI_BASE_ADDRESS_0
) / 4];
489 case PCI_PRIMARY_BUS
:
490 *value
= (bridge
->secondary_latency_timer
<< 24 |
491 bridge
->subordinate_bus
<< 16 |
492 bridge
->secondary_bus
<< 8 |
493 bridge
->primary_bus
);
497 if (!mvebu_has_ioport(port
))
498 *value
= bridge
->secondary_status
<< 16;
500 *value
= (bridge
->secondary_status
<< 16 |
501 bridge
->iolimit
<< 8 |
505 case PCI_MEMORY_BASE
:
506 *value
= (bridge
->memlimit
<< 16 | bridge
->membase
);
509 case PCI_PREF_MEMORY_BASE
:
513 case PCI_IO_BASE_UPPER16
:
514 *value
= (bridge
->iolimitupper
<< 16 | bridge
->iobaseupper
);
517 case PCI_ROM_ADDRESS1
:
521 case PCI_INTERRUPT_LINE
:
522 /* LINE PIN MIN_GNT MAX_LAT */
528 * PCI defines configuration read accesses to reserved or
529 * unimplemented registers to read as zero and complete
533 return PCIBIOS_SUCCESSFUL
;
537 *value
= (*value
>> (8 * (where
& 3))) & 0xffff;
539 *value
= (*value
>> (8 * (where
& 3))) & 0xff;
541 return PCIBIOS_SUCCESSFUL
;
544 /* Write to the PCI-to-PCI bridge configuration space */
545 static int mvebu_sw_pci_bridge_write(struct mvebu_pcie_port
*port
,
546 unsigned int where
, int size
, u32 value
)
548 struct mvebu_sw_pci_bridge
*bridge
= &port
->bridge
;
555 mask
= ~(0xffff << ((where
& 3) * 8));
557 mask
= ~(0xff << ((where
& 3) * 8));
559 return PCIBIOS_BAD_REGISTER_NUMBER
;
561 err
= mvebu_sw_pci_bridge_read(port
, where
& ~3, 4, ®
);
565 value
= (reg
& mask
) | value
<< ((where
& 3) * 8);
567 switch (where
& ~3) {
570 u32 old
= bridge
->command
;
572 if (!mvebu_has_ioport(port
))
573 value
&= ~PCI_COMMAND_IO
;
575 bridge
->command
= value
& 0xffff;
576 if ((old
^ bridge
->command
) & PCI_COMMAND_IO
)
577 mvebu_pcie_handle_iobase_change(port
);
578 if ((old
^ bridge
->command
) & PCI_COMMAND_MEMORY
)
579 mvebu_pcie_handle_membase_change(port
);
583 case PCI_BASE_ADDRESS_0
... PCI_BASE_ADDRESS_1
:
584 bridge
->bar
[((where
& ~3) - PCI_BASE_ADDRESS_0
) / 4] = value
;
589 * We also keep bit 1 set, it is a read-only bit that
590 * indicates we support 32 bits addressing for the
593 bridge
->iobase
= (value
& 0xff) | PCI_IO_RANGE_TYPE_32
;
594 bridge
->iolimit
= ((value
>> 8) & 0xff) | PCI_IO_RANGE_TYPE_32
;
595 mvebu_pcie_handle_iobase_change(port
);
598 case PCI_MEMORY_BASE
:
599 bridge
->membase
= value
& 0xffff;
600 bridge
->memlimit
= value
>> 16;
601 mvebu_pcie_handle_membase_change(port
);
604 case PCI_IO_BASE_UPPER16
:
605 bridge
->iobaseupper
= value
& 0xffff;
606 bridge
->iolimitupper
= value
>> 16;
607 mvebu_pcie_handle_iobase_change(port
);
610 case PCI_PRIMARY_BUS
:
611 bridge
->primary_bus
= value
& 0xff;
612 bridge
->secondary_bus
= (value
>> 8) & 0xff;
613 bridge
->subordinate_bus
= (value
>> 16) & 0xff;
614 bridge
->secondary_latency_timer
= (value
>> 24) & 0xff;
615 mvebu_pcie_set_local_bus_nr(port
, bridge
->secondary_bus
);
622 return PCIBIOS_SUCCESSFUL
;
625 static inline struct mvebu_pcie
*sys_to_pcie(struct pci_sys_data
*sys
)
627 return sys
->private_data
;
630 static struct mvebu_pcie_port
*mvebu_pcie_find_port(struct mvebu_pcie
*pcie
,
636 for (i
= 0; i
< pcie
->nports
; i
++) {
637 struct mvebu_pcie_port
*port
= &pcie
->ports
[i
];
639 if (bus
->number
== 0 && port
->devfn
== devfn
)
641 if (bus
->number
!= 0 &&
642 bus
->number
>= port
->bridge
.secondary_bus
&&
643 bus
->number
<= port
->bridge
.subordinate_bus
)
650 /* PCI configuration space write function */
651 static int mvebu_pcie_wr_conf(struct pci_bus
*bus
, u32 devfn
,
652 int where
, int size
, u32 val
)
654 struct mvebu_pcie
*pcie
= sys_to_pcie(bus
->sysdata
);
655 struct mvebu_pcie_port
*port
;
658 port
= mvebu_pcie_find_port(pcie
, bus
, devfn
);
660 return PCIBIOS_DEVICE_NOT_FOUND
;
662 /* Access the emulated PCI-to-PCI bridge */
663 if (bus
->number
== 0)
664 return mvebu_sw_pci_bridge_write(port
, where
, size
, val
);
666 if (!mvebu_pcie_link_up(port
))
667 return PCIBIOS_DEVICE_NOT_FOUND
;
670 * On the secondary bus, we don't want to expose any other
671 * device than the device physically connected in the PCIe
672 * slot, visible in slot 0. In slot 1, there's a special
673 * Marvell device that only makes sense when the Armada is
674 * used as a PCIe endpoint.
676 if (bus
->number
== port
->bridge
.secondary_bus
&&
677 PCI_SLOT(devfn
) != 0)
678 return PCIBIOS_DEVICE_NOT_FOUND
;
680 /* Access the real PCIe interface */
681 ret
= mvebu_pcie_hw_wr_conf(port
, bus
, devfn
,
687 /* PCI configuration space read function */
688 static int mvebu_pcie_rd_conf(struct pci_bus
*bus
, u32 devfn
, int where
,
691 struct mvebu_pcie
*pcie
= sys_to_pcie(bus
->sysdata
);
692 struct mvebu_pcie_port
*port
;
695 port
= mvebu_pcie_find_port(pcie
, bus
, devfn
);
698 return PCIBIOS_DEVICE_NOT_FOUND
;
701 /* Access the emulated PCI-to-PCI bridge */
702 if (bus
->number
== 0)
703 return mvebu_sw_pci_bridge_read(port
, where
, size
, val
);
705 if (!mvebu_pcie_link_up(port
)) {
707 return PCIBIOS_DEVICE_NOT_FOUND
;
711 * On the secondary bus, we don't want to expose any other
712 * device than the device physically connected in the PCIe
713 * slot, visible in slot 0. In slot 1, there's a special
714 * Marvell device that only makes sense when the Armada is
715 * used as a PCIe endpoint.
717 if (bus
->number
== port
->bridge
.secondary_bus
&&
718 PCI_SLOT(devfn
) != 0) {
720 return PCIBIOS_DEVICE_NOT_FOUND
;
723 /* Access the real PCIe interface */
724 ret
= mvebu_pcie_hw_rd_conf(port
, bus
, devfn
,
730 static struct pci_ops mvebu_pcie_ops
= {
731 .read
= mvebu_pcie_rd_conf
,
732 .write
= mvebu_pcie_wr_conf
,
735 static int mvebu_pcie_setup(int nr
, struct pci_sys_data
*sys
)
737 struct mvebu_pcie
*pcie
= sys_to_pcie(sys
);
740 pcie
->mem
.name
= "PCI MEM";
741 pcie
->realio
.name
= "PCI I/O";
743 if (request_resource(&iomem_resource
, &pcie
->mem
))
746 if (resource_size(&pcie
->realio
) != 0) {
747 if (request_resource(&ioport_resource
, &pcie
->realio
)) {
748 release_resource(&pcie
->mem
);
751 pci_add_resource_offset(&sys
->resources
, &pcie
->realio
,
754 pci_add_resource_offset(&sys
->resources
, &pcie
->mem
, sys
->mem_offset
);
755 pci_add_resource(&sys
->resources
, &pcie
->busn
);
757 for (i
= 0; i
< pcie
->nports
; i
++) {
758 struct mvebu_pcie_port
*port
= &pcie
->ports
[i
];
762 mvebu_pcie_setup_hw(port
);
768 static resource_size_t
mvebu_pcie_align_resource(struct pci_dev
*dev
,
769 const struct resource
*res
,
770 resource_size_t start
,
771 resource_size_t size
,
772 resource_size_t align
)
774 if (dev
->bus
->number
!= 0)
778 * On the PCI-to-PCI bridge side, the I/O windows must have at
779 * least a 64 KB size and the memory windows must have at
780 * least a 1 MB size. Moreover, MBus windows need to have a
781 * base address aligned on their size, and their size must be
782 * a power of two. This means that if the BAR doesn't have a
783 * power of two size, several MBus windows will actually be
784 * created. We need to ensure that the biggest MBus window
785 * (which will be the first one) is aligned on its size, which
786 * explains the rounddown_pow_of_two() being done here.
788 if (res
->flags
& IORESOURCE_IO
)
789 return round_up(start
, max_t(resource_size_t
, SZ_64K
,
790 rounddown_pow_of_two(size
)));
791 else if (res
->flags
& IORESOURCE_MEM
)
792 return round_up(start
, max_t(resource_size_t
, SZ_1M
,
793 rounddown_pow_of_two(size
)));
798 static void mvebu_pcie_enable(struct mvebu_pcie
*pcie
)
802 memset(&hw
, 0, sizeof(hw
));
804 #ifdef CONFIG_PCI_MSI
805 hw
.msi_ctrl
= pcie
->msi
;
808 hw
.nr_controllers
= 1;
809 hw
.private_data
= (void **)&pcie
;
810 hw
.setup
= mvebu_pcie_setup
;
811 hw
.map_irq
= of_irq_parse_and_map_pci
;
812 hw
.ops
= &mvebu_pcie_ops
;
813 hw
.align_resource
= mvebu_pcie_align_resource
;
815 pci_common_init_dev(&pcie
->pdev
->dev
, &hw
);
819 * Looks up the list of register addresses encoded into the reg =
820 * <...> property for one that matches the given port/lane. Once
823 static void __iomem
*mvebu_pcie_map_registers(struct platform_device
*pdev
,
824 struct device_node
*np
,
825 struct mvebu_pcie_port
*port
)
827 struct resource regs
;
830 ret
= of_address_to_resource(np
, 0, ®s
);
834 return devm_ioremap_resource(&pdev
->dev
, ®s
);
837 #define DT_FLAGS_TO_TYPE(flags) (((flags) >> 24) & 0x03)
838 #define DT_TYPE_IO 0x1
839 #define DT_TYPE_MEM32 0x2
840 #define DT_CPUADDR_TO_TARGET(cpuaddr) (((cpuaddr) >> 56) & 0xFF)
841 #define DT_CPUADDR_TO_ATTR(cpuaddr) (((cpuaddr) >> 48) & 0xFF)
843 static int mvebu_get_tgt_attr(struct device_node
*np
, int devfn
,
848 const int na
= 3, ns
= 2;
850 int rlen
, nranges
, rangesz
, pna
, i
;
855 range
= of_get_property(np
, "ranges", &rlen
);
859 pna
= of_n_addr_cells(np
);
860 rangesz
= pna
+ na
+ ns
;
861 nranges
= rlen
/ sizeof(__be32
) / rangesz
;
863 for (i
= 0; i
< nranges
; i
++, range
+= rangesz
) {
864 u32 flags
= of_read_number(range
, 1);
865 u32 slot
= of_read_number(range
+ 1, 1);
866 u64 cpuaddr
= of_read_number(range
+ na
, pna
);
869 if (DT_FLAGS_TO_TYPE(flags
) == DT_TYPE_IO
)
870 rtype
= IORESOURCE_IO
;
871 else if (DT_FLAGS_TO_TYPE(flags
) == DT_TYPE_MEM32
)
872 rtype
= IORESOURCE_MEM
;
876 if (slot
== PCI_SLOT(devfn
) && type
== rtype
) {
877 *tgt
= DT_CPUADDR_TO_TARGET(cpuaddr
);
878 *attr
= DT_CPUADDR_TO_ATTR(cpuaddr
);
886 static void mvebu_pcie_msi_enable(struct mvebu_pcie
*pcie
)
888 struct device_node
*msi_node
;
890 msi_node
= of_parse_phandle(pcie
->pdev
->dev
.of_node
,
895 pcie
->msi
= of_pci_find_msi_chip_by_node(msi_node
);
896 of_node_put(msi_node
);
899 pcie
->msi
->dev
= &pcie
->pdev
->dev
;
902 static int mvebu_pcie_suspend(struct device
*dev
)
904 struct mvebu_pcie
*pcie
;
907 pcie
= dev_get_drvdata(dev
);
908 for (i
= 0; i
< pcie
->nports
; i
++) {
909 struct mvebu_pcie_port
*port
= pcie
->ports
+ i
;
910 port
->saved_pcie_stat
= mvebu_readl(port
, PCIE_STAT_OFF
);
916 static int mvebu_pcie_resume(struct device
*dev
)
918 struct mvebu_pcie
*pcie
;
921 pcie
= dev_get_drvdata(dev
);
922 for (i
= 0; i
< pcie
->nports
; i
++) {
923 struct mvebu_pcie_port
*port
= pcie
->ports
+ i
;
924 mvebu_writel(port
, port
->saved_pcie_stat
, PCIE_STAT_OFF
);
925 mvebu_pcie_setup_hw(port
);
931 static int mvebu_pcie_parse_port(struct mvebu_pcie
*pcie
,
932 struct mvebu_pcie_port
*port
, struct device_node
*child
)
934 struct device
*dev
= &pcie
->pdev
->dev
;
935 enum of_gpio_flags flags
;
940 if (of_property_read_u32(child
, "marvell,pcie-port", &port
->port
)) {
941 dev_warn(dev
, "ignoring %s, missing pcie-port property\n",
942 of_node_full_name(child
));
946 if (of_property_read_u32(child
, "marvell,pcie-lane", &port
->lane
))
949 port
->name
= kasprintf(GFP_KERNEL
, "pcie%d.%d", port
->port
, port
->lane
);
951 port
->devfn
= of_pci_get_devfn(child
);
955 ret
= mvebu_get_tgt_attr(dev
->of_node
, port
->devfn
, IORESOURCE_MEM
,
956 &port
->mem_target
, &port
->mem_attr
);
958 dev_err(dev
, "%s: cannot get tgt/attr for mem window\n",
963 if (resource_size(&pcie
->io
) != 0)
964 mvebu_get_tgt_attr(dev
->of_node
, port
->devfn
, IORESOURCE_IO
,
965 &port
->io_target
, &port
->io_attr
);
967 port
->io_target
= -1;
971 port
->reset_gpio
= of_get_named_gpio_flags(child
, "reset-gpios", 0,
973 if (gpio_is_valid(port
->reset_gpio
)) {
974 port
->reset_active_low
= flags
& OF_GPIO_ACTIVE_LOW
;
975 port
->reset_name
= kasprintf(GFP_KERNEL
, "%s-reset",
978 ret
= devm_gpio_request_one(dev
, port
->reset_gpio
,
979 GPIOF_DIR_OUT
, port
->reset_name
);
981 if (ret
== -EPROBE_DEFER
)
987 port
->clk
= of_clk_get_by_name(child
, NULL
);
988 if (IS_ERR(port
->clk
)) {
989 dev_err(dev
, "%s: cannot get clock\n", port
->name
);
1001 static int mvebu_pcie_probe(struct platform_device
*pdev
)
1003 struct mvebu_pcie
*pcie
;
1004 struct device_node
*np
= pdev
->dev
.of_node
;
1005 struct device_node
*child
;
1008 pcie
= devm_kzalloc(&pdev
->dev
, sizeof(struct mvebu_pcie
),
1014 platform_set_drvdata(pdev
, pcie
);
1016 /* Get the PCIe memory and I/O aperture */
1017 mvebu_mbus_get_pcie_mem_aperture(&pcie
->mem
);
1018 if (resource_size(&pcie
->mem
) == 0) {
1019 dev_err(&pdev
->dev
, "invalid memory aperture size\n");
1023 mvebu_mbus_get_pcie_io_aperture(&pcie
->io
);
1025 if (resource_size(&pcie
->io
) != 0) {
1026 pcie
->realio
.flags
= pcie
->io
.flags
;
1027 pcie
->realio
.start
= PCIBIOS_MIN_IO
;
1028 pcie
->realio
.end
= min_t(resource_size_t
,
1030 resource_size(&pcie
->io
));
1032 pcie
->realio
= pcie
->io
;
1034 /* Get the bus range */
1035 ret
= of_pci_parse_bus_range(np
, &pcie
->busn
);
1037 dev_err(&pdev
->dev
, "failed to parse bus-range property: %d\n",
1042 num
= of_get_available_child_count(pdev
->dev
.of_node
);
1044 pcie
->ports
= devm_kzalloc(&pdev
->dev
, num
*
1045 sizeof(struct mvebu_pcie_port
),
1051 for_each_available_child_of_node(pdev
->dev
.of_node
, child
) {
1052 struct mvebu_pcie_port
*port
= &pcie
->ports
[i
];
1054 ret
= mvebu_pcie_parse_port(pcie
, port
, child
);
1060 if (gpio_is_valid(port
->reset_gpio
)) {
1061 u32 reset_udelay
= 20000;
1063 of_property_read_u32(child
, "reset-delay-us",
1066 gpio_set_value(port
->reset_gpio
,
1067 (port
->reset_active_low
) ? 1 : 0);
1068 msleep(reset_udelay
/1000);
1071 ret
= clk_prepare_enable(port
->clk
);
1075 port
->base
= mvebu_pcie_map_registers(pdev
, child
, port
);
1076 if (IS_ERR(port
->base
)) {
1077 dev_err(&pdev
->dev
, "%s: cannot map registers\n",
1080 clk_disable_unprepare(port
->clk
);
1084 mvebu_pcie_set_local_dev_nr(port
, 1);
1087 mvebu_sw_pci_bridge_init(port
);
1093 for (i
= 0; i
< (IO_SPACE_LIMIT
- SZ_64K
); i
+= SZ_64K
)
1094 pci_ioremap_io(i
, pcie
->io
.start
+ i
);
1096 mvebu_pcie_msi_enable(pcie
);
1097 mvebu_pcie_enable(pcie
);
1099 platform_set_drvdata(pdev
, pcie
);
1104 static const struct of_device_id mvebu_pcie_of_match_table
[] = {
1105 { .compatible
= "marvell,armada-xp-pcie", },
1106 { .compatible
= "marvell,armada-370-pcie", },
1107 { .compatible
= "marvell,dove-pcie", },
1108 { .compatible
= "marvell,kirkwood-pcie", },
1111 MODULE_DEVICE_TABLE(of
, mvebu_pcie_of_match_table
);
1113 static struct dev_pm_ops mvebu_pcie_pm_ops
= {
1114 .suspend_noirq
= mvebu_pcie_suspend
,
1115 .resume_noirq
= mvebu_pcie_resume
,
1118 static struct platform_driver mvebu_pcie_driver
= {
1120 .name
= "mvebu-pcie",
1121 .of_match_table
= mvebu_pcie_of_match_table
,
1122 /* driver unloading/unbinding currently not supported */
1123 .suppress_bind_attrs
= true,
1124 .pm
= &mvebu_pcie_pm_ops
,
1126 .probe
= mvebu_pcie_probe
,
1128 module_platform_driver(mvebu_pcie_driver
);
1130 MODULE_AUTHOR("Thomas Petazzoni <thomas.petazzoni@free-electrons.com>");
1131 MODULE_DESCRIPTION("Marvell EBU PCIe driver");
1132 MODULE_LICENSE("GPL v2");