Date: Tue, 24 May 2016 01:12:19 +0000 (UTC) From: Adrian Chadd <adrian@FreeBSD.org> To: src-committers@freebsd.org, svn-src-all@freebsd.org, svn-src-head@freebsd.org Subject: svn commit: r300548 - in head/sys: conf dev/bhnd dev/bhnd/bhndb dev/bhnd/cores/chipc dev/bhnd/nvram dev/bhnd/siba modules/bhnd modules/bhnd/cores/bhnd_chipc Message-ID: <201605240112.u4O1CJOt063645@repo.freebsd.org>
next in thread | raw e-mail | index | archive | help
Author: adrian Date: Tue May 24 01:12:19 2016 New Revision: 300548 URL: https://svnweb.freebsd.org/changeset/base/300548 Log: [bhnd] Implement pass-through resource management for ChipCommon. This patchset adds support to bhnd_chipc for sharing SYS_RES_MEMORY resources with its children, allowing us to hang devices off of bhnd_chipc that rely on access to a subset of the device register space that bhnd_chipc itself must also allocate. We could avoid most of this heavy lifting if RF_SHAREABLE+SYS_RES_MEMORY wasn't limited to use with allocations at the same size/offset. As a work-around, I implemented something similar to vga_pci.c, which implements similar reference counting of of PCI BAR resources for its children. With these changes, chipc will use reference counting of SYS_RES_MEMORY allocation/activation requests, to decide when to allocate/activate/ deactivate/release resources from the parent bhnd(4) bus. The requesting child device is allocated a new resource from chipc's rman, pointing to (possibly a subregion of) the refcounted bhnd resources allocated by chipc. Other resource types are just passed directly to the parent bhnd bus; RF_SHAREABLE works just fine with IRQs. I also lifted the SPROM device code out into a common driver, since this now allows me to hang simple subclasses off of a common driver off of both bhndb_pci and bhnd_chipc. Tested: * (landonf) Tested against BCM4331 and BCM4312, confirmed that SPROM still attaches and can be queried. Submitted by: Landon Fuller <landonf@landonf.org> Reviewed by: mizkha@gmail.com Differential Revision: https://reviews.freebsd.org/D6471 Added: head/sys/dev/bhnd/cores/chipc/bhnd_sprom_chipc.c (contents, props changed) head/sys/dev/bhnd/cores/chipc/chipc_private.h (contents, props changed) head/sys/dev/bhnd/cores/chipc/chipc_subr.c (contents, props changed) head/sys/dev/bhnd/nvram/bhnd_sprom_subr.c - copied, changed from r300546, head/sys/dev/bhnd/nvram/bhnd_sprom.c Modified: head/sys/conf/files head/sys/dev/bhnd/bhnd_subr.c head/sys/dev/bhnd/bhndb/bhndb_pci_sprom.c head/sys/dev/bhnd/cores/chipc/bhnd_chipc_if.m head/sys/dev/bhnd/cores/chipc/chipc.c head/sys/dev/bhnd/cores/chipc/chipc.h head/sys/dev/bhnd/cores/chipc/chipcreg.h head/sys/dev/bhnd/cores/chipc/chipcvar.h head/sys/dev/bhnd/nvram/bhnd_nvram.h head/sys/dev/bhnd/nvram/bhnd_sprom.c head/sys/dev/bhnd/nvram/bhnd_spromvar.h head/sys/dev/bhnd/siba/siba.c head/sys/dev/bhnd/siba/siba_subr.c head/sys/dev/bhnd/siba/sibavar.h head/sys/modules/bhnd/Makefile head/sys/modules/bhnd/cores/bhnd_chipc/Makefile Modified: head/sys/conf/files ============================================================================== --- head/sys/conf/files Tue May 24 00:57:11 2016 (r300547) +++ head/sys/conf/files Tue May 24 01:12:19 2016 (r300548) @@ -1139,7 +1139,9 @@ dev/bhnd/bcma/bcma_bhndb.c optional bhn dev/bhnd/bcma/bcma_erom.c optional bhndbus | bcma dev/bhnd/bcma/bcma_subr.c optional bhndbus | bcma dev/bhnd/cores/chipc/chipc.c optional bhndbus | bhnd +dev/bhnd/cores/chipc/chipc_subr.c optional bhndbus | bhnd dev/bhnd/cores/chipc/bhnd_chipc_if.m optional bhndbus | bhnd +dev/bhnd/cores/chipc/bhnd_sprom_chipc.c optional bhndbus | bhnd dev/bhnd/cores/pci/bhnd_pci.c optional bhndbus pci | bhnd pci dev/bhnd/cores/pci/bhnd_pci_hostb.c optional bhndbus pci | bhndb pci dev/bhnd/cores/pci/bhnd_pcib.c optional bhnd_pcib bhnd pci @@ -1148,6 +1150,7 @@ dev/bhnd/cores/pcie2/bhnd_pcie2_hostb.c dev/bhnd/cores/pcie2/bhnd_pcie2b.c optional bhnd_pcie2b bhnd pci dev/bhnd/nvram/bhnd_nvram_if.m optional bhndbus | bhnd dev/bhnd/nvram/bhnd_sprom.c optional bhndbus | bhnd +dev/bhnd/nvram/bhnd_sprom_subr.c optional bhndbus | bhnd dev/bhnd/nvram/nvram_subr.c optional bhndbus | bhnd dev/bhnd/siba/siba.c optional bhndbus | siba dev/bhnd/siba/siba_bhndb.c optional bhndbus | siba bhndb Modified: head/sys/dev/bhnd/bhnd_subr.c ============================================================================== --- head/sys/dev/bhnd/bhnd_subr.c Tue May 24 00:57:11 2016 (r300547) +++ head/sys/dev/bhnd/bhnd_subr.c Tue May 24 01:12:19 2016 (r300548) @@ -797,11 +797,11 @@ bhnd_parse_chipid(uint32_t idreg, bhnd_a struct bhnd_chipid result; /* Fetch the basic chip info */ - result.chip_id = CHIPC_GET_ATTR(idreg, ID_CHIP); - result.chip_pkg = CHIPC_GET_ATTR(idreg, ID_PKG); - result.chip_rev = CHIPC_GET_ATTR(idreg, ID_REV); - result.chip_type = CHIPC_GET_ATTR(idreg, ID_BUS); - result.ncores = CHIPC_GET_ATTR(idreg, ID_NUMCORE); + result.chip_id = CHIPC_GET_BITS(idreg, CHIPC_ID_CHIP); + result.chip_pkg = CHIPC_GET_BITS(idreg, CHIPC_ID_PKG); + result.chip_rev = CHIPC_GET_BITS(idreg, CHIPC_ID_REV); + result.chip_type = CHIPC_GET_BITS(idreg, CHIPC_ID_BUS); + result.ncores = CHIPC_GET_BITS(idreg, CHIPC_ID_NUMCORE); result.enum_addr = enum_addr; @@ -1020,15 +1020,11 @@ find_nvram_child(device_t dev) if (device_get_devclass(dev) != bhnd_devclass) return (NULL); - /* Look for a ChipCommon device */ + /* Look for a ChipCommon-attached NVRAM device */ if ((chipc = bhnd_find_child(dev, BHND_DEVCLASS_CC, -1)) != NULL) { - bhnd_nvram_src_t src; - - /* Query the NVRAM source and determine whether it's - * accessible via the ChipCommon device */ - src = BHND_CHIPC_NVRAM_SRC(chipc); - if (BHND_NVRAM_SRC_CC(src)) - return (chipc); + nvram = device_find_child(chipc, "bhnd_nvram", 0); + if (nvram != NULL) + return (nvram); } /* Not found */ Modified: head/sys/dev/bhnd/bhndb/bhndb_pci_sprom.c ============================================================================== --- head/sys/dev/bhnd/bhndb/bhndb_pci_sprom.c Tue May 24 00:57:11 2016 (r300547) +++ head/sys/dev/bhnd/bhndb/bhndb_pci_sprom.c Tue May 24 01:12:19 2016 (r300548) @@ -53,29 +53,15 @@ __FBSDID("$FreeBSD$"); #include <dev/bhnd/nvram/bhnd_spromvar.h> #include "bhnd_nvram_if.h" + #include "bhndb_pcireg.h" #include "bhndb_pcivar.h" -struct bhndb_pci_sprom_softc { - device_t dev; - struct bhnd_resource *sprom_res; /**< SPROM resource */ - int sprom_rid; /**< SPROM RID */ - struct bhnd_sprom shadow; /**< SPROM shadow */ - struct mtx mtx; /**< SPROM shadow mutex */ -}; - -#define SPROM_LOCK_INIT(sc) \ - mtx_init(&(sc)->mtx, device_get_nameunit((sc)->dev), \ - "BHND PCI SPROM lock", MTX_DEF) -#define SPROM_LOCK(sc) mtx_lock(&(sc)->mtx) -#define SPROM_UNLOCK(sc) mtx_unlock(&(sc)->mtx) -#define SPROM_LOCK_ASSERT(sc, what) mtx_assert(&(sc)->mtx, what) -#define SPROM_LOCK_DESTROY(sc) mtx_destroy(&(sc)->mtx) - static int bhndb_pci_sprom_probe(device_t dev) { device_t bridge, bus; + int error; /* Our parent must be a PCI-BHND bridge with an attached bhnd bus */ bridge = device_get_parent(dev); @@ -86,125 +72,23 @@ bhndb_pci_sprom_probe(device_t dev) if (bus == NULL) return (ENXIO); - /* Found */ - device_set_desc(dev, "PCI-BHNDB SPROM/OTP"); - if (!bootverbose) - device_quiet(dev); + /* Defer to default driver implementation */ + if ((error = bhnd_sprom_probe(dev)) > 0) + return (error); - /* Refuse wildcard attachments */ return (BUS_PROBE_NOWILDCARD); } -static int -bhndb_pci_sprom_attach(device_t dev) -{ - struct bhndb_pci_sprom_softc *sc; - int error; - - sc = device_get_softc(dev); - sc->dev = dev; - - /* Allocate SPROM resource */ - sc->sprom_rid = 0; - sc->sprom_res = bhnd_alloc_resource_any(dev, SYS_RES_MEMORY, - &sc->sprom_rid, RF_ACTIVE); - if (sc->sprom_res == NULL) { - device_printf(dev, "failed to allocate resources\n"); - return (ENXIO); - } - - /* Initialize SPROM shadow */ - if ((error = bhnd_sprom_init(&sc->shadow, sc->sprom_res, 0))) { - device_printf(dev, "unrecognized SPROM format\n"); - goto failed; - } - - /* Initialize mutex */ - SPROM_LOCK_INIT(sc); - - return (0); - -failed: - bhnd_release_resource(dev, SYS_RES_MEMORY, sc->sprom_rid, - sc->sprom_res); - return (error); -} - -static int -bhndb_pci_sprom_resume(device_t dev) -{ - return (0); -} - -static int -bhndb_pci_sprom_suspend(device_t dev) -{ - return (0); -} - -static int -bhndb_pci_sprom_detach(device_t dev) -{ - struct bhndb_pci_sprom_softc *sc; - - sc = device_get_softc(dev); - - bhnd_release_resource(dev, SYS_RES_MEMORY, sc->sprom_rid, - sc->sprom_res); - bhnd_sprom_fini(&sc->shadow); - SPROM_LOCK_DESTROY(sc); - - return (0); -} - -static int -bhndb_pci_sprom_getvar(device_t dev, const char *name, void *buf, size_t *len) -{ - struct bhndb_pci_sprom_softc *sc; - int error; - - sc = device_get_softc(dev); - - SPROM_LOCK(sc); - error = bhnd_sprom_getvar(&sc->shadow, name, buf, len); - SPROM_UNLOCK(sc); - - return (error); -} - -static int -bhndb_pci_sprom_setvar(device_t dev, const char *name, const void *buf, - size_t len) -{ - struct bhndb_pci_sprom_softc *sc; - int error; - - sc = device_get_softc(dev); - - SPROM_LOCK(sc); - error = bhnd_sprom_setvar(&sc->shadow, name, buf, len); - SPROM_UNLOCK(sc); - - return (error); -} static device_method_t bhndb_pci_sprom_methods[] = { /* Device interface */ DEVMETHOD(device_probe, bhndb_pci_sprom_probe), - DEVMETHOD(device_attach, bhndb_pci_sprom_attach), - DEVMETHOD(device_resume, bhndb_pci_sprom_resume), - DEVMETHOD(device_suspend, bhndb_pci_sprom_suspend), - DEVMETHOD(device_detach, bhndb_pci_sprom_detach), - - /* NVRAM interface */ - DEVMETHOD(bhnd_nvram_getvar, bhndb_pci_sprom_getvar), - DEVMETHOD(bhnd_nvram_setvar, bhndb_pci_sprom_setvar), - DEVMETHOD_END }; -DEFINE_CLASS_0(bhnd_nvram, bhndb_pci_sprom_driver, bhndb_pci_sprom_methods, sizeof(struct bhndb_pci_sprom_softc)); +DEFINE_CLASS_1(bhnd_nvram, bhndb_pci_sprom_driver, bhndb_pci_sprom_methods, sizeof(struct bhnd_sprom_softc), bhnd_sprom_driver); DRIVER_MODULE(bhndb_pci_sprom, bhndb, bhndb_pci_sprom_driver, bhnd_nvram_devclass, NULL, NULL); MODULE_DEPEND(bhndb_pci_sprom, bhnd, 1, 1, 1); +MODULE_DEPEND(bhndb_pci_sprom, bhnd_sprom, 1, 1, 1); MODULE_VERSION(bhndb_pci_sprom, 1); Modified: head/sys/dev/bhnd/cores/chipc/bhnd_chipc_if.m ============================================================================== --- head/sys/dev/bhnd/cores/chipc/bhnd_chipc_if.m Tue May 24 00:57:11 2016 (r300547) +++ head/sys/dev/bhnd/cores/chipc/bhnd_chipc_if.m Tue May 24 01:12:19 2016 (r300548) @@ -36,6 +36,11 @@ INTERFACE bhnd_chipc; # bhnd(4) ChipCommon interface. # +HEADER { + /* forward declarations */ + struct chipc_caps; +} + /** * Return the preferred NVRAM data source. * @@ -63,3 +68,35 @@ METHOD void write_chipctrl { uint32_t value; uint32_t mask; } + +/** + * Return a borrowed reference to ChipCommon's capability + * table. + * + * @param dev A bhnd(4) ChipCommon device + */ +METHOD struct chipc_caps * get_caps { + device_t dev; +} + +/** + * Enable hardware access to the SPROM. + * + * @param sc chipc driver state. + * + * @retval 0 success + * @retval EBUSY If enabling the hardware may conflict with + * other active devices. + */ +METHOD int enable_sprom { + device_t dev; +} + +/** + * Release hardware access to the SPROM. + * + * @param sc chipc driver state. + */ +METHOD void disable_sprom { + device_t dev; +} Added: head/sys/dev/bhnd/cores/chipc/bhnd_sprom_chipc.c ============================================================================== --- /dev/null 00:00:00 1970 (empty, because file is newly added) +++ head/sys/dev/bhnd/cores/chipc/bhnd_sprom_chipc.c Tue May 24 01:12:19 2016 (r300548) @@ -0,0 +1,101 @@ +/*- + * Copyright (c) 2015-2016 Landon Fuller <landon@landonf.org> + * All rights reserved. + * + * 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, + * without modification. + * 2. Redistributions in binary form must reproduce at minimum a disclaimer + * similar to the "NO WARRANTY" disclaimer below ("Disclaimer") and any + * redistribution must be conditioned upon including a substantially + * similar Disclaimer requirement for further binary redistribution. + * + * NO WARRANTY + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF NONINFRINGEMENT, MERCHANTIBILITY + * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL + * THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR 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 DAMAGES. + */ + +#include <sys/cdefs.h> +__FBSDID("$FreeBSD$"); + +/* + * ChipCommon SPROM driver. + */ + +#include <sys/param.h> +#include <sys/kernel.h> +#include <sys/bus.h> +#include <sys/limits.h> +#include <sys/malloc.h> +#include <sys/module.h> +#include <sys/systm.h> + +#include <dev/bhnd/bhnd.h> +#include <dev/bhnd/nvram/bhnd_nvram.h> +#include <dev/bhnd/nvram/bhnd_spromvar.h> + +#include "bhnd_chipc_if.h" +#include "bhnd_nvram_if.h" + +static int +chipc_sprom_probe(device_t dev) +{ + device_t chipc; + int error; + + chipc = device_get_parent(dev); + + /* Only match on SPROM devices */ + if (BHND_CHIPC_NVRAM_SRC(chipc) != BHND_NVRAM_SRC_SPROM) + return (ENXIO); + + /* Defer to default driver implementation */ + if ((error = bhnd_sprom_probe(dev)) > 0) + return (error); + + return (BUS_PROBE_NOWILDCARD); +} + +static int +chipc_sprom_attach(device_t dev) +{ + device_t chipc; + int error; + + /* Request that ChipCommon enable access to SPROM hardware before + * delegating attachment (and SPROM parsing) to the common driver */ + chipc = device_get_parent(dev); + if ((error = BHND_CHIPC_ENABLE_SPROM(chipc))) + return (error); + + error = bhnd_sprom_attach(dev); + BHND_CHIPC_DISABLE_SPROM(chipc); + return (error); +} + +static device_method_t chipc_sprom_methods[] = { + /* Device interface */ + DEVMETHOD(device_probe, chipc_sprom_probe), + DEVMETHOD(device_attach, chipc_sprom_attach), + DEVMETHOD_END +}; + +DEFINE_CLASS_1(bhnd_nvram, chipc_sprom_driver, chipc_sprom_methods, sizeof(struct bhnd_sprom_softc), bhnd_sprom_driver); +DRIVER_MODULE(bhnd_chipc_sprom, bhnd_chipc, chipc_sprom_driver, bhnd_nvram_devclass, NULL, NULL); + +MODULE_DEPEND(bhnd_chipc_sprom, bhnd, 1, 1, 1); +MODULE_DEPEND(bhnd_chipc_sprom, bhnd_chipc, 1, 1, 1); +MODULE_DEPEND(bhnd_chipc_sprom, bhnd_sprom, 1, 1, 1); +MODULE_VERSION(bhnd_chipc_sprom, 1); Modified: head/sys/dev/bhnd/cores/chipc/chipc.c ============================================================================== --- head/sys/dev/bhnd/cores/chipc/chipc.c Tue May 24 00:57:11 2016 (r300547) +++ head/sys/dev/bhnd/cores/chipc/chipc.c Tue May 24 01:12:19 2016 (r300548) @@ -1,5 +1,6 @@ /*- - * Copyright (c) 2015 Landon Fuller <landon@landonf.org> + * Copyright (c) 2015-2016 Landon Fuller <landon@landonf.org> + * Copyright (c) 2016 Michael Zhilin <mizhka@gmail.com> * All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -42,8 +43,11 @@ __FBSDID("$FreeBSD$"); #include <sys/param.h> #include <sys/kernel.h> +#include <sys/lock.h> #include <sys/bus.h> +#include <sys/malloc.h> #include <sys/module.h> +#include <sys/mutex.h> #include <sys/systm.h> #include <machine/bus.h> @@ -51,19 +55,14 @@ __FBSDID("$FreeBSD$"); #include <machine/resource.h> #include <dev/bhnd/bhnd.h> - -#include "bhnd_nvram_if.h" +#include <dev/bhnd/bhndvar.h> #include "chipcreg.h" #include "chipcvar.h" +#include "chipc_private.h" devclass_t bhnd_chipc_devclass; /**< bhnd(4) chipcommon device class */ -static const struct resource_spec chipc_rspec[CHIPC_MAX_RSPEC] = { - { SYS_RES_MEMORY, 0, RF_ACTIVE }, - { -1, -1, 0 } -}; - static struct bhnd_device_quirk chipc_quirks[]; static struct bhnd_chip_quirk chipc_chip_quirks[]; @@ -77,7 +76,10 @@ static const struct bhnd_device chipc_de /* Device quirks table */ static struct bhnd_device_quirk chipc_quirks[] = { { BHND_HWREV_GTE (32), CHIPC_QUIRK_SUPPORTS_SPROM }, - { BHND_HWREV_GTE (35), CHIPC_QUIRK_SUPPORTS_NFLASH }, + { BHND_HWREV_GTE (35), CHIPC_QUIRK_SUPPORTS_CAP_EXT }, + { BHND_HWREV_EQ (38), CHIPC_QUIRK_4706_NFLASH }, /*BCM5357 ?*/ + { BHND_HWREV_GTE (49), CHIPC_QUIRK_IPX_OTPLAYOUT_SIZE }, + BHND_DEVICE_QUIRK_END }; @@ -111,15 +113,37 @@ static struct bhnd_chip_quirk chipc_chip {{ BHND_CHIP_IR(43602, HWREV_LTE(2)) }, CHIPC_QUIRK_4360_FEM_MUX_SPROM }, + /* BCM4706 */ + {{ BHND_CHIP_ID(4306) }, + CHIPC_QUIRK_4706_NFLASH }, + BHND_CHIP_QUIRK_END }; +static int chipc_try_activate_resource( + struct chipc_softc *sc, device_t child, + int type, int rid, struct resource *r, + bool req_direct); + +static int chipc_read_caps(struct chipc_softc *sc, + struct chipc_caps *caps); + +static int chipc_nvram_attach(struct chipc_softc *sc); +static bhnd_nvram_src_t chipc_nvram_identify(struct chipc_softc *sc); +static bool chipc_should_enable_sprom( + struct chipc_softc *sc); + +static int chipc_init_rman(struct chipc_softc *sc); +static void chipc_free_rman(struct chipc_softc *sc); +static struct rman *chipc_get_rman(struct chipc_softc *sc, + int type); + /* quirk and capability flag convenience macros */ #define CHIPC_QUIRK(_sc, _name) \ ((_sc)->quirks & CHIPC_QUIRK_ ## _name) #define CHIPC_CAP(_sc, _name) \ - ((_sc)->caps & CHIPC_ ## _name) + ((_sc)->caps._name) #define CHIPC_ASSERT_QUIRK(_sc, name) \ KASSERT(CHIPC_QUIRK((_sc), name), ("quirk " __STRING(_name) " not set")) @@ -127,12 +151,6 @@ static struct bhnd_chip_quirk chipc_chip #define CHIPC_ASSERT_CAP(_sc, name) \ KASSERT(CHIPC_CAP((_sc), name), ("capability " __STRING(_name) " not set")) -static bhnd_nvram_src_t chipc_nvram_identify(struct chipc_softc *sc); -static int chipc_sprom_init(struct chipc_softc *); -static int chipc_enable_sprom_pins(struct chipc_softc *); -static int chipc_disable_sprom_pins(struct chipc_softc *); - - static int chipc_probe(device_t dev) { @@ -159,19 +177,36 @@ chipc_attach(device_t dev) sc->dev = dev; sc->quirks = bhnd_device_quirks(dev, chipc_devices, sizeof(chipc_devices[0])); - + sc->sprom_refcnt = 0; + CHIPC_LOCK_INIT(sc); + STAILQ_INIT(&sc->mem_regions); - /* Allocate bus resources */ - memcpy(sc->rspec, chipc_rspec, sizeof(sc->rspec)); - if ((error = bhnd_alloc_resources(dev, sc->rspec, sc->res))) - return (error); + /* Set up resource management */ + if ((error = chipc_init_rman(sc))) { + device_printf(sc->dev, + "failed to initialize chipc resource state: %d\n", error); + goto failed; + } + + /* Allocate the region containing our core registers */ + if ((sc->core_region = chipc_find_region_by_rid(sc, 0)) == NULL) { + error = ENXIO; + goto failed; + } + + error = chipc_retain_region(sc, sc->core_region, + RF_ALLOCATED|RF_ACTIVE); + if (error) { + sc->core_region = NULL; + goto failed; + } else { + sc->core = sc->core_region->cr_res; + } - sc->core = sc->res[0]; - /* Fetch our chipset identification data */ ccid_reg = bhnd_bus_read_4(sc->core, CHIPC_ID); - chip_type = CHIPC_GET_ATTR(ccid_reg, ID_BUS); + chip_type = CHIPC_GET_BITS(ccid_reg, CHIPC_ID_BUS); switch (chip_type) { case BHND_CHIPTYPE_SIBA: @@ -185,44 +220,36 @@ chipc_attach(device_t dev) default: device_printf(dev, "unsupported chip type %hhu\n", chip_type); error = ENODEV; - goto cleanup; + goto failed; } sc->ccid = bhnd_parse_chipid(ccid_reg, enum_addr); - /* Fetch capability and status register values */ - sc->caps = bhnd_bus_read_4(sc->core, CHIPC_CAPABILITIES); - sc->cst = bhnd_bus_read_4(sc->core, CHIPC_CHIPST); - - /* Identify NVRAM source */ - sc->nvram_src = chipc_nvram_identify(sc); - - /* Read NVRAM data */ - switch (sc->nvram_src) { - case BHND_NVRAM_SRC_OTP: - // TODO (requires access to OTP hardware) - device_printf(sc->dev, "NVRAM-OTP unsupported\n"); - break; + /* Fetch and parse capability register(s) */ + if ((error = chipc_read_caps(sc, &sc->caps))) + goto failed; - case BHND_NVRAM_SRC_NFLASH: - // TODO (requires access to NFLASH hardware) - device_printf(sc->dev, "NVRAM-NFLASH unsupported\n"); - break; + if (bootverbose) + chipc_print_caps(sc->dev, &sc->caps); - case BHND_NVRAM_SRC_SPROM: - if ((error = chipc_sprom_init(sc))) - goto cleanup; - break; + /* Identify NVRAM source and add child device. */ + sc->nvram_src = chipc_nvram_identify(sc); + if ((error = chipc_nvram_attach(sc))) + goto failed; - case BHND_NVRAM_SRC_UNKNOWN: - /* Handled externally */ - break; - } + /* Standard bus probe */ + if ((error = bus_generic_attach(dev))) + goto failed; return (0); -cleanup: - bhnd_release_resources(dev, sc->rspec, sc->res); +failed: + if (sc->core_region != NULL) { + chipc_release_region(sc, sc->core_region, + RF_ALLOCATED|RF_ACTIVE); + } + + chipc_free_rman(sc); CHIPC_LOCK_DESTROY(sc); return (error); } @@ -231,9 +258,15 @@ static int chipc_detach(device_t dev) { struct chipc_softc *sc; + int error; sc = device_get_softc(dev); - bhnd_release_resources(dev, sc->rspec, sc->res); + + if ((error = bus_generic_detach(dev))) + return (error); + + chipc_release_region(sc, sc->core_region, RF_ALLOCATED|RF_ACTIVE); + chipc_free_rman(sc); bhnd_sprom_fini(&sc->sprom); CHIPC_LOCK_DESTROY(sc); @@ -241,58 +274,131 @@ chipc_detach(device_t dev) return (0); } +/* Read and parse chipc capabilities */ static int -chipc_suspend(device_t dev) +chipc_read_caps(struct chipc_softc *sc, struct chipc_caps *caps) { - return (0); -} + uint32_t cap_reg; + uint32_t cap_ext_reg; + uint32_t regval; + + /* Fetch cap registers */ + cap_reg = bhnd_bus_read_4(sc->core, CHIPC_CAPABILITIES); + cap_ext_reg = 0; + if (CHIPC_QUIRK(sc, SUPPORTS_CAP_EXT)) + cap_ext_reg = bhnd_bus_read_4(sc->core, CHIPC_CAPABILITIES_EXT); + + /* Extract values */ + caps->num_uarts = CHIPC_GET_BITS(cap_reg, CHIPC_CAP_NUM_UART); + caps->mipseb = CHIPC_GET_FLAG(cap_reg, CHIPC_CAP_MIPSEB); + caps->uart_gpio = CHIPC_GET_FLAG(cap_reg, CHIPC_CAP_UARTGPIO); + caps->uart_clock = CHIPC_GET_BITS(cap_reg, CHIPC_CAP_UCLKSEL); + + caps->extbus_type = CHIPC_GET_BITS(cap_reg, CHIPC_CAP_EXTBUS); + caps->power_control = CHIPC_GET_FLAG(cap_reg, CHIPC_CAP_PWR_CTL); + caps->jtag_master = CHIPC_GET_FLAG(cap_reg, CHIPC_CAP_JTAGP); + + caps->pll_type = CHIPC_GET_BITS(cap_reg, CHIPC_CAP_PLL); + caps->backplane_64 = CHIPC_GET_FLAG(cap_reg, CHIPC_CAP_BKPLN64); + caps->boot_rom = CHIPC_GET_FLAG(cap_reg, CHIPC_CAP_ROM); + caps->pmu = CHIPC_GET_FLAG(cap_reg, CHIPC_CAP_PMU); + caps->eci = CHIPC_GET_FLAG(cap_reg, CHIPC_CAP_ECI); + caps->sprom = CHIPC_GET_FLAG(cap_reg, CHIPC_CAP_SPROM); + caps->otp_size = CHIPC_GET_BITS(cap_reg, CHIPC_CAP_OTP_SIZE); + + caps->seci = CHIPC_GET_FLAG(cap_ext_reg, CHIPC_CAP2_SECI); + caps->gsio = CHIPC_GET_FLAG(cap_ext_reg, CHIPC_CAP2_GSIO); + caps->aob = CHIPC_GET_FLAG(cap_ext_reg, CHIPC_CAP2_AOB); + + /* Fetch OTP size for later IPX controller revisions */ + if (CHIPC_QUIRK(sc, IPX_OTPLAYOUT_SIZE)) { + regval = bhnd_bus_read_4(sc->core, CHIPC_OTPLAYOUT); + caps->otp_size = CHIPC_GET_BITS(regval, CHIPC_OTPL_SIZE); + } + + /* Determine flash type and paramters */ + caps->cfi_width = 0; + + switch (CHIPC_GET_BITS(cap_reg, CHIPC_CAP_FLASH)) { + case CHIPC_CAP_SFLASH_ST: + caps->flash_type = CHIPC_SFLASH_ST; + break; + case CHIPC_CAP_SFLASH_AT: + caps->flash_type = CHIPC_SFLASH_AT; + break; + case CHIPC_CAP_NFLASH: + caps->flash_type = CHIPC_NFLASH; + break; + case CHIPC_CAP_PFLASH: + caps->flash_type = CHIPC_PFLASH_CFI; + + /* determine cfi width */ + regval = bhnd_bus_read_4(sc->core, CHIPC_FLASH_CFG); + if (CHIPC_GET_FLAG(regval, CHIPC_FLASH_CFG_DS)) + caps->cfi_width = 2; + else + caps->cfi_width = 1; + + break; + case CHIPC_CAP_FLASH_NONE: + caps->flash_type = CHIPC_FLASH_NONE; + break; + + } + + /* Handle 4706_NFLASH fallback */ + if (CHIPC_QUIRK(sc, 4706_NFLASH) && + CHIPC_GET_FLAG(cap_reg, CHIPC_CAP_4706_NFLASH)) + { + caps->flash_type = CHIPC_NFLASH_4706; + } -static int -chipc_resume(device_t dev) -{ return (0); } /** - * Initialize local SPROM shadow, if required. - * - * @param sc chipc driver state. + * If supported, add an appropriate NVRAM child device. */ static int -chipc_sprom_init(struct chipc_softc *sc) +chipc_nvram_attach(struct chipc_softc *sc) { - int error; + device_t nvram_dev; + rman_res_t start; + int error; - KASSERT(sc->nvram_src == BHND_NVRAM_SRC_SPROM, - ("non-SPROM source (%u)\n", sc->nvram_src)); + switch (sc->nvram_src) { + case BHND_NVRAM_SRC_OTP: + // TODO OTP support + device_printf(sc->dev, "OTP nvram source unsupported\n"); + return (0); - /* Enable access to the SPROM */ - CHIPC_LOCK(sc); - if ((error = chipc_enable_sprom_pins(sc))) - goto failed; + case BHND_NVRAM_SRC_SPROM: + /* Add OTP/SPROM device */ + nvram_dev = BUS_ADD_CHILD(sc->dev, 0, "bhnd_nvram", -1); + if (nvram_dev == NULL) { + device_printf(sc->dev, "failed to add NVRAM device\n"); + return (ENXIO); + } + + start = rman_get_start(sc->core->res) + CHIPC_SPROM_OTP; + error = bus_set_resource(nvram_dev, SYS_RES_MEMORY, 0, start, + CHIPC_SPROM_OTP_SIZE); + return (error); - /* Initialize SPROM parser */ - error = bhnd_sprom_init(&sc->sprom, sc->core, CHIPC_SPROM_OTP); - if (error) { - device_printf(sc->dev, "SPROM identification failed: %d\n", - error); + case BHND_NVRAM_SRC_FLASH: + // TODO flash support + device_printf(sc->dev, "flash nvram source unsupported\n"); + return (0); - chipc_disable_sprom_pins(sc); - goto failed; - } + case BHND_NVRAM_SRC_UNKNOWN: + /* Handled externally */ + return (0); - /* Drop access to the SPROM lines */ - if ((error = chipc_disable_sprom_pins(sc))) { - bhnd_sprom_fini(&sc->sprom); - goto failed; + default: + device_printf(sc->dev, "invalid nvram source: %u\n", + sc->nvram_src); + return (ENXIO); } - CHIPC_UNLOCK(sc); - - return (0); - -failed: - CHIPC_UNLOCK(sc); - return (error); } /** @@ -317,27 +423,645 @@ chipc_nvram_identify(struct chipc_softc * We check for hardware presence in order of precedence. For example, * SPROM is is always used in preference to internal OTP if found. */ - if (CHIPC_CAP(sc, CAP_SPROM)) { + if (CHIPC_CAP(sc, sprom)) { srom_ctrl = bhnd_bus_read_4(sc->core, CHIPC_SPROM_CTRL); if (srom_ctrl & CHIPC_SRC_PRESENT) return (BHND_NVRAM_SRC_SPROM); } /* Check for OTP */ - if (CHIPC_CAP(sc, CAP_OTP_SIZE)) + if (CHIPC_CAP(sc, otp_size) != 0) return (BHND_NVRAM_SRC_OTP); - /* - * Finally, Northstar chipsets (and possibly other chipsets?) support - * external NAND flash. - */ - if (CHIPC_QUIRK(sc, SUPPORTS_NFLASH) && CHIPC_CAP(sc, CAP_NFLASH)) - return (BHND_NVRAM_SRC_NFLASH); + /* Check for flash */ + if (CHIPC_CAP(sc, flash_type) != CHIPC_FLASH_NONE) + return (BHND_NVRAM_SRC_FLASH); /* No NVRAM hardware capability declared */ return (BHND_NVRAM_SRC_UNKNOWN); } +static int +chipc_suspend(device_t dev) +{ + return (bus_generic_suspend(dev)); +} + +static int +chipc_resume(device_t dev) +{ + return (bus_generic_resume(dev)); +} + +static void +chipc_probe_nomatch(device_t dev, device_t child) +{ + struct resource_list *rl; + const char *name; + + name = device_get_name(child); + if (name == NULL) + name = "unknown device"; + + device_printf(dev, "<%s> at", name); + + rl = BUS_GET_RESOURCE_LIST(dev, child); + if (rl != NULL) { + resource_list_print_type(rl, "mem", SYS_RES_MEMORY, "%#jx"); + resource_list_print_type(rl, "irq", SYS_RES_IRQ, "%jd"); + } + + printf(" (no driver attached)\n"); +} + +static int +chipc_print_child(device_t dev, device_t child) +{ + struct resource_list *rl; + int retval = 0; + + retval += bus_print_child_header(dev, child); + + rl = BUS_GET_RESOURCE_LIST(dev, child); + if (rl != NULL) { + retval += resource_list_print_type(rl, "mem", SYS_RES_MEMORY, + "%#jx"); + retval += resource_list_print_type(rl, "irq", SYS_RES_IRQ, + "%jd"); + } + + retval += bus_print_child_domain(dev, child); + retval += bus_print_child_footer(dev, child); + + return (retval); +} + +static int +chipc_child_pnpinfo_str(device_t dev, device_t child, char *buf, + size_t buflen) +{ + if (buflen == 0) + return (EOVERFLOW); + + *buf = '\0'; + return (0); +} + +static int +chipc_child_location_str(device_t dev, device_t child, char *buf, + size_t buflen) +{ + if (buflen == 0) + return (EOVERFLOW); + + *buf = '\0'; + return (ENXIO); +} + +static device_t +chipc_add_child(device_t dev, u_int order, const char *name, int unit) +{ + struct chipc_devinfo *dinfo; + device_t child; + + child = device_add_child_ordered(dev, order, name, unit); + if (child == NULL) + return (NULL); + + dinfo = malloc(sizeof(struct chipc_devinfo), M_BHND, M_NOWAIT); + if (dinfo == NULL) { + device_delete_child(dev, child); + return (NULL); + } + + resource_list_init(&dinfo->resources); + + device_set_ivars(child, dinfo); + + return (child); +} + +static void +chipc_child_deleted(device_t dev, device_t child) +{ + struct chipc_devinfo *dinfo = device_get_ivars(child); + + if (dinfo != NULL) { + resource_list_free(&dinfo->resources); + free(dinfo, M_BHND); + } + + device_set_ivars(child, NULL); +} + +static struct resource_list * +chipc_get_resource_list(device_t dev, device_t child) +{ + struct chipc_devinfo *dinfo = device_get_ivars(child); + return (&dinfo->resources); +} + + +/* Allocate region records for the given port, and add the port's memory + * range to the mem_rman */ +static int +chipc_rman_init_regions (struct chipc_softc *sc, bhnd_port_type type, + u_int port) +{ + struct chipc_region *cr; + rman_res_t start, end; + u_int num_regions; + int error; + + num_regions = bhnd_get_region_count(sc->dev, port, port); + for (u_int region = 0; region < num_regions; region++) { + /* Allocate new region record */ + cr = chipc_alloc_region(sc, type, port, region); + if (cr == NULL) + return (ENODEV); + + /* Can't manage regions that cannot be allocated */ + if (cr->cr_rid < 0) { + BHND_DEBUG_DEV(sc->dev, "no rid for chipc region " + "%s%u.%u", bhnd_port_type_name(type), port, region); + chipc_free_region(sc, cr); + continue; + } + + /* Add to rman's managed range */ + start = cr->cr_addr; + end = cr->cr_end; + if ((error = rman_manage_region(&sc->mem_rman, start, end))) { + chipc_free_region(sc, cr); + return (error); + } + + /* Add to region list */ + STAILQ_INSERT_TAIL(&sc->mem_regions, cr, cr_link); + } + + return (0); +} + +/* Initialize memory state for all chipc port regions */ +static int +chipc_init_rman(struct chipc_softc *sc) +{ + u_int num_ports; + int error; + + /* Port types for which we'll register chipc_region mappings */ + bhnd_port_type types[] = { + BHND_PORT_DEVICE + }; + + /* Initialize resource manager */ + sc->mem_rman.rm_start = 0; + sc->mem_rman.rm_end = BUS_SPACE_MAXADDR; + sc->mem_rman.rm_type = RMAN_ARRAY; + sc->mem_rman.rm_descr = "ChipCommon Device Memory"; + if ((error = rman_init(&sc->mem_rman))) { + device_printf(sc->dev, "could not initialize mem_rman: %d\n", + error); + return (error); + } + + /* Populate per-port-region state */ + for (u_int i = 0; i < nitems(types); i++) { + num_ports = bhnd_get_port_count(sc->dev, types[i]); + for (u_int port = 0; port < num_ports; port++) { *** DIFF OUTPUT TRUNCATED AT 1000 LINES ***
Want to link to this message? Use this URL: <https://mail-archive.FreeBSD.org/cgi/mid.cgi?201605240112.u4O1CJOt063645>