Changeset View
Standalone View
sys/dev/pci/pci-host-generic.c
Property | Old Value | New Value |
---|---|---|
svn:eol-style | null | native \ No newline at end of property |
svn:keywords | null | FreeBSD=%H \ No newline at end of property |
svn:mime-type | null | text/plain \ No newline at end of property |
/*- | |||||
* Copyright (c) 2015 Ruslan Bukin <br@bsdpad.com> | |||||
* Copyright (c) 2014 The FreeBSD Foundation | |||||
* All rights reserved. | |||||
* | |||||
* This software was developed by Semihalf under | |||||
* the sponsorship of the FreeBSD Foundation. | |||||
* | |||||
* Redistribution and use in source and binary forms, with or without | |||||
* modification, are permitted provided that the following conditions | |||||
* are met: | |||||
* 1. Redistributions of source code must retain the above copyright | |||||
* notice, this list of conditions and the following disclaimer. | |||||
* 2. Redistributions in binary form must reproduce the above copyright | |||||
* notice, this list of conditions and the following disclaimer in the | |||||
* documentation and/or other materials provided with the distribution. | |||||
* | |||||
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND | |||||
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | |||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | |||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE | |||||
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | |||||
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | |||||
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | |||||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | |||||
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | |||||
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | |||||
* SUCH DAMAGE. | |||||
*/ | |||||
/* Generic ECAM PCIe driver */ | |||||
#include <sys/cdefs.h> | |||||
__FBSDID("$FreeBSD$"); | |||||
#include <sys/param.h> | |||||
#include <sys/systm.h> | |||||
#include <sys/malloc.h> | |||||
#include <sys/kernel.h> | |||||
#include <sys/rman.h> | |||||
#include <sys/module.h> | |||||
#include <sys/bus.h> | |||||
#include <sys/endian.h> | |||||
#include <sys/cpuset.h> | |||||
#include <sys/rwlock.h> | |||||
#include <dev/ofw/openfirm.h> | |||||
#include <dev/ofw/ofw_bus.h> | |||||
#include <dev/ofw/ofw_bus_subr.h> | |||||
#include <dev/pci/pcivar.h> | |||||
#include <dev/pci/pcireg.h> | |||||
#include <dev/pci/pcib_private.h> | |||||
#include <machine/cpu.h> | |||||
#include <machine/bus.h> | |||||
#include <machine/fdt.h> | |||||
#include <machine/intr.h> | |||||
#include <dev/fdt/fdt_common.h> | |||||
#include <vm/vm_page.h> | |||||
#include "pcib_if.h" | |||||
/* Assembling ECAM Configuration Address */ | |||||
#define PCIE_BUS_SHIFT 20 | |||||
#define PCIE_SLOT_SHIFT 15 | |||||
#define PCIE_FUNC_SHIFT 12 | |||||
#define PCIE_BUS_MASK 0xFF | |||||
#define PCIE_SLOT_MASK 0x1F | |||||
#define PCIE_FUNC_MASK 0x07 | |||||
#define PCIE_REG_MASK 0xFFF | |||||
#define PCIE_ADDR_OFFSET(bus, slot, func, reg) \ | |||||
((((bus) & PCIE_BUS_MASK) << PCIE_BUS_SHIFT) | \ | |||||
(((slot) & PCIE_SLOT_MASK) << PCIE_SLOT_SHIFT) | \ | |||||
(((func) & PCIE_FUNC_MASK) << PCIE_FUNC_SHIFT) | \ | |||||
((reg) & PCIE_REG_MASK)) | |||||
#define MAX_RANGES_TUPLES 5 | |||||
#define MIN_RANGES_TUPLES 2 | |||||
#define PCI_IO_WINDOW_OFFSET 0x1000 | |||||
#define PCI_IRQ_START 32 | |||||
#define PCI_IRQ_END (PCI_IRQ_START + 4) | |||||
#define SPACE_CODE_SHIFT 24 | |||||
#define SPACE_CODE_MASK 0x3 | |||||
#define SPACE_CODE_IO_SPACE 0x1 | |||||
#define PROPS_CELL_SIZE 1 | |||||
#define PCI_ADDR_CELL_SIZE 2 | |||||
struct pcie_range { | |||||
uint64_t pci_base; | |||||
uint64_t phys_base; | |||||
uint64_t size; | |||||
uint64_t flags; | |||||
#define FLAG_IO (1 << 0) | |||||
#define FLAG_MEM (1 << 1) | |||||
}; | |||||
struct generic_pcie_softc { | |||||
struct pcie_range ranges[MAX_RANGES_TUPLES]; | |||||
struct rman mem_rman; | |||||
struct rman io_rman; | |||||
struct rman irq_rman; | |||||
struct resource *res; | |||||
struct resource *res1; | |||||
int ecam; | |||||
bus_space_tag_t bst; | |||||
bus_space_handle_t bsh; | |||||
device_t dev; | |||||
bus_space_handle_t ioh; | |||||
}; | |||||
/* Forward prototypes */ | |||||
static int generic_pcie_probe(device_t dev); | |||||
static int generic_pcie_attach(device_t dev); | |||||
static int parse_pci_mem_ranges(struct generic_pcie_softc *sc); | |||||
static uint32_t generic_pcie_read_config(device_t dev, u_int bus, u_int slot, | |||||
u_int func, u_int reg, int bytes); | |||||
static void generic_pcie_write_config(device_t dev, u_int bus, u_int slot, | |||||
u_int func, u_int reg, uint32_t val, int bytes); | |||||
static int generic_pcie_maxslots(device_t dev); | |||||
static int generic_pcie_read_ivar(device_t dev, device_t child, int index, | |||||
uintptr_t *result); | |||||
static int generic_pcie_write_ivar(device_t dev, device_t child, int index, | |||||
uintptr_t value); | |||||
static struct resource *generic_pcie_alloc_resource(device_t dev, | |||||
device_t child, int type, int *rid, u_long start, u_long end, | |||||
u_long count, u_int flags); | |||||
static int generic_pcie_release_resource(device_t dev, device_t child, | |||||
int type, int rid, struct resource *res); | |||||
static int generic_pcie_map_msi(device_t pcib, device_t child, int irq, | |||||
uint64_t *addr, uint32_t *data); | |||||
static int generic_pcie_alloc_msix(device_t pcib, device_t child, int *irq); | |||||
static int generic_pcie_release_msix(device_t pcib, device_t child, int irq); | |||||
static int generic_pcie_alloc_msi(device_t pcib, device_t child, int count, | |||||
int maxcount, int *irqs); | |||||
static int generic_pcie_release_msi(device_t pcib, device_t child, int count, | |||||
int *irqs); | |||||
static int | |||||
generic_pcie_probe(device_t dev) | |||||
{ | |||||
if (!ofw_bus_status_okay(dev)) | |||||
return (ENXIO); | |||||
if (ofw_bus_is_compatible(dev, "pci-host-ecam-generic")) { | |||||
device_set_desc(dev, "Generic PCI host controller"); | |||||
return (BUS_PROBE_DEFAULT); | |||||
} | |||||
return (ENXIO); | |||||
} | |||||
static int | |||||
generic_pcie_attach(device_t dev) | |||||
{ | |||||
struct generic_pcie_softc *sc; | |||||
uint64_t phys_base; | |||||
uint64_t pci_base; | |||||
uint64_t size; | |||||
int error; | |||||
int tuple; | |||||
int rid; | |||||
sc = device_get_softc(dev); | |||||
sc->dev = dev; | |||||
rid = 0; | |||||
sc->res = bus_alloc_resource_any(dev, SYS_RES_MEMORY, &rid, RF_ACTIVE); | |||||
if (sc->res == NULL) { | |||||
device_printf(dev, "could not map memory.\n"); | |||||
return (ENXIO); | |||||
} | |||||
sc->bst = rman_get_bustag(sc->res); | |||||
sc->bsh = rman_get_bushandle(sc->res); | |||||
sc->mem_rman.rm_type = RMAN_ARRAY; | |||||
sc->mem_rman.rm_descr = "PCIe Memory"; | |||||
sc->io_rman.rm_type = RMAN_ARRAY; | |||||
sc->io_rman.rm_descr = "PCIe IO window"; | |||||
/* Retrieve 'ranges' property from FDT */ | |||||
if (bootverbose) | |||||
device_printf(dev, "parsing FDT for ECAM%d:\n", | |||||
sc->ecam); | |||||
if (parse_pci_mem_ranges(sc)) | |||||
return (ENXIO); | |||||
/* Initialize rman and allocate memory regions */ | |||||
error = rman_init(&sc->mem_rman); | |||||
if (error) { | |||||
device_printf(dev, "rman_init() failed. error = %d\n", error); | |||||
return (error); | |||||
} | |||||
error = rman_init(&sc->io_rman); | |||||
if (error) { | |||||
device_printf(dev, "rman_init() failed. error = %d\n", error); | |||||
return (error); | |||||
} | |||||
for (tuple = 0; tuple < MAX_RANGES_TUPLES; tuple++) { | |||||
phys_base = sc->ranges[tuple].phys_base; | |||||
pci_base = sc->ranges[tuple].pci_base; | |||||
size = sc->ranges[tuple].size; | |||||
if (phys_base == 0 || size == 0) | |||||
continue; /* empty range element */ | |||||
if (sc->ranges[tuple].flags & FLAG_MEM) { | |||||
error = rman_manage_region(&sc->mem_rman, | |||||
phys_base, | |||||
phys_base + size); | |||||
} else if (sc->ranges[tuple].flags & FLAG_IO) { | |||||
error = rman_manage_region(&sc->io_rman, | |||||
pci_base + PCI_IO_WINDOW_OFFSET, | |||||
pci_base + PCI_IO_WINDOW_OFFSET + size); | |||||
} else | |||||
continue; | |||||
if (error) { | |||||
device_printf(dev, "rman_manage_region() failed." | |||||
"error = %d\n", error); | |||||
rman_fini(&sc->mem_rman); | |||||
return (error); | |||||
} | |||||
} | |||||
/* TODO: get IRQ numbers from FDT */ | |||||
sc->irq_rman.rm_type = RMAN_ARRAY; | |||||
sc->irq_rman.rm_descr = "Generic PCIe IRQs"; | |||||
if (rman_init(&sc->irq_rman) != 0 || | |||||
rman_manage_region(&sc->irq_rman, PCI_IRQ_START, | |||||
PCI_IRQ_END) != 0) { | |||||
panic("Generic PCI: failed to set up IRQ rman"); | |||||
} | |||||
device_add_child(dev, "pci", -1); | |||||
return (bus_generic_attach(dev)); | |||||
} | |||||
static int | |||||
parse_pci_mem_ranges(struct generic_pcie_softc *sc) | |||||
{ | |||||
pcell_t pci_addr_cells, parent_addr_cells, size_cells; | |||||
pcell_t *ranges_buf, *cell_ptr; | |||||
int cells_count, tuples_count; | |||||
pcell_t attributes; | |||||
phandle_t node; | |||||
int tuple; | |||||
int rv; | |||||
node = ofw_bus_get_node(sc->dev); | |||||
if (fdt_addrsize_cells(node, &pci_addr_cells, &size_cells)) | |||||
return (ENXIO); | |||||
andrew: Don't use fdt_* functions, just use `OF_getencprop` here and fail if the address or size is… | |||||
parent_addr_cells = fdt_parent_addr_cells(node); | |||||
if (parent_addr_cells != 2 || pci_addr_cells != 3 || size_cells != 2) { | |||||
Done Inline ActionsUse OF_getencprop(OF_parent(node) for this andrew: Use `OF_getencprop(OF_parent(node)` for this | |||||
device_printf(sc->dev, | |||||
"Unexpected number of address or size cells in FDT\n"); | |||||
return (ENXIO); | |||||
} | |||||
cells_count = OF_getprop_alloc(node, "ranges", | |||||
sizeof(pcell_t), (void **)&ranges_buf); | |||||
if (cells_count == -1) { | |||||
device_printf(sc->dev, "Error parsing FDT 'ranges' property\n"); | |||||
return (ENXIO); | |||||
} | |||||
tuples_count = cells_count / | |||||
(pci_addr_cells + parent_addr_cells + size_cells); | |||||
if (tuples_count > MAX_RANGES_TUPLES || tuples_count < MIN_RANGES_TUPLES) { | |||||
device_printf(sc->dev, | |||||
"Unexpected number of 'ranges' tuples in FDT\n"); | |||||
rv = ENXIO; | |||||
goto out; | |||||
} | |||||
cell_ptr = ranges_buf; | |||||
for (tuple = 0; tuple < tuples_count; tuple++) { | |||||
attributes = fdt_data_get((void *)cell_ptr, PROPS_CELL_SIZE); | |||||
attributes = (attributes >> SPACE_CODE_SHIFT) & SPACE_CODE_MASK; | |||||
if (attributes == SPACE_CODE_IO_SPACE) { | |||||
sc->ranges[tuple].flags |= FLAG_IO; | |||||
} else { | |||||
sc->ranges[tuple].flags |= FLAG_MEM; | |||||
} | |||||
cell_ptr += PROPS_CELL_SIZE; /* move ptr to pci addr */ | |||||
sc->ranges[tuple].pci_base = fdt_data_get((void *)cell_ptr, 2); | |||||
cell_ptr += PCI_ADDR_CELL_SIZE; /* move ptr to cpu addr */ | |||||
sc->ranges[tuple].phys_base = fdt_data_get((void *)cell_ptr, 2); | |||||
cell_ptr += parent_addr_cells; /* move ptr to size cells*/ | |||||
sc->ranges[tuple].size = fdt_data_get((void *)cell_ptr, 2); | |||||
cell_ptr += size_cells; /* move ptr to next tuple*/ | |||||
if (bootverbose) { | |||||
device_printf(sc->dev, | |||||
"\tPCI addr: 0x%jx, CPU addr: 0x%jx, Size: 0x%jx\n", | |||||
sc->ranges[tuple].pci_base, | |||||
sc->ranges[tuple].phys_base, | |||||
sc->ranges[tuple].size); | |||||
} | |||||
} | |||||
for (; tuple < MAX_RANGES_TUPLES; tuple++) { | |||||
/* zero-fill remaining tuples to mark empty elements in array */ | |||||
sc->ranges[tuple].phys_base = 0; | |||||
sc->ranges[tuple].size = 0; | |||||
} | |||||
rv = 0; | |||||
out: | |||||
free(ranges_buf, M_OFWPROP); | |||||
return (rv); | |||||
} | |||||
static uint32_t | |||||
generic_pcie_read_config(device_t dev, u_int bus, u_int slot, | |||||
u_int func, u_int reg, int bytes) | |||||
{ | |||||
struct generic_pcie_softc *sc; | |||||
bus_space_handle_t h; | |||||
bus_space_tag_t t; | |||||
uint64_t offset; | |||||
uint32_t data; | |||||
if (bus > 255 || slot > 31 || func > 7 || reg > 4095) | |||||
return (~0U); | |||||
sc = device_get_softc(dev); | |||||
offset = PCIE_ADDR_OFFSET(bus, slot, func, reg); | |||||
t = sc->bst; | |||||
h = sc->bsh; | |||||
switch (bytes) { | |||||
case 1: | |||||
data = bus_space_read_1(t, h, offset); | |||||
break; | |||||
case 2: | |||||
data = le16toh(bus_space_read_2(t, h, offset)); | |||||
break; | |||||
case 4: | |||||
data = le32toh(bus_space_read_4(t, h, offset)); | |||||
break; | |||||
default: | |||||
return (~0U); | |||||
} | |||||
if (reg == PCIR_INTLINE) { | |||||
data += PCI_IRQ_START; | |||||
} | |||||
return (data); | |||||
} | |||||
static void | |||||
generic_pcie_write_config(device_t dev, u_int bus, u_int slot, | |||||
u_int func, u_int reg, uint32_t val, int bytes) | |||||
{ | |||||
struct generic_pcie_softc *sc; | |||||
bus_space_handle_t h; | |||||
bus_space_tag_t t; | |||||
uint64_t offset; | |||||
if (bus > 255 || slot > 31 || func > 7 || reg > 4095) | |||||
return; | |||||
sc = device_get_softc(dev); | |||||
offset = PCIE_ADDR_OFFSET(bus, slot, func, reg); | |||||
t = sc->bst; | |||||
h = sc->bsh; | |||||
switch (bytes) { | |||||
case 1: | |||||
bus_space_write_1(t, h, offset, val); | |||||
break; | |||||
case 2: | |||||
bus_space_write_2(t, h, offset, htole16(val)); | |||||
break; | |||||
case 4: | |||||
bus_space_write_4(t, h, offset, htole32(val)); | |||||
break; | |||||
default: | |||||
return; | |||||
} | |||||
} | |||||
static int | |||||
generic_pcie_maxslots(device_t dev) | |||||
{ | |||||
return (31); /* max slots per bus acc. to standard */ | |||||
} | |||||
static int | |||||
generic_pcie_read_ivar(device_t dev, device_t child, int index, | |||||
uintptr_t *result) | |||||
{ | |||||
struct generic_pcie_softc *sc; | |||||
int secondary_bus; | |||||
sc = device_get_softc(dev); | |||||
if (index == PCIB_IVAR_BUS) { | |||||
/* this pcib adds only pci bus 0 as child */ | |||||
secondary_bus = 0; | |||||
*result = secondary_bus; | |||||
return (0); | |||||
} | |||||
if (index == PCIB_IVAR_DOMAIN) { | |||||
*result = sc->ecam; | |||||
return (0); | |||||
} | |||||
device_printf(dev, "ERROR: Unknown index.\n"); | |||||
return (ENOENT); | |||||
} | |||||
static int | |||||
generic_pcie_write_ivar(device_t dev, device_t child, int index, | |||||
uintptr_t value) | |||||
{ | |||||
return (ENOENT); | |||||
} | |||||
static struct rman * | |||||
generic_pcie_rman(struct generic_pcie_softc *sc, int type) | |||||
{ | |||||
switch (type) { | |||||
case SYS_RES_IOPORT: | |||||
return (&sc->io_rman); | |||||
case SYS_RES_MEMORY: | |||||
return (&sc->mem_rman); | |||||
case SYS_RES_IRQ: | |||||
return (&sc->irq_rman); | |||||
default: | |||||
Done Inline ActionsThis doesn't seem right. The alloc_resource routine uses a local rman for memory, I/O, and IRQs. You should be using rman_release_resource() for all all of those. Ideally you would have a helper routine: static struct rman * generic_pcie_rman(int type) { switch (type) { case SYS_RES_IOPORT: return (&sc->io_rman); .... } And then in release_resource do something like: struct rman *rm; rm = generic_pcie_rman(type); if (rm != NULL) { KASSERT(rman_is_region_manager(res, rm), ("rman mismatch")); rman_release_resource(res); } return (bus_generic_release_resource(dev, child, type, rid, res)); (I prefer using bus_generic_* over BUS_* directly) You can then use the rman lookup routine in alloc_resource as well. jhb: This doesn't seem right. The alloc_resource routine uses a local rman for memory, I/O, and… | |||||
break; | |||||
} | |||||
return (NULL); | |||||
} | |||||
static int | |||||
generic_pcie_release_resource(device_t dev, device_t child, int type, | |||||
int rid, struct resource *res) | |||||
{ | |||||
struct generic_pcie_softc *sc; | |||||
struct rman *rm; | |||||
sc = device_get_softc(dev); | |||||
rm = generic_pcie_rman(sc, type); | |||||
if (rm != NULL) { | |||||
KASSERT(rman_is_region_manager(res, rm), ("rman mismatch")); | |||||
rman_release_resource(res); | |||||
} | |||||
return (bus_generic_release_resource(dev, child, type, rid, res)); | |||||
} | |||||
static struct resource * | |||||
generic_pcie_alloc_resource(device_t dev, device_t child, int type, int *rid, | |||||
u_long start, u_long end, u_long count, u_int flags) | |||||
{ | |||||
struct generic_pcie_softc *sc; | |||||
struct resource *res; | |||||
struct rman *rm; | |||||
sc = device_get_softc(dev); | |||||
rm = generic_pcie_rman(sc, type); | |||||
if (rm == NULL) | |||||
return (BUS_ALLOC_RESOURCE(device_get_parent(dev), dev, | |||||
type, rid, start, end, count, flags)); | |||||
if (bootverbose) { | |||||
device_printf(dev, | |||||
"rman_reserve_resource: start=%#lx, end=%#lx, count=%#lx\n", | |||||
start, end, count); | |||||
Done Inline ActionsPlease only set bustag/bushandle in activate_resource(). It needs to work that way for NEW_PCIB. Also, I would add an adjust_resource method. It can be fairly short: adjust_resource(...) { rm = generic_pcie_rman(rman_get_type(res)); if (rm != NULL) return (rman_adjust_resource(res, ...)); return (bus_generic_adjust_resource(...)); } jhb: Please only set bustag/bushandle in activate_resource(). It needs to work that way for… | |||||
} | |||||
res = rman_reserve_resource(rm, start, end, count, flags, child); | |||||
if (res == NULL) | |||||
goto fail; | |||||
rman_set_rid(res, *rid); | |||||
if (flags & RF_ACTIVE) | |||||
if (bus_activate_resource(child, type, *rid, res)) { | |||||
rman_release_resource(res); | |||||
goto fail; | |||||
} | |||||
return (res); | |||||
fail: | |||||
if (bootverbose) { | |||||
device_printf(dev, "%s FAIL: type=%d, rid=%d, " | |||||
"start=%016lx, end=%016lx, count=%016lx, flags=%x\n", | |||||
__func__, type, *rid, start, end, count, flags); | |||||
} | |||||
return (NULL); | |||||
} | |||||
static int | |||||
generic_pcie_adjust_resource(device_t dev, device_t child, int type, | |||||
struct resource *res, u_long start, u_long end) | |||||
{ | |||||
struct generic_pcie_softc *sc; | |||||
struct rman *rm; | |||||
sc = device_get_softc(dev); | |||||
rm = generic_pcie_rman(sc, type); | |||||
if (rm != NULL) | |||||
return (rman_adjust_resource(res, start, end)); | |||||
return (bus_generic_adjust_resource(dev, child, type, res, start, end)); | |||||
} | |||||
static int | |||||
generic_pcie_activate_resource(device_t dev, device_t child, int type, int rid, | |||||
struct resource *r) | |||||
{ | |||||
struct generic_pcie_softc *sc; | |||||
uint64_t phys_base; | |||||
uint64_t pci_base; | |||||
vm_offset_t vaddr; | |||||
uint64_t size; | |||||
int found; | |||||
int res; | |||||
int i; | |||||
sc = device_get_softc(dev); | |||||
if ((res = rman_activate_resource(r)) != 0) | |||||
return (res); | |||||
switch(type) { | |||||
Done Inline ActionsIf you want a parent device to set the bus tag/handle for memory, then this probably warrants Regardless I think you to assert that resources all use a local rman (similar to the KASSERT I suggested for release). You should also be using the rman methods to activate/deactivate on SYS_RES_IRQ. Also, I don't see a deactivate resource method. It should undo the effects of activate (deactivate in rman, etc.). Also, in general in activate routines you should to the rman activate first since that checks for !RF_SHAREABLE violations, etc. and only do MD work like pmap_mapdev if rman_activate_resource succeeds. jhb: If you want a parent device to set the bus tag/handle for memory, then this probably warrants
a… | |||||
case SYS_RES_IOPORT: | |||||
found = 0; | |||||
for (i = 0; i < MAX_RANGES_TUPLES; i++) { | |||||
pci_base = sc->ranges[i].pci_base; | |||||
phys_base = sc->ranges[i].phys_base; | |||||
size = sc->ranges[i].size; | |||||
if ((rid > pci_base) && (rid < (pci_base + size))) { | |||||
found = 1; | |||||
break; | |||||
} | |||||
} | |||||
if (found) { | |||||
vaddr = (vm_offset_t)pmap_mapdev(rman_get_start(r) + \ | |||||
Done Inline ActionsI would just use bus_generic_setup_intr() and bus_generic_teardown_intr() directly in the DEVMETHODS table and remove these. jhb: I would just use bus_generic_setup_intr() and bus_generic_teardown_intr() directly in the… | |||||
phys_base, rman_get_size(r)); | |||||
rman_set_virtual(r, (void *)vaddr); | |||||
rman_set_bustag(r, fdtbus_bs_tag); | |||||
rman_set_bushandle(r, vaddr); | |||||
} else { | |||||
Done Inline ActionsThis doesn't look correct, shouldn't it call into the parent for this? andrew: This doesn't look correct, shouldn't it call into the parent for this? | |||||
Done Inline ActionsQuite possibly (I'll defer to you on this one). You will need to ensure the parent has a proper activate_resource method. (Most of sys/arm does not, but I haven't looked at arm64's nexus.) jhb: Quite possibly (I'll defer to you on this one). You will need to ensure the parent has a… | |||||
Done Inline ActionsIf not it should be fixed. andrew: If not it should be fixed. | |||||
device_printf(dev, "Failed to activate IOPORT resource\n"); | |||||
Not Done Inline Actionsfixed br: fixed | |||||
res = 0; | |||||
} | |||||
break; | |||||
case SYS_RES_MEMORY: | |||||
vaddr = (vm_offset_t)pmap_mapdev(rman_get_start(r), rman_get_size(r)); | |||||
rman_set_virtual(r, (void *)vaddr); | |||||
rman_set_bustag(r, fdtbus_bs_tag); | |||||
rman_set_bushandle(r, vaddr); | |||||
break; | |||||
default: | |||||
break; | |||||
} | |||||
return (res); | |||||
} | |||||
static int | |||||
generic_pcie_deactivate_resource(device_t dev, device_t child, int type, int rid, | |||||
struct resource *r) | |||||
Done Inline ActionsThis doesn't appear to actually do anything? jhb: This doesn't appear to actually do anything? | |||||
{ | |||||
struct generic_pcie_softc *sc; | |||||
vm_offset_t vaddr; | |||||
sc = device_get_softc(dev); | |||||
switch(type) { | |||||
case SYS_RES_IOPORT: | |||||
case SYS_RES_MEMORY: | |||||
vaddr = (vm_offset_t)rman_get_virtual(r); | |||||
pmap_unmapdev(vaddr, rman_get_size(r)); | |||||
break; | |||||
default: | |||||
break; | |||||
} | |||||
return (rman_deactivate_resource(r)); | |||||
jhbUnsubmitted Done Inline ActionsMy only suggestion here would be to do rman_deactivate_resource() first. It will fail if the resource isn't actually active so you won't risk calling pmap_unmapdev() on an invalid value (i.e. if someone allocates a resource without RF_ACTIVE and then calls bus_deactivate_resource() directly. This is a bug in their driver certainly, but it is good to handle that regardless.) jhb: My only suggestion here would be to do rman_deactivate_resource() first. It will fail if the… | |||||
} | |||||
static int | |||||
generic_pcie_map_msi(device_t pcib, device_t child, int irq, | |||||
uint64_t *addr, uint32_t *data) | |||||
{ | |||||
int error; | |||||
error = arm_map_msix(child, irq, addr, data); | |||||
return (error); | |||||
} | |||||
static int | |||||
generic_pcie_alloc_msix(device_t pcib, device_t child, int *irq) | |||||
Done Inline ActionsThis should be calling into the parent for this. The nexus driver should be fixed to handle this method. andrew: This should be calling into the parent for this. The nexus driver should be fixed to handle… | |||||
{ | |||||
Not Done Inline Actionsok fixed br: ok fixed | |||||
int error; | |||||
error = arm_alloc_msix(child, irq); | |||||
return (error); | |||||
} | |||||
static int | |||||
generic_pcie_release_msix(device_t pcib, device_t child, int irq) | |||||
Done Inline ActionsAnd here, and below. andrew: And here, and below. | |||||
{ | |||||
int error; | |||||
error = arm_release_msix(child, irq); | |||||
return (error); | |||||
} | |||||
static int | |||||
generic_pcie_alloc_msi(device_t pcib, device_t child, int count, int maxcount, | |||||
int *irqs) | |||||
{ | |||||
int error; | |||||
error = arm_alloc_msi(child, count, irqs); | |||||
return (error); | |||||
} | |||||
static int | |||||
generic_pcie_release_msi(device_t pcib, device_t child, int count, int *irqs) | |||||
{ | |||||
int error; | |||||
error = arm_release_msi(child, count, irqs); | |||||
return (error); | |||||
} | |||||
static device_method_t generic_pcie_methods[] = { | |||||
DEVMETHOD(device_probe, generic_pcie_probe), | |||||
DEVMETHOD(device_attach, generic_pcie_attach), | |||||
DEVMETHOD(pcib_maxslots, generic_pcie_maxslots), | |||||
DEVMETHOD(pcib_read_config, generic_pcie_read_config), | |||||
DEVMETHOD(pcib_write_config, generic_pcie_write_config), | |||||
DEVMETHOD(bus_read_ivar, generic_pcie_read_ivar), | |||||
DEVMETHOD(bus_write_ivar, generic_pcie_write_ivar), | |||||
DEVMETHOD(bus_alloc_resource, generic_pcie_alloc_resource), | |||||
DEVMETHOD(bus_adjust_resource, generic_pcie_adjust_resource), | |||||
DEVMETHOD(bus_release_resource, generic_pcie_release_resource), | |||||
Done Inline ActionsCould you group these, e.g. device, then bus, then pcib. andrew: Could you group these, e.g. device, then bus, then pcib. | |||||
DEVMETHOD(bus_activate_resource, generic_pcie_activate_resource), | |||||
DEVMETHOD(bus_deactivate_resource, generic_pcie_deactivate_resource), | |||||
DEVMETHOD(bus_setup_intr, bus_generic_setup_intr), | |||||
DEVMETHOD(bus_teardown_intr, bus_generic_teardown_intr), | |||||
DEVMETHOD(pcib_map_msi, generic_pcie_map_msi), | |||||
DEVMETHOD(pcib_alloc_msix, generic_pcie_alloc_msix), | |||||
DEVMETHOD(pcib_release_msix, generic_pcie_release_msix), | |||||
DEVMETHOD(pcib_alloc_msi, generic_pcie_alloc_msi), | |||||
DEVMETHOD(pcib_release_msi, generic_pcie_release_msi), | |||||
DEVMETHOD_END | |||||
}; | |||||
static driver_t generic_pcie_driver = { | |||||
"pcib", | |||||
generic_pcie_methods, | |||||
sizeof(struct generic_pcie_softc), | |||||
}; | |||||
static devclass_t generic_pcie_devclass; | |||||
DRIVER_MODULE(pcib, simplebus, generic_pcie_driver, | |||||
generic_pcie_devclass, 0, 0); | |||||
DRIVER_MODULE(pcib, ofwbus, generic_pcie_driver, | |||||
generic_pcie_devclass, 0, 0); |
Don't use fdt_* functions, just use OF_getencprop here and fail if the address or size is missing.