2 * Copyright (c) 2015 Ruslan Bukin <br@bsdpad.com>
3 * Copyright (c) 2014 The FreeBSD Foundation
6 * This software was developed by Semihalf under
7 * the sponsorship of the FreeBSD Foundation.
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted provided that the following conditions
12 * 1. Redistributions of source code must retain the above copyright
13 * notice, this list of conditions and the following disclaimer.
14 * 2. Redistributions in binary form must reproduce the above copyright
15 * notice, this list of conditions and the following disclaimer in the
16 * documentation and/or other materials provided with the distribution.
18 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
19 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
21 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
22 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
23 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
24 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
25 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
26 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
27 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31 /* Generic ECAM PCIe driver */
33 #include <sys/cdefs.h>
34 __FBSDID("$FreeBSD$");
36 #include "opt_platform.h"
38 #include <sys/param.h>
39 #include <sys/systm.h>
40 #include <sys/malloc.h>
41 #include <sys/kernel.h>
43 #include <sys/module.h>
45 #include <sys/endian.h>
46 #include <sys/cpuset.h>
47 #include <sys/rwlock.h>
50 #include <machine/intr.h>
53 #include <dev/ofw/openfirm.h>
54 #include <dev/ofw/ofw_bus.h>
55 #include <dev/ofw/ofw_bus_subr.h>
56 #include <dev/ofw/ofw_pci.h>
57 #include <dev/pci/pcivar.h>
58 #include <dev/pci/pcireg.h>
59 #include <dev/pci/pcib_private.h>
60 #include <dev/pci/pci_host_generic.h>
62 #include <machine/cpu.h>
63 #include <machine/bus.h>
64 #include <machine/intr.h>
65 #include <vm/vm_page.h>
69 /* Assembling ECAM Configuration Address */
70 #define PCIE_BUS_SHIFT 20
71 #define PCIE_SLOT_SHIFT 15
72 #define PCIE_FUNC_SHIFT 12
73 #define PCIE_BUS_MASK 0xFF
74 #define PCIE_SLOT_MASK 0x1F
75 #define PCIE_FUNC_MASK 0x07
76 #define PCIE_REG_MASK 0xFFF
78 #define PCIE_ADDR_OFFSET(bus, slot, func, reg) \
79 ((((bus) & PCIE_BUS_MASK) << PCIE_BUS_SHIFT) | \
80 (((slot) & PCIE_SLOT_MASK) << PCIE_SLOT_SHIFT) | \
81 (((func) & PCIE_FUNC_MASK) << PCIE_FUNC_SHIFT) | \
82 ((reg) & PCIE_REG_MASK))
84 #define PCI_IO_WINDOW_OFFSET 0x1000
86 #define SPACE_CODE_SHIFT 24
87 #define SPACE_CODE_MASK 0x3
88 #define SPACE_CODE_IO_SPACE 0x1
89 #define PROPS_CELL_SIZE 1
90 #define PCI_ADDR_CELL_SIZE 2
92 /* OFW bus interface */
93 struct generic_pcie_ofw_devinfo {
94 struct ofw_bus_devinfo di_dinfo;
95 struct resource_list di_rl;
98 /* Forward prototypes */
100 static int generic_pcie_probe(device_t dev);
101 static int parse_pci_mem_ranges(struct generic_pcie_softc *sc);
102 static uint32_t generic_pcie_read_config(device_t dev, u_int bus, u_int slot,
103 u_int func, u_int reg, int bytes);
104 static void generic_pcie_write_config(device_t dev, u_int bus, u_int slot,
105 u_int func, u_int reg, uint32_t val, int bytes);
106 static int generic_pcie_maxslots(device_t dev);
107 static int generic_pcie_read_ivar(device_t dev, device_t child, int index,
109 static int generic_pcie_write_ivar(device_t dev, device_t child, int index,
111 static struct resource *generic_pcie_alloc_resource_ofw(device_t, device_t,
112 int, int *, rman_res_t, rman_res_t, rman_res_t, u_int);
113 static struct resource *generic_pcie_alloc_resource_pcie(device_t dev,
114 device_t child, int type, int *rid, rman_res_t start, rman_res_t end,
115 rman_res_t count, u_int flags);
116 static int generic_pcie_release_resource(device_t dev, device_t child,
117 int type, int rid, struct resource *res);
118 static int generic_pcie_release_resource_ofw(device_t, device_t, int, int,
120 static int generic_pcie_release_resource_pcie(device_t, device_t, int, int,
122 static int generic_pcie_ofw_bus_attach(device_t);
123 static const struct ofw_bus_devinfo *generic_pcie_ofw_get_devinfo(device_t,
127 get_addr_size_cells(phandle_t node, pcell_t *addr_cells, pcell_t *size_cells)
131 /* Find address cells if present */
132 OF_getencprop(node, "#address-cells", addr_cells, sizeof(*addr_cells));
135 /* Find size cells if present */
136 OF_getencprop(node, "#size-cells", size_cells, sizeof(*size_cells));
140 generic_pcie_probe(device_t dev)
143 if (!ofw_bus_status_okay(dev))
146 if (ofw_bus_is_compatible(dev, "pci-host-ecam-generic")) {
147 device_set_desc(dev, "Generic PCI host controller");
148 return (BUS_PROBE_GENERIC);
150 if (ofw_bus_is_compatible(dev, "arm,gem5_pcie")) {
151 device_set_desc(dev, "GEM5 PCIe host controller");
152 return (BUS_PROBE_DEFAULT);
159 pci_host_generic_attach(device_t dev)
161 struct generic_pcie_softc *sc;
170 sc = device_get_softc(dev);
173 /* Retrieve 'ranges' property from FDT */
175 device_printf(dev, "parsing FDT for ECAM%d:\n",
177 if (parse_pci_mem_ranges(sc))
181 if (generic_pcie_ofw_bus_attach(dev) != 0)
184 node = ofw_bus_get_node(dev);
185 if (sc->coherent == 0) {
186 sc->coherent = OF_hasprop(node, "dma-coherent");
189 device_printf(dev, "Bus is%s cache-coherent\n",
190 sc->coherent ? "" : " not");
192 /* Create the parent DMA tag to pass down the coherent flag */
193 error = bus_dma_tag_create(bus_get_dma_tag(dev), /* parent */
194 1, 0, /* alignment, bounds */
195 BUS_SPACE_MAXADDR, /* lowaddr */
196 BUS_SPACE_MAXADDR, /* highaddr */
197 NULL, NULL, /* filter, filterarg */
198 BUS_SPACE_MAXSIZE, /* maxsize */
199 BUS_SPACE_UNRESTRICTED, /* nsegments */
200 BUS_SPACE_MAXSIZE, /* maxsegsize */
201 sc->coherent ? BUS_DMA_COHERENT : 0, /* flags */
202 NULL, NULL, /* lockfunc, lockarg */
208 sc->res = bus_alloc_resource_any(dev, SYS_RES_MEMORY, &rid, RF_ACTIVE);
209 if (sc->res == NULL) {
210 device_printf(dev, "could not map memory.\n");
214 sc->bst = rman_get_bustag(sc->res);
215 sc->bsh = rman_get_bushandle(sc->res);
217 sc->mem_rman.rm_type = RMAN_ARRAY;
218 sc->mem_rman.rm_descr = "PCIe Memory";
219 sc->io_rman.rm_type = RMAN_ARRAY;
220 sc->io_rman.rm_descr = "PCIe IO window";
222 /* Initialize rman and allocate memory regions */
223 error = rman_init(&sc->mem_rman);
225 device_printf(dev, "rman_init() failed. error = %d\n", error);
229 error = rman_init(&sc->io_rman);
231 device_printf(dev, "rman_init() failed. error = %d\n", error);
235 for (tuple = 0; tuple < MAX_RANGES_TUPLES; tuple++) {
236 phys_base = sc->ranges[tuple].phys_base;
237 pci_base = sc->ranges[tuple].pci_base;
238 size = sc->ranges[tuple].size;
239 if (phys_base == 0 || size == 0)
240 continue; /* empty range element */
241 if (sc->ranges[tuple].flags & FLAG_MEM) {
242 error = rman_manage_region(&sc->mem_rman,
243 phys_base, phys_base + size - 1);
244 } else if (sc->ranges[tuple].flags & FLAG_IO) {
245 error = rman_manage_region(&sc->io_rman,
246 pci_base + PCI_IO_WINDOW_OFFSET,
247 pci_base + PCI_IO_WINDOW_OFFSET + size - 1);
251 device_printf(dev, "rman_manage_region() failed."
252 "error = %d\n", error);
253 rman_fini(&sc->mem_rman);
258 ofw_bus_setup_iinfo(node, &sc->pci_iinfo, sizeof(cell_t));
260 device_add_child(dev, "pci", -1);
261 return (bus_generic_attach(dev));
265 parse_pci_mem_ranges(struct generic_pcie_softc *sc)
267 pcell_t pci_addr_cells, parent_addr_cells;
268 pcell_t attributes, size_cells;
275 node = ofw_bus_get_node(sc->dev);
277 OF_getencprop(node, "#address-cells", &pci_addr_cells,
278 sizeof(pci_addr_cells));
279 OF_getencprop(node, "#size-cells", &size_cells,
281 OF_getencprop(OF_parent(node), "#address-cells", &parent_addr_cells,
282 sizeof(parent_addr_cells));
284 if (parent_addr_cells != 2 || pci_addr_cells != 3 || size_cells != 2) {
285 device_printf(sc->dev,
286 "Unexpected number of address or size cells in FDT\n");
290 nbase_ranges = OF_getproplen(node, "ranges");
291 sc->nranges = nbase_ranges / sizeof(cell_t) /
292 (parent_addr_cells + pci_addr_cells + size_cells);
293 base_ranges = malloc(nbase_ranges, M_DEVBUF, M_WAITOK);
294 OF_getencprop(node, "ranges", base_ranges, nbase_ranges);
296 for (i = 0, j = 0; i < sc->nranges; i++) {
297 attributes = (base_ranges[j++] >> SPACE_CODE_SHIFT) & \
299 if (attributes == SPACE_CODE_IO_SPACE) {
300 sc->ranges[i].flags |= FLAG_IO;
302 sc->ranges[i].flags |= FLAG_MEM;
305 sc->ranges[i].pci_base = 0;
306 for (k = 0; k < (pci_addr_cells - 1); k++) {
307 sc->ranges[i].pci_base <<= 32;
308 sc->ranges[i].pci_base |= base_ranges[j++];
310 sc->ranges[i].phys_base = 0;
311 for (k = 0; k < parent_addr_cells; k++) {
312 sc->ranges[i].phys_base <<= 32;
313 sc->ranges[i].phys_base |= base_ranges[j++];
315 sc->ranges[i].size = 0;
316 for (k = 0; k < size_cells; k++) {
317 sc->ranges[i].size <<= 32;
318 sc->ranges[i].size |= base_ranges[j++];
322 for (; i < MAX_RANGES_TUPLES; i++) {
323 /* zero-fill remaining tuples to mark empty elements in array */
324 sc->ranges[i].pci_base = 0;
325 sc->ranges[i].phys_base = 0;
326 sc->ranges[i].size = 0;
330 for (tuple = 0; tuple < MAX_RANGES_TUPLES; tuple++) {
331 device_printf(sc->dev,
332 "\tPCI addr: 0x%jx, CPU addr: 0x%jx, Size: 0x%jx\n",
333 sc->ranges[tuple].pci_base,
334 sc->ranges[tuple].phys_base,
335 sc->ranges[tuple].size);
339 free(base_ranges, M_DEVBUF);
344 generic_pcie_read_config(device_t dev, u_int bus, u_int slot,
345 u_int func, u_int reg, int bytes)
347 struct generic_pcie_softc *sc;
348 bus_space_handle_t h;
353 if ((bus > PCI_BUSMAX) || (slot > PCI_SLOTMAX) ||
354 (func > PCI_FUNCMAX) || (reg > PCIE_REGMAX))
357 sc = device_get_softc(dev);
359 offset = PCIE_ADDR_OFFSET(bus, slot, func, reg);
365 data = bus_space_read_1(t, h, offset);
368 data = le16toh(bus_space_read_2(t, h, offset));
371 data = le32toh(bus_space_read_4(t, h, offset));
381 generic_pcie_write_config(device_t dev, u_int bus, u_int slot,
382 u_int func, u_int reg, uint32_t val, int bytes)
384 struct generic_pcie_softc *sc;
385 bus_space_handle_t h;
389 if ((bus > PCI_BUSMAX) || (slot > PCI_SLOTMAX) ||
390 (func > PCI_FUNCMAX) || (reg > PCIE_REGMAX))
393 sc = device_get_softc(dev);
395 offset = PCIE_ADDR_OFFSET(bus, slot, func, reg);
402 bus_space_write_1(t, h, offset, val);
405 bus_space_write_2(t, h, offset, htole16(val));
408 bus_space_write_4(t, h, offset, htole32(val));
416 generic_pcie_maxslots(device_t dev)
419 return (31); /* max slots per bus acc. to standard */
423 generic_pcie_route_interrupt(device_t bus, device_t dev, int pin)
425 struct generic_pcie_softc *sc;
426 struct ofw_pci_register reg;
427 uint32_t pintr, mintr[2];
431 sc = device_get_softc(bus);
434 bzero(®, sizeof(reg));
435 reg.phys_hi = (pci_get_bus(dev) << OFW_PCI_PHYS_HI_BUSSHIFT) |
436 (pci_get_slot(dev) << OFW_PCI_PHYS_HI_DEVICESHIFT) |
437 (pci_get_function(dev) << OFW_PCI_PHYS_HI_FUNCTIONSHIFT);
439 intrcells = ofw_bus_lookup_imap(ofw_bus_get_node(dev),
440 &sc->pci_iinfo, ®, sizeof(reg), &pintr, sizeof(pintr),
441 mintr, sizeof(mintr), &iparent);
443 pintr = ofw_bus_map_intr(dev, iparent, intrcells, mintr);
447 device_printf(bus, "could not route pin %d for device %d.%d\n",
448 pin, pci_get_slot(dev), pci_get_function(dev));
449 return (PCI_INVALID_IRQ);
454 generic_pcie_read_ivar(device_t dev, device_t child, int index,
457 struct generic_pcie_softc *sc;
460 sc = device_get_softc(dev);
462 if (index == PCIB_IVAR_BUS) {
463 /* this pcib adds only pci bus 0 as child */
465 *result = secondary_bus;
470 if (index == PCIB_IVAR_DOMAIN) {
476 device_printf(dev, "ERROR: Unknown index %d.\n", index);
481 generic_pcie_write_ivar(device_t dev, device_t child, int index,
489 generic_pcie_rman(struct generic_pcie_softc *sc, int type)
494 return (&sc->io_rman);
496 return (&sc->mem_rman);
505 generic_pcie_release_resource_pcie(device_t dev, device_t child, int type,
506 int rid, struct resource *res)
508 struct generic_pcie_softc *sc;
511 sc = device_get_softc(dev);
513 rm = generic_pcie_rman(sc, type);
515 KASSERT(rman_is_region_manager(res, rm), ("rman mismatch"));
516 rman_release_resource(res);
519 return (bus_generic_release_resource(dev, child, type, rid, res));
523 generic_pcie_release_resource(device_t dev, device_t child, int type,
524 int rid, struct resource *res)
526 #if defined(NEW_PCIB) && defined(PCI_RES_BUS)
527 struct generic_pcie_softc *sc;
529 if (type == PCI_RES_BUS) {
530 sc = device_get_softc(dev);
531 return (pci_domain_release_bus(sc->ecam, child, rid, res));
534 /* For PCIe devices that do not have FDT nodes, use PCIB method */
535 if ((int)ofw_bus_get_node(child) <= 0) {
536 return (generic_pcie_release_resource_pcie(dev,
537 child, type, rid, res));
540 /* For other devices use OFW method */
541 return (generic_pcie_release_resource_ofw(dev,
542 child, type, rid, res));
546 pci_host_generic_alloc_resource(device_t dev, device_t child, int type, int *rid,
547 rman_res_t start, rman_res_t end, rman_res_t count, u_int flags)
549 #if defined(NEW_PCIB) && defined(PCI_RES_BUS)
550 struct generic_pcie_softc *sc;
552 if (type == PCI_RES_BUS) {
553 sc = device_get_softc(dev);
554 return (pci_domain_alloc_bus(sc->ecam, child, rid, start, end,
558 /* For PCIe devices that do not have FDT nodes, use PCIB method */
559 if ((int)ofw_bus_get_node(child) <= 0)
560 return (generic_pcie_alloc_resource_pcie(dev, child, type, rid,
561 start, end, count, flags));
563 /* For other devices use OFW method */
564 return (generic_pcie_alloc_resource_ofw(dev, child, type, rid,
565 start, end, count, flags));
568 static struct resource *
569 generic_pcie_alloc_resource_pcie(device_t dev, device_t child, int type, int *rid,
570 rman_res_t start, rman_res_t end, rman_res_t count, u_int flags)
572 struct generic_pcie_softc *sc;
573 struct resource *res;
576 sc = device_get_softc(dev);
578 rm = generic_pcie_rman(sc, type);
580 return (BUS_ALLOC_RESOURCE(device_get_parent(dev), dev,
581 type, rid, start, end, count, flags));
585 "rman_reserve_resource: start=%#jx, end=%#jx, count=%#jx\n",
589 res = rman_reserve_resource(rm, start, end, count, flags, child);
593 rman_set_rid(res, *rid);
595 if (flags & RF_ACTIVE)
596 if (bus_activate_resource(child, type, *rid, res)) {
597 rman_release_resource(res);
604 device_printf(dev, "%s FAIL: type=%d, rid=%d, "
605 "start=%016jx, end=%016jx, count=%016jx, flags=%x\n",
606 __func__, type, *rid, start, end, count, flags);
612 generic_pcie_adjust_resource(device_t dev, device_t child, int type,
613 struct resource *res, rman_res_t start, rman_res_t end)
615 struct generic_pcie_softc *sc;
618 sc = device_get_softc(dev);
619 #if defined(NEW_PCIB) && defined(PCI_RES_BUS)
620 if (type == PCI_RES_BUS)
621 return (pci_domain_adjust_bus(sc->ecam, child, res, start,
625 rm = generic_pcie_rman(sc, type);
627 return (rman_adjust_resource(res, start, end));
628 return (bus_generic_adjust_resource(dev, child, type, res, start, end));
632 generic_pcie_activate_resource(device_t dev, device_t child, int type, int rid,
635 struct generic_pcie_softc *sc;
643 sc = device_get_softc(dev);
645 if ((res = rman_activate_resource(r)) != 0)
651 for (i = 0; i < MAX_RANGES_TUPLES; i++) {
652 pci_base = sc->ranges[i].pci_base;
653 phys_base = sc->ranges[i].phys_base;
654 size = sc->ranges[i].size;
656 if ((rid > pci_base) && (rid < (pci_base + size))) {
662 rman_set_start(r, rman_get_start(r) + phys_base);
663 rman_set_end(r, rman_get_end(r) + phys_base);
664 BUS_ACTIVATE_RESOURCE(device_get_parent(dev), child,
667 device_printf(dev, "Failed to activate IOPORT resource\n");
672 BUS_ACTIVATE_RESOURCE(device_get_parent(dev), child, type, rid, r);
682 generic_pcie_deactivate_resource(device_t dev, device_t child, int type, int rid,
685 struct generic_pcie_softc *sc;
689 sc = device_get_softc(dev);
691 if ((res = rman_deactivate_resource(r)) != 0)
697 vaddr = (vm_offset_t)rman_get_virtual(r);
698 pmap_unmapdev(vaddr, rman_get_size(r));
708 generic_pcie_get_dma_tag(device_t dev, device_t child)
710 struct generic_pcie_softc *sc;
712 sc = device_get_softc(dev);
717 generic_pcie_alloc_msi(device_t pci, device_t child, int count, int maxcount,
721 phandle_t msi_parent;
723 ofw_bus_msimap(ofw_bus_get_node(pci), pci_get_rid(child), &msi_parent,
725 return (intr_alloc_msi(pci, child, msi_parent, count, maxcount,
727 #elif defined(__aarch64__)
728 return (arm_alloc_msi(pci, child, count, maxcount, irqs));
735 generic_pcie_release_msi(device_t pci, device_t child, int count, int *irqs)
738 phandle_t msi_parent;
740 ofw_bus_msimap(ofw_bus_get_node(pci), pci_get_rid(child), &msi_parent,
742 return (intr_release_msi(pci, child, msi_parent, count, irqs));
743 #elif defined(__aarch64__)
744 return (arm_release_msi(pci, child, count, irqs));
751 generic_pcie_map_msi(device_t pci, device_t child, int irq, uint64_t *addr,
755 phandle_t msi_parent;
757 ofw_bus_msimap(ofw_bus_get_node(pci), pci_get_rid(child), &msi_parent,
759 return (intr_map_msi(pci, child, msi_parent, irq, addr, data));
760 #elif defined(__aarch64__)
761 return (arm_map_msi(pci, child, irq, addr, data));
768 generic_pcie_alloc_msix(device_t pci, device_t child, int *irq)
771 phandle_t msi_parent;
773 ofw_bus_msimap(ofw_bus_get_node(pci), pci_get_rid(child), &msi_parent,
775 return (intr_alloc_msix(pci, child, msi_parent, irq));
776 #elif defined(__aarch64__)
777 return (arm_alloc_msix(pci, child, irq));
784 generic_pcie_release_msix(device_t pci, device_t child, int irq)
787 phandle_t msi_parent;
789 ofw_bus_msimap(ofw_bus_get_node(pci), pci_get_rid(child), &msi_parent,
791 return (intr_release_msix(pci, child, msi_parent, irq));
792 #elif defined(__aarch64__)
793 return (arm_release_msix(pci, child, irq));
800 generic_pcie_get_id(device_t pci, device_t child, enum pci_id_type type,
807 if (type != PCI_ID_MSI)
808 return (pcib_get_id(pci, child, type, id));
810 node = ofw_bus_get_node(pci);
811 pci_rid = pci_get_rid(child);
813 ofw_bus_msimap(node, pci_rid, NULL, &rid);
819 static device_method_t generic_pcie_methods[] = {
820 DEVMETHOD(device_probe, generic_pcie_probe),
821 DEVMETHOD(device_attach, pci_host_generic_attach),
822 DEVMETHOD(bus_read_ivar, generic_pcie_read_ivar),
823 DEVMETHOD(bus_write_ivar, generic_pcie_write_ivar),
824 DEVMETHOD(bus_alloc_resource, pci_host_generic_alloc_resource),
825 DEVMETHOD(bus_adjust_resource, generic_pcie_adjust_resource),
826 DEVMETHOD(bus_release_resource, generic_pcie_release_resource),
827 DEVMETHOD(bus_activate_resource, generic_pcie_activate_resource),
828 DEVMETHOD(bus_deactivate_resource, generic_pcie_deactivate_resource),
829 DEVMETHOD(bus_setup_intr, bus_generic_setup_intr),
830 DEVMETHOD(bus_teardown_intr, bus_generic_teardown_intr),
832 DEVMETHOD(bus_get_dma_tag, generic_pcie_get_dma_tag),
835 DEVMETHOD(pcib_maxslots, generic_pcie_maxslots),
836 DEVMETHOD(pcib_route_interrupt, generic_pcie_route_interrupt),
837 DEVMETHOD(pcib_read_config, generic_pcie_read_config),
838 DEVMETHOD(pcib_write_config, generic_pcie_write_config),
839 DEVMETHOD(pcib_alloc_msi, generic_pcie_alloc_msi),
840 DEVMETHOD(pcib_release_msi, generic_pcie_release_msi),
841 DEVMETHOD(pcib_alloc_msix, generic_pcie_alloc_msix),
842 DEVMETHOD(pcib_release_msix, generic_pcie_release_msix),
843 DEVMETHOD(pcib_map_msi, generic_pcie_map_msi),
844 DEVMETHOD(pcib_get_id, generic_pcie_get_id),
846 /* ofw_bus interface */
847 DEVMETHOD(ofw_bus_get_devinfo, generic_pcie_ofw_get_devinfo),
848 DEVMETHOD(ofw_bus_get_compat, ofw_bus_gen_get_compat),
849 DEVMETHOD(ofw_bus_get_model, ofw_bus_gen_get_model),
850 DEVMETHOD(ofw_bus_get_name, ofw_bus_gen_get_name),
851 DEVMETHOD(ofw_bus_get_node, ofw_bus_gen_get_node),
852 DEVMETHOD(ofw_bus_get_type, ofw_bus_gen_get_type),
857 static const struct ofw_bus_devinfo *
858 generic_pcie_ofw_get_devinfo(device_t bus __unused, device_t child)
860 struct generic_pcie_ofw_devinfo *di;
862 di = device_get_ivars(child);
863 return (&di->di_dinfo);
866 static struct resource *
867 generic_pcie_alloc_resource_ofw(device_t bus, device_t child, int type, int *rid,
868 rman_res_t start, rman_res_t end, rman_res_t count, u_int flags)
870 struct generic_pcie_softc *sc;
871 struct generic_pcie_ofw_devinfo *di;
872 struct resource_list_entry *rle;
875 sc = device_get_softc(bus);
877 if (RMAN_IS_DEFAULT_RANGE(start, end)) {
878 if ((di = device_get_ivars(child)) == NULL)
880 if (type == SYS_RES_IOPORT)
881 type = SYS_RES_MEMORY;
883 /* Find defaults for this rid */
884 rle = resource_list_find(&di->di_rl, type, *rid);
893 if (type == SYS_RES_MEMORY) {
894 /* Remap through ranges property */
895 for (i = 0; i < MAX_RANGES_TUPLES; i++) {
896 if (start >= sc->ranges[i].phys_base && end <
897 sc->ranges[i].pci_base + sc->ranges[i].size) {
898 start -= sc->ranges[i].phys_base;
899 start += sc->ranges[i].pci_base;
900 end -= sc->ranges[i].phys_base;
901 end += sc->ranges[i].pci_base;
906 if (i == MAX_RANGES_TUPLES) {
907 device_printf(bus, "Could not map resource "
908 "%#jx-%#jx\n", start, end);
913 return (bus_generic_alloc_resource(bus, child, type, rid, start, end,
918 generic_pcie_release_resource_ofw(device_t bus, device_t child, int type, int rid,
919 struct resource *res)
922 return (bus_generic_release_resource(bus, child, type, rid, res));
925 /* Helper functions */
928 generic_pcie_ofw_bus_attach(device_t dev)
930 struct generic_pcie_ofw_devinfo *di;
932 phandle_t parent, node;
933 pcell_t addr_cells, size_cells;
935 parent = ofw_bus_get_node(dev);
937 get_addr_size_cells(parent, &addr_cells, &size_cells);
938 /* Iterate through all bus subordinates */
939 for (node = OF_child(parent); node > 0; node = OF_peer(node)) {
941 /* Allocate and populate devinfo. */
942 di = malloc(sizeof(*di), M_DEVBUF, M_WAITOK | M_ZERO);
943 if (ofw_bus_gen_setup_devinfo(&di->di_dinfo, node) != 0) {
948 /* Initialize and populate resource list. */
949 resource_list_init(&di->di_rl);
950 ofw_bus_reg_to_rl(dev, node, addr_cells, size_cells,
953 ofw_bus_intr_to_rl(dev, node, &di->di_rl, NULL);
956 /* Add newbus device for this FDT node */
957 child = device_add_child(dev, NULL, -1);
959 resource_list_free(&di->di_rl);
960 ofw_bus_gen_destroy_devinfo(&di->di_dinfo);
965 device_set_ivars(child, di);
972 DEFINE_CLASS_0(pcib, generic_pcie_driver,
973 generic_pcie_methods, sizeof(struct generic_pcie_softc));
975 devclass_t generic_pcie_devclass;
977 DRIVER_MODULE(pcib, simplebus, generic_pcie_driver,
978 generic_pcie_devclass, 0, 0);
979 DRIVER_MODULE(pcib, ofwbus, generic_pcie_driver,
980 generic_pcie_devclass, 0, 0);