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/module.h>
13 #include <linux/mbus.h>
14 #include <linux/slab.h>
15 #include <linux/platform_device.h>
16 #include <linux/of_address.h>
17 #include <linux/of_pci.h>
18 #include <linux/of_irq.h>
19 #include <linux/of_platform.h>
22 * PCIe unit register offsets.
24 #define PCIE_DEV_ID_OFF 0x0000
25 #define PCIE_CMD_OFF 0x0004
26 #define PCIE_DEV_REV_OFF 0x0008
27 #define PCIE_BAR_LO_OFF(n) (0x0010 + ((n) << 3))
28 #define PCIE_BAR_HI_OFF(n) (0x0014 + ((n) << 3))
29 #define PCIE_HEADER_LOG_4_OFF 0x0128
30 #define PCIE_BAR_CTRL_OFF(n) (0x1804 + (((n) - 1) * 4))
31 #define PCIE_WIN04_CTRL_OFF(n) (0x1820 + ((n) << 4))
32 #define PCIE_WIN04_BASE_OFF(n) (0x1824 + ((n) << 4))
33 #define PCIE_WIN04_REMAP_OFF(n) (0x182c + ((n) << 4))
34 #define PCIE_WIN5_CTRL_OFF 0x1880
35 #define PCIE_WIN5_BASE_OFF 0x1884
36 #define PCIE_WIN5_REMAP_OFF 0x188c
37 #define PCIE_CONF_ADDR_OFF 0x18f8
38 #define PCIE_CONF_ADDR_EN 0x80000000
39 #define PCIE_CONF_REG(r) ((((r) & 0xf00) << 16) | ((r) & 0xfc))
40 #define PCIE_CONF_BUS(b) (((b) & 0xff) << 16)
41 #define PCIE_CONF_DEV(d) (((d) & 0x1f) << 11)
42 #define PCIE_CONF_FUNC(f) (((f) & 0x7) << 8)
43 #define PCIE_CONF_ADDR(bus, devfn, where) \
44 (PCIE_CONF_BUS(bus) | PCIE_CONF_DEV(PCI_SLOT(devfn)) | \
45 PCIE_CONF_FUNC(PCI_FUNC(devfn)) | PCIE_CONF_REG(where) | \
47 #define PCIE_CONF_DATA_OFF 0x18fc
48 #define PCIE_MASK_OFF 0x1910
49 #define PCIE_MASK_ENABLE_INTS 0x0f000000
50 #define PCIE_CTRL_OFF 0x1a00
51 #define PCIE_CTRL_X1_MODE 0x0001
52 #define PCIE_STAT_OFF 0x1a04
53 #define PCIE_STAT_BUS 0xff00
54 #define PCIE_STAT_DEV 0x1f0000
55 #define PCIE_STAT_LINK_DOWN BIT(0)
56 #define PCIE_DEBUG_CTRL 0x1a60
57 #define PCIE_DEBUG_SOFT_RESET BIT(20)
60 * This product ID is registered by Marvell, and used when the Marvell
61 * SoC is not the root complex, but an endpoint on the PCIe bus. It is
62 * therefore safe to re-use this PCI ID for our emulated PCI-to-PCI
65 #define MARVELL_EMULATED_PCI_PCI_BRIDGE_ID 0x7846
67 /* PCI configuration space of a PCI-to-PCI bridge */
68 struct mvebu_sw_pci_bridge
{
83 u8 secondary_latency_timer
;
100 struct mvebu_pcie_port
;
102 /* Structure representing all PCIe interfaces */
104 struct platform_device
*pdev
;
105 struct mvebu_pcie_port
*ports
;
107 struct resource realio
;
109 struct resource busn
;
113 /* Structure representing one PCIe interface */
114 struct mvebu_pcie_port
{
117 spinlock_t conf_lock
;
123 struct mvebu_sw_pci_bridge bridge
;
124 struct device_node
*dn
;
125 struct mvebu_pcie
*pcie
;
126 phys_addr_t memwin_base
;
128 phys_addr_t iowin_base
;
132 static bool mvebu_pcie_link_up(struct mvebu_pcie_port
*port
)
134 return !(readl(port
->base
+ PCIE_STAT_OFF
) & PCIE_STAT_LINK_DOWN
);
137 static void mvebu_pcie_set_local_bus_nr(struct mvebu_pcie_port
*port
, int nr
)
141 stat
= readl(port
->base
+ PCIE_STAT_OFF
);
142 stat
&= ~PCIE_STAT_BUS
;
144 writel(stat
, port
->base
+ PCIE_STAT_OFF
);
147 static void mvebu_pcie_set_local_dev_nr(struct mvebu_pcie_port
*port
, int nr
)
151 stat
= readl(port
->base
+ PCIE_STAT_OFF
);
152 stat
&= ~PCIE_STAT_DEV
;
154 writel(stat
, port
->base
+ PCIE_STAT_OFF
);
158 * Setup PCIE BARs and Address Decode Wins:
159 * BAR[0,2] -> disabled, BAR[1] -> covers all DRAM banks
160 * WIN[0-3] -> DRAM bank[0-3]
162 static void __init
mvebu_pcie_setup_wins(struct mvebu_pcie_port
*port
)
164 const struct mbus_dram_target_info
*dram
;
168 dram
= mv_mbus_dram_info();
170 /* First, disable and clear BARs and windows. */
171 for (i
= 1; i
< 3; i
++) {
172 writel(0, port
->base
+ PCIE_BAR_CTRL_OFF(i
));
173 writel(0, port
->base
+ PCIE_BAR_LO_OFF(i
));
174 writel(0, port
->base
+ PCIE_BAR_HI_OFF(i
));
177 for (i
= 0; i
< 5; i
++) {
178 writel(0, port
->base
+ PCIE_WIN04_CTRL_OFF(i
));
179 writel(0, port
->base
+ PCIE_WIN04_BASE_OFF(i
));
180 writel(0, port
->base
+ PCIE_WIN04_REMAP_OFF(i
));
183 writel(0, port
->base
+ PCIE_WIN5_CTRL_OFF
);
184 writel(0, port
->base
+ PCIE_WIN5_BASE_OFF
);
185 writel(0, port
->base
+ PCIE_WIN5_REMAP_OFF
);
187 /* Setup windows for DDR banks. Count total DDR size on the fly. */
189 for (i
= 0; i
< dram
->num_cs
; i
++) {
190 const struct mbus_dram_window
*cs
= dram
->cs
+ i
;
192 writel(cs
->base
& 0xffff0000,
193 port
->base
+ PCIE_WIN04_BASE_OFF(i
));
194 writel(0, port
->base
+ PCIE_WIN04_REMAP_OFF(i
));
195 writel(((cs
->size
- 1) & 0xffff0000) |
196 (cs
->mbus_attr
<< 8) |
197 (dram
->mbus_dram_target_id
<< 4) | 1,
198 port
->base
+ PCIE_WIN04_CTRL_OFF(i
));
203 /* Round up 'size' to the nearest power of two. */
204 if ((size
& (size
- 1)) != 0)
205 size
= 1 << fls(size
);
207 /* Setup BAR[1] to all DRAM banks. */
208 writel(dram
->cs
[0].base
, port
->base
+ PCIE_BAR_LO_OFF(1));
209 writel(0, port
->base
+ PCIE_BAR_HI_OFF(1));
210 writel(((size
- 1) & 0xffff0000) | 1,
211 port
->base
+ PCIE_BAR_CTRL_OFF(1));
214 static void __init
mvebu_pcie_setup_hw(struct mvebu_pcie_port
*port
)
219 /* Point PCIe unit MBUS decode windows to DRAM space. */
220 mvebu_pcie_setup_wins(port
);
222 /* Master + slave enable. */
223 cmd
= readw(port
->base
+ PCIE_CMD_OFF
);
224 cmd
|= PCI_COMMAND_IO
;
225 cmd
|= PCI_COMMAND_MEMORY
;
226 cmd
|= PCI_COMMAND_MASTER
;
227 writew(cmd
, port
->base
+ PCIE_CMD_OFF
);
229 /* Enable interrupt lines A-D. */
230 mask
= readl(port
->base
+ PCIE_MASK_OFF
);
231 mask
|= PCIE_MASK_ENABLE_INTS
;
232 writel(mask
, port
->base
+ PCIE_MASK_OFF
);
235 static int mvebu_pcie_hw_rd_conf(struct mvebu_pcie_port
*port
,
237 u32 devfn
, int where
, int size
, u32
*val
)
239 writel(PCIE_CONF_ADDR(bus
->number
, devfn
, where
),
240 port
->base
+ PCIE_CONF_ADDR_OFF
);
242 *val
= readl(port
->base
+ PCIE_CONF_DATA_OFF
);
245 *val
= (*val
>> (8 * (where
& 3))) & 0xff;
247 *val
= (*val
>> (8 * (where
& 3))) & 0xffff;
249 return PCIBIOS_SUCCESSFUL
;
252 static int mvebu_pcie_hw_wr_conf(struct mvebu_pcie_port
*port
,
254 u32 devfn
, int where
, int size
, u32 val
)
256 int ret
= PCIBIOS_SUCCESSFUL
;
258 writel(PCIE_CONF_ADDR(bus
->number
, devfn
, where
),
259 port
->base
+ PCIE_CONF_ADDR_OFF
);
262 writel(val
, port
->base
+ PCIE_CONF_DATA_OFF
);
264 writew(val
, port
->base
+ PCIE_CONF_DATA_OFF
+ (where
& 3));
266 writeb(val
, port
->base
+ PCIE_CONF_DATA_OFF
+ (where
& 3));
268 ret
= PCIBIOS_BAD_REGISTER_NUMBER
;
273 static void mvebu_pcie_handle_iobase_change(struct mvebu_pcie_port
*port
)
277 /* Are the new iobase/iolimit values invalid? */
278 if (port
->bridge
.iolimit
< port
->bridge
.iobase
||
279 port
->bridge
.iolimitupper
< port
->bridge
.iobaseupper
) {
281 /* If a window was configured, remove it */
282 if (port
->iowin_base
) {
283 mvebu_mbus_del_window(port
->iowin_base
,
285 port
->iowin_base
= 0;
286 port
->iowin_size
= 0;
293 * We read the PCI-to-PCI bridge emulated registers, and
294 * calculate the base address and size of the address decoding
295 * window to setup, according to the PCI-to-PCI bridge
296 * specifications. iobase is the bus address, port->iowin_base
297 * is the CPU address.
299 iobase
= ((port
->bridge
.iobase
& 0xF0) << 8) |
300 (port
->bridge
.iobaseupper
<< 16);
301 port
->iowin_base
= port
->pcie
->io
.start
+ iobase
;
302 port
->iowin_size
= ((0xFFF | ((port
->bridge
.iolimit
& 0xF0) << 8) |
303 (port
->bridge
.iolimitupper
<< 16)) -
306 mvebu_mbus_add_window_remap_flags(port
->name
, port
->iowin_base
,
311 pci_ioremap_io(iobase
, port
->iowin_base
);
314 static void mvebu_pcie_handle_membase_change(struct mvebu_pcie_port
*port
)
316 /* Are the new membase/memlimit values invalid? */
317 if (port
->bridge
.memlimit
< port
->bridge
.membase
) {
319 /* If a window was configured, remove it */
320 if (port
->memwin_base
) {
321 mvebu_mbus_del_window(port
->memwin_base
,
323 port
->memwin_base
= 0;
324 port
->memwin_size
= 0;
331 * We read the PCI-to-PCI bridge emulated registers, and
332 * calculate the base address and size of the address decoding
333 * window to setup, according to the PCI-to-PCI bridge
336 port
->memwin_base
= ((port
->bridge
.membase
& 0xFFF0) << 16);
338 (((port
->bridge
.memlimit
& 0xFFF0) << 16) | 0xFFFFF) -
341 mvebu_mbus_add_window_remap_flags(port
->name
, port
->memwin_base
,
348 * Initialize the configuration space of the PCI-to-PCI bridge
349 * associated with the given PCIe interface.
351 static void mvebu_sw_pci_bridge_init(struct mvebu_pcie_port
*port
)
353 struct mvebu_sw_pci_bridge
*bridge
= &port
->bridge
;
355 memset(bridge
, 0, sizeof(struct mvebu_sw_pci_bridge
));
357 bridge
->class = PCI_CLASS_BRIDGE_PCI
;
358 bridge
->vendor
= PCI_VENDOR_ID_MARVELL
;
359 bridge
->device
= MARVELL_EMULATED_PCI_PCI_BRIDGE_ID
;
360 bridge
->header_type
= PCI_HEADER_TYPE_BRIDGE
;
361 bridge
->cache_line_size
= 0x10;
363 /* We support 32 bits I/O addressing */
364 bridge
->iobase
= PCI_IO_RANGE_TYPE_32
;
365 bridge
->iolimit
= PCI_IO_RANGE_TYPE_32
;
369 * Read the configuration space of the PCI-to-PCI bridge associated to
370 * the given PCIe interface.
372 static int mvebu_sw_pci_bridge_read(struct mvebu_pcie_port
*port
,
373 unsigned int where
, int size
, u32
*value
)
375 struct mvebu_sw_pci_bridge
*bridge
= &port
->bridge
;
377 switch (where
& ~3) {
379 *value
= bridge
->device
<< 16 | bridge
->vendor
;
383 *value
= bridge
->command
;
386 case PCI_CLASS_REVISION
:
387 *value
= bridge
->class << 16 | bridge
->interface
<< 8 |
391 case PCI_CACHE_LINE_SIZE
:
392 *value
= bridge
->bist
<< 24 | bridge
->header_type
<< 16 |
393 bridge
->latency_timer
<< 8 | bridge
->cache_line_size
;
396 case PCI_BASE_ADDRESS_0
... PCI_BASE_ADDRESS_1
:
397 *value
= bridge
->bar
[((where
& ~3) - PCI_BASE_ADDRESS_0
) / 4];
400 case PCI_PRIMARY_BUS
:
401 *value
= (bridge
->secondary_latency_timer
<< 24 |
402 bridge
->subordinate_bus
<< 16 |
403 bridge
->secondary_bus
<< 8 |
404 bridge
->primary_bus
);
408 *value
= (bridge
->secondary_status
<< 16 |
409 bridge
->iolimit
<< 8 |
413 case PCI_MEMORY_BASE
:
414 *value
= (bridge
->memlimit
<< 16 | bridge
->membase
);
417 case PCI_PREF_MEMORY_BASE
:
421 case PCI_IO_BASE_UPPER16
:
422 *value
= (bridge
->iolimitupper
<< 16 | bridge
->iobaseupper
);
425 case PCI_ROM_ADDRESS1
:
431 return PCIBIOS_BAD_REGISTER_NUMBER
;
435 *value
= (*value
>> (8 * (where
& 3))) & 0xffff;
437 *value
= (*value
>> (8 * (where
& 3))) & 0xff;
439 return PCIBIOS_SUCCESSFUL
;
442 /* Write to the PCI-to-PCI bridge configuration space */
443 static int mvebu_sw_pci_bridge_write(struct mvebu_pcie_port
*port
,
444 unsigned int where
, int size
, u32 value
)
446 struct mvebu_sw_pci_bridge
*bridge
= &port
->bridge
;
453 mask
= ~(0xffff << ((where
& 3) * 8));
455 mask
= ~(0xff << ((where
& 3) * 8));
457 return PCIBIOS_BAD_REGISTER_NUMBER
;
459 err
= mvebu_sw_pci_bridge_read(port
, where
& ~3, 4, ®
);
463 value
= (reg
& mask
) | value
<< ((where
& 3) * 8);
465 switch (where
& ~3) {
467 bridge
->command
= value
& 0xffff;
470 case PCI_BASE_ADDRESS_0
... PCI_BASE_ADDRESS_1
:
471 bridge
->bar
[((where
& ~3) - PCI_BASE_ADDRESS_0
) / 4] = value
;
476 * We also keep bit 1 set, it is a read-only bit that
477 * indicates we support 32 bits addressing for the
480 bridge
->iobase
= (value
& 0xff) | PCI_IO_RANGE_TYPE_32
;
481 bridge
->iolimit
= ((value
>> 8) & 0xff) | PCI_IO_RANGE_TYPE_32
;
482 bridge
->secondary_status
= value
>> 16;
483 mvebu_pcie_handle_iobase_change(port
);
486 case PCI_MEMORY_BASE
:
487 bridge
->membase
= value
& 0xffff;
488 bridge
->memlimit
= value
>> 16;
489 mvebu_pcie_handle_membase_change(port
);
492 case PCI_IO_BASE_UPPER16
:
493 bridge
->iobaseupper
= value
& 0xffff;
494 bridge
->iolimitupper
= value
>> 16;
495 mvebu_pcie_handle_iobase_change(port
);
498 case PCI_PRIMARY_BUS
:
499 bridge
->primary_bus
= value
& 0xff;
500 bridge
->secondary_bus
= (value
>> 8) & 0xff;
501 bridge
->subordinate_bus
= (value
>> 16) & 0xff;
502 bridge
->secondary_latency_timer
= (value
>> 24) & 0xff;
503 mvebu_pcie_set_local_bus_nr(port
, bridge
->secondary_bus
);
510 return PCIBIOS_SUCCESSFUL
;
513 static inline struct mvebu_pcie
*sys_to_pcie(struct pci_sys_data
*sys
)
515 return sys
->private_data
;
518 static struct mvebu_pcie_port
*
519 mvebu_pcie_find_port(struct mvebu_pcie
*pcie
, struct pci_bus
*bus
,
524 for (i
= 0; i
< pcie
->nports
; i
++) {
525 struct mvebu_pcie_port
*port
= &pcie
->ports
[i
];
526 if (bus
->number
== 0 && port
->devfn
== devfn
)
528 if (bus
->number
!= 0 &&
529 bus
->number
>= port
->bridge
.secondary_bus
&&
530 bus
->number
<= port
->bridge
.subordinate_bus
)
537 /* PCI configuration space write function */
538 static int mvebu_pcie_wr_conf(struct pci_bus
*bus
, u32 devfn
,
539 int where
, int size
, u32 val
)
541 struct mvebu_pcie
*pcie
= sys_to_pcie(bus
->sysdata
);
542 struct mvebu_pcie_port
*port
;
546 port
= mvebu_pcie_find_port(pcie
, bus
, devfn
);
548 return PCIBIOS_DEVICE_NOT_FOUND
;
550 /* Access the emulated PCI-to-PCI bridge */
551 if (bus
->number
== 0)
552 return mvebu_sw_pci_bridge_write(port
, where
, size
, val
);
555 return PCIBIOS_DEVICE_NOT_FOUND
;
558 * On the secondary bus, we don't want to expose any other
559 * device than the device physically connected in the PCIe
560 * slot, visible in slot 0. In slot 1, there's a special
561 * Marvell device that only makes sense when the Armada is
562 * used as a PCIe endpoint.
564 if (bus
->number
== port
->bridge
.secondary_bus
&&
565 PCI_SLOT(devfn
) != 0)
566 return PCIBIOS_DEVICE_NOT_FOUND
;
568 /* Access the real PCIe interface */
569 spin_lock_irqsave(&port
->conf_lock
, flags
);
570 ret
= mvebu_pcie_hw_wr_conf(port
, bus
, devfn
,
572 spin_unlock_irqrestore(&port
->conf_lock
, flags
);
577 /* PCI configuration space read function */
578 static int mvebu_pcie_rd_conf(struct pci_bus
*bus
, u32 devfn
, int where
,
581 struct mvebu_pcie
*pcie
= sys_to_pcie(bus
->sysdata
);
582 struct mvebu_pcie_port
*port
;
586 port
= mvebu_pcie_find_port(pcie
, bus
, devfn
);
589 return PCIBIOS_DEVICE_NOT_FOUND
;
592 /* Access the emulated PCI-to-PCI bridge */
593 if (bus
->number
== 0)
594 return mvebu_sw_pci_bridge_read(port
, where
, size
, val
);
596 if (!port
->haslink
) {
598 return PCIBIOS_DEVICE_NOT_FOUND
;
602 * On the secondary bus, we don't want to expose any other
603 * device than the device physically connected in the PCIe
604 * slot, visible in slot 0. In slot 1, there's a special
605 * Marvell device that only makes sense when the Armada is
606 * used as a PCIe endpoint.
608 if (bus
->number
== port
->bridge
.secondary_bus
&&
609 PCI_SLOT(devfn
) != 0) {
611 return PCIBIOS_DEVICE_NOT_FOUND
;
614 /* Access the real PCIe interface */
615 spin_lock_irqsave(&port
->conf_lock
, flags
);
616 ret
= mvebu_pcie_hw_rd_conf(port
, bus
, devfn
,
618 spin_unlock_irqrestore(&port
->conf_lock
, flags
);
623 static struct pci_ops mvebu_pcie_ops
= {
624 .read
= mvebu_pcie_rd_conf
,
625 .write
= mvebu_pcie_wr_conf
,
628 static int __init
mvebu_pcie_setup(int nr
, struct pci_sys_data
*sys
)
630 struct mvebu_pcie
*pcie
= sys_to_pcie(sys
);
633 pci_add_resource_offset(&sys
->resources
, &pcie
->realio
, sys
->io_offset
);
634 pci_add_resource_offset(&sys
->resources
, &pcie
->mem
, sys
->mem_offset
);
635 pci_add_resource(&sys
->resources
, &pcie
->busn
);
637 for (i
= 0; i
< pcie
->nports
; i
++) {
638 struct mvebu_pcie_port
*port
= &pcie
->ports
[i
];
639 mvebu_pcie_setup_hw(port
);
645 static int __init
mvebu_pcie_map_irq(const struct pci_dev
*dev
, u8 slot
, u8 pin
)
650 ret
= of_irq_map_pci(dev
, &oirq
);
654 return irq_create_of_mapping(oirq
.controller
, oirq
.specifier
,
658 static struct pci_bus
*mvebu_pcie_scan_bus(int nr
, struct pci_sys_data
*sys
)
660 struct mvebu_pcie
*pcie
= sys_to_pcie(sys
);
663 bus
= pci_create_root_bus(&pcie
->pdev
->dev
, sys
->busnr
,
664 &mvebu_pcie_ops
, sys
, &sys
->resources
);
668 pci_scan_child_bus(bus
);
673 resource_size_t
mvebu_pcie_align_resource(struct pci_dev
*dev
,
674 const struct resource
*res
,
675 resource_size_t start
,
676 resource_size_t size
,
677 resource_size_t align
)
679 if (dev
->bus
->number
!= 0)
683 * On the PCI-to-PCI bridge side, the I/O windows must have at
684 * least a 64 KB size and be aligned on their size, and the
685 * memory windows must have at least a 1 MB size and be
686 * aligned on their size
688 if (res
->flags
& IORESOURCE_IO
)
689 return round_up(start
, max((resource_size_t
)SZ_64K
, size
));
690 else if (res
->flags
& IORESOURCE_MEM
)
691 return round_up(start
, max((resource_size_t
)SZ_1M
, size
));
696 static void __init
mvebu_pcie_enable(struct mvebu_pcie
*pcie
)
700 memset(&hw
, 0, sizeof(hw
));
702 hw
.nr_controllers
= 1;
703 hw
.private_data
= (void **)&pcie
;
704 hw
.setup
= mvebu_pcie_setup
;
705 hw
.scan
= mvebu_pcie_scan_bus
;
706 hw
.map_irq
= mvebu_pcie_map_irq
;
707 hw
.ops
= &mvebu_pcie_ops
;
708 hw
.align_resource
= mvebu_pcie_align_resource
;
710 pci_common_init(&hw
);
714 * Looks up the list of register addresses encoded into the reg =
715 * <...> property for one that matches the given port/lane. Once
718 static void __iomem
* __init
719 mvebu_pcie_map_registers(struct platform_device
*pdev
,
720 struct device_node
*np
,
721 struct mvebu_pcie_port
*port
)
723 struct resource regs
;
726 ret
= of_address_to_resource(np
, 0, ®s
);
730 return devm_request_and_ioremap(&pdev
->dev
, ®s
);
733 static int __init
mvebu_pcie_probe(struct platform_device
*pdev
)
735 struct mvebu_pcie
*pcie
;
736 struct device_node
*np
= pdev
->dev
.of_node
;
737 struct of_pci_range range
;
738 struct of_pci_range_parser parser
;
739 struct device_node
*child
;
742 pcie
= devm_kzalloc(&pdev
->dev
, sizeof(struct mvebu_pcie
),
749 if (of_pci_range_parser_init(&parser
, np
))
752 /* Get the I/O and memory ranges from DT */
753 for_each_of_pci_range(&parser
, &range
) {
754 unsigned long restype
= range
.flags
& IORESOURCE_TYPE_BITS
;
755 if (restype
== IORESOURCE_IO
) {
756 of_pci_range_to_resource(&range
, np
, &pcie
->io
);
757 of_pci_range_to_resource(&range
, np
, &pcie
->realio
);
758 pcie
->io
.name
= "I/O";
759 pcie
->realio
.start
= max_t(resource_size_t
,
762 pcie
->realio
.end
= min_t(resource_size_t
,
764 range
.pci_addr
+ range
.size
);
766 if (restype
== IORESOURCE_MEM
) {
767 of_pci_range_to_resource(&range
, np
, &pcie
->mem
);
768 pcie
->mem
.name
= "MEM";
772 /* Get the bus range */
773 ret
= of_pci_parse_bus_range(np
, &pcie
->busn
);
775 dev_err(&pdev
->dev
, "failed to parse bus-range property: %d\n",
780 for_each_child_of_node(pdev
->dev
.of_node
, child
) {
781 if (!of_device_is_available(child
))
786 pcie
->ports
= devm_kzalloc(&pdev
->dev
, pcie
->nports
*
787 sizeof(struct mvebu_pcie_port
),
793 for_each_child_of_node(pdev
->dev
.of_node
, child
) {
794 struct mvebu_pcie_port
*port
= &pcie
->ports
[i
];
796 if (!of_device_is_available(child
))
801 if (of_property_read_u32(child
, "marvell,pcie-port",
804 "ignoring PCIe DT node, missing pcie-port property\n");
808 if (of_property_read_u32(child
, "marvell,pcie-lane",
812 port
->name
= kasprintf(GFP_KERNEL
, "pcie%d.%d",
813 port
->port
, port
->lane
);
815 port
->devfn
= of_pci_get_devfn(child
);
819 port
->base
= mvebu_pcie_map_registers(pdev
, child
, port
);
821 dev_err(&pdev
->dev
, "PCIe%d.%d: cannot map registers\n",
822 port
->port
, port
->lane
);
826 mvebu_pcie_set_local_dev_nr(port
, 1);
828 if (mvebu_pcie_link_up(port
)) {
830 dev_info(&pdev
->dev
, "PCIe%d.%d: link up\n",
831 port
->port
, port
->lane
);
834 dev_info(&pdev
->dev
, "PCIe%d.%d: link down\n",
835 port
->port
, port
->lane
);
838 port
->clk
= of_clk_get_by_name(child
, NULL
);
839 if (IS_ERR(port
->clk
)) {
840 dev_err(&pdev
->dev
, "PCIe%d.%d: cannot get clock\n",
841 port
->port
, port
->lane
);
849 clk_prepare_enable(port
->clk
);
850 spin_lock_init(&port
->conf_lock
);
852 mvebu_sw_pci_bridge_init(port
);
857 mvebu_pcie_enable(pcie
);
862 static const struct of_device_id mvebu_pcie_of_match_table
[] = {
863 { .compatible
= "marvell,armada-xp-pcie", },
864 { .compatible
= "marvell,armada-370-pcie", },
865 { .compatible
= "marvell,kirkwood-pcie", },
868 MODULE_DEVICE_TABLE(of
, mvebu_pcie_of_match_table
);
870 static struct platform_driver mvebu_pcie_driver
= {
872 .owner
= THIS_MODULE
,
873 .name
= "mvebu-pcie",
875 of_match_ptr(mvebu_pcie_of_match_table
),
879 static int __init
mvebu_pcie_init(void)
881 return platform_driver_probe(&mvebu_pcie_driver
,
885 subsys_initcall(mvebu_pcie_init
);
887 MODULE_AUTHOR("Thomas Petazzoni <thomas.petazzoni@free-electrons.com>");
888 MODULE_DESCRIPTION("Marvell EBU PCIe driver");
889 MODULE_LICENSE("GPLv2");