108077f58SMarcel Moolenaar /*- 271e3c308SPedro F. Giffuni * SPDX-License-Identifier: BSD-3-Clause 371e3c308SPedro F. Giffuni * 408077f58SMarcel Moolenaar * Copyright (c) 2006-2008, Juniper Networks, Inc. 525c22eb4SRafal Jaworowski * Copyright (c) 2008 Semihalf, Rafal Czubak 6d1d3233eSRafal Jaworowski * Copyright (c) 2009 The FreeBSD Foundation 708077f58SMarcel Moolenaar * All rights reserved. 808077f58SMarcel Moolenaar * 9d1d3233eSRafal Jaworowski * Portions of this software were developed by Semihalf 10d1d3233eSRafal Jaworowski * under sponsorship from the FreeBSD Foundation. 11d1d3233eSRafal Jaworowski * 1208077f58SMarcel Moolenaar * Redistribution and use in source and binary forms, with or without 1308077f58SMarcel Moolenaar * modification, are permitted provided that the following conditions 1408077f58SMarcel Moolenaar * are met: 1508077f58SMarcel Moolenaar * 1. Redistributions of source code must retain the above copyright 1608077f58SMarcel Moolenaar * notice, this list of conditions and the following disclaimer. 1708077f58SMarcel Moolenaar * 2. Redistributions in binary form must reproduce the above copyright 1808077f58SMarcel Moolenaar * notice, this list of conditions and the following disclaimer in the 1908077f58SMarcel Moolenaar * documentation and/or other materials provided with the distribution. 2008077f58SMarcel Moolenaar * 3. The name of the author may not be used to endorse or promote products 2108077f58SMarcel Moolenaar * derived from this software without specific prior written permission. 2208077f58SMarcel Moolenaar * 2308077f58SMarcel Moolenaar * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 2408077f58SMarcel Moolenaar * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 2508077f58SMarcel Moolenaar * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 2608077f58SMarcel Moolenaar * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 2708077f58SMarcel Moolenaar * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 2808077f58SMarcel Moolenaar * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 2908077f58SMarcel Moolenaar * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED 3008077f58SMarcel Moolenaar * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 3108077f58SMarcel Moolenaar * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 3208077f58SMarcel Moolenaar * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 3308077f58SMarcel Moolenaar * SUCH DAMAGE. 3408077f58SMarcel Moolenaar */ 3508077f58SMarcel Moolenaar 368bc8506eSJustin Hibbits #include "opt_platform.h" 378bc8506eSJustin Hibbits 3808077f58SMarcel Moolenaar #include <sys/cdefs.h> 3908077f58SMarcel Moolenaar __FBSDID("$FreeBSD$"); 4008077f58SMarcel Moolenaar 4108077f58SMarcel Moolenaar #include <sys/param.h> 4208077f58SMarcel Moolenaar #include <sys/systm.h> 4308077f58SMarcel Moolenaar #include <sys/ktr.h> 4408077f58SMarcel Moolenaar #include <sys/kernel.h> 4508077f58SMarcel Moolenaar #include <sys/malloc.h> 4608077f58SMarcel Moolenaar #include <sys/module.h> 4708077f58SMarcel Moolenaar #include <sys/bus.h> 4808077f58SMarcel Moolenaar #include <sys/rman.h> 4908077f58SMarcel Moolenaar #include <machine/bus.h> 5008077f58SMarcel Moolenaar 5108077f58SMarcel Moolenaar #include <vm/vm.h> 5208077f58SMarcel Moolenaar #include <vm/pmap.h> 5308077f58SMarcel Moolenaar 54d1d3233eSRafal Jaworowski #include <dev/fdt/fdt_common.h> 55d1d3233eSRafal Jaworowski #include <dev/ofw/ofw_bus.h> 56d1d3233eSRafal Jaworowski #include <dev/ofw/ofw_bus_subr.h> 57d1d3233eSRafal Jaworowski 5825c22eb4SRafal Jaworowski #include <powerpc/mpc85xx/mpc85xx.h> 5908077f58SMarcel Moolenaar 60d1d3233eSRafal Jaworowski #include "ofw_bus_if.h" 61d1d3233eSRafal Jaworowski #include "lbc.h" 6208077f58SMarcel Moolenaar 63d1d3233eSRafal Jaworowski #ifdef DEBUG 64d1d3233eSRafal Jaworowski #define debugf(fmt, args...) do { printf("%s(): ", __func__); \ 65d1d3233eSRafal Jaworowski printf(fmt,##args); } while (0) 66d1d3233eSRafal Jaworowski #else 67d1d3233eSRafal Jaworowski #define debugf(fmt, args...) 68d1d3233eSRafal Jaworowski #endif 6908077f58SMarcel Moolenaar 70d1d3233eSRafal Jaworowski static MALLOC_DEFINE(M_LBC, "localbus", "localbus devices information"); 71d1d3233eSRafal Jaworowski 72d1d3233eSRafal Jaworowski static int lbc_probe(device_t); 73d1d3233eSRafal Jaworowski static int lbc_attach(device_t); 74d1d3233eSRafal Jaworowski static int lbc_shutdown(device_t); 758bc8506eSJustin Hibbits static int lbc_activate_resource(device_t bus __unused, device_t child __unused, 768bc8506eSJustin Hibbits int type, int rid __unused, struct resource *r); 778bc8506eSJustin Hibbits static int lbc_deactivate_resource(device_t bus __unused, 788bc8506eSJustin Hibbits device_t child __unused, int type __unused, int rid __unused, 798bc8506eSJustin Hibbits struct resource *r); 80d1d3233eSRafal Jaworowski static struct resource *lbc_alloc_resource(device_t, device_t, int, int *, 812dd1bdf1SJustin Hibbits rman_res_t, rman_res_t, rman_res_t, u_int); 82d1d3233eSRafal Jaworowski static int lbc_print_child(device_t, device_t); 83d1d3233eSRafal Jaworowski static int lbc_release_resource(device_t, device_t, int, int, 84d1d3233eSRafal Jaworowski struct resource *); 85d1d3233eSRafal Jaworowski static const struct ofw_bus_devinfo *lbc_get_devinfo(device_t, device_t); 86d1d3233eSRafal Jaworowski 87d1d3233eSRafal Jaworowski /* 88d1d3233eSRafal Jaworowski * Bus interface definition 89d1d3233eSRafal Jaworowski */ 90d1d3233eSRafal Jaworowski static device_method_t lbc_methods[] = { 91d1d3233eSRafal Jaworowski /* Device interface */ 92d1d3233eSRafal Jaworowski DEVMETHOD(device_probe, lbc_probe), 93d1d3233eSRafal Jaworowski DEVMETHOD(device_attach, lbc_attach), 94d1d3233eSRafal Jaworowski DEVMETHOD(device_shutdown, lbc_shutdown), 95d1d3233eSRafal Jaworowski 96d1d3233eSRafal Jaworowski /* Bus interface */ 97d1d3233eSRafal Jaworowski DEVMETHOD(bus_print_child, lbc_print_child), 98d1d3233eSRafal Jaworowski DEVMETHOD(bus_setup_intr, bus_generic_setup_intr), 99d1d3233eSRafal Jaworowski DEVMETHOD(bus_teardown_intr, NULL), 100d1d3233eSRafal Jaworowski 101d1d3233eSRafal Jaworowski DEVMETHOD(bus_alloc_resource, lbc_alloc_resource), 102d1d3233eSRafal Jaworowski DEVMETHOD(bus_release_resource, lbc_release_resource), 1038bc8506eSJustin Hibbits DEVMETHOD(bus_activate_resource, lbc_activate_resource), 1048bc8506eSJustin Hibbits DEVMETHOD(bus_deactivate_resource, lbc_deactivate_resource), 105d1d3233eSRafal Jaworowski 106d1d3233eSRafal Jaworowski /* OFW bus interface */ 107d1d3233eSRafal Jaworowski DEVMETHOD(ofw_bus_get_devinfo, lbc_get_devinfo), 108d1d3233eSRafal Jaworowski DEVMETHOD(ofw_bus_get_compat, ofw_bus_gen_get_compat), 109d1d3233eSRafal Jaworowski DEVMETHOD(ofw_bus_get_model, ofw_bus_gen_get_model), 110d1d3233eSRafal Jaworowski DEVMETHOD(ofw_bus_get_name, ofw_bus_gen_get_name), 111d1d3233eSRafal Jaworowski DEVMETHOD(ofw_bus_get_node, ofw_bus_gen_get_node), 112d1d3233eSRafal Jaworowski DEVMETHOD(ofw_bus_get_type, ofw_bus_gen_get_type), 113d1d3233eSRafal Jaworowski 114d1d3233eSRafal Jaworowski { 0, 0 } 115d1d3233eSRafal Jaworowski }; 116d1d3233eSRafal Jaworowski 117d1d3233eSRafal Jaworowski static driver_t lbc_driver = { 118d1d3233eSRafal Jaworowski "lbc", 119d1d3233eSRafal Jaworowski lbc_methods, 120d1d3233eSRafal Jaworowski sizeof(struct lbc_softc) 121d1d3233eSRafal Jaworowski }; 122d1d3233eSRafal Jaworowski 123d1d3233eSRafal Jaworowski devclass_t lbc_devclass; 124d1d3233eSRafal Jaworowski 12512cb797eSJustin Hibbits EARLY_DRIVER_MODULE(lbc, ofwbus, lbc_driver, lbc_devclass, 12612cb797eSJustin Hibbits 0, 0, BUS_PASS_BUS); 127d1d3233eSRafal Jaworowski 12825c22eb4SRafal Jaworowski /* 12925c22eb4SRafal Jaworowski * Calculate address mask used by OR(n) registers. Use memory region size to 13025c22eb4SRafal Jaworowski * determine mask value. The size must be a power of two and within the range 13125c22eb4SRafal Jaworowski * of 32KB - 4GB. Otherwise error code is returned. Value representing 13225c22eb4SRafal Jaworowski * 4GB size can be passed as 0xffffffff. 13325c22eb4SRafal Jaworowski */ 13425c22eb4SRafal Jaworowski static uint32_t 13525c22eb4SRafal Jaworowski lbc_address_mask(uint32_t size) 13625c22eb4SRafal Jaworowski { 13725c22eb4SRafal Jaworowski int n = 15; 13825c22eb4SRafal Jaworowski 139295be330SJustin Hibbits if (size == ~0) 14025c22eb4SRafal Jaworowski return (0); 14125c22eb4SRafal Jaworowski 14225c22eb4SRafal Jaworowski while (n < 32) { 143295be330SJustin Hibbits if (size == (1U << n)) 14425c22eb4SRafal Jaworowski break; 14525c22eb4SRafal Jaworowski n++; 14625c22eb4SRafal Jaworowski } 14725c22eb4SRafal Jaworowski 14825c22eb4SRafal Jaworowski if (n == 32) 14925c22eb4SRafal Jaworowski return (EINVAL); 15025c22eb4SRafal Jaworowski 15125c22eb4SRafal Jaworowski return (0xffff8000 << (n - 15)); 15225c22eb4SRafal Jaworowski } 15325c22eb4SRafal Jaworowski 154d1d3233eSRafal Jaworowski static void 155d1d3233eSRafal Jaworowski lbc_banks_unmap(struct lbc_softc *sc) 15608077f58SMarcel Moolenaar { 157f6703dd2SMarcel Moolenaar int r; 15808077f58SMarcel Moolenaar 159f6703dd2SMarcel Moolenaar r = 0; 160f6703dd2SMarcel Moolenaar while (r < LBC_DEV_MAX) { 161f6703dd2SMarcel Moolenaar if (sc->sc_range[r].size == 0) 162f6703dd2SMarcel Moolenaar return; 16325c22eb4SRafal Jaworowski 164f6703dd2SMarcel Moolenaar pmap_unmapdev(sc->sc_range[r].kva, sc->sc_range[r].size); 165f6703dd2SMarcel Moolenaar law_disable(OCP85XX_TGTIF_LBC, sc->sc_range[r].addr, 166f6703dd2SMarcel Moolenaar sc->sc_range[r].size); 167f6703dd2SMarcel Moolenaar r++; 16808077f58SMarcel Moolenaar } 16908077f58SMarcel Moolenaar } 17008077f58SMarcel Moolenaar 17108077f58SMarcel Moolenaar static int 172d1d3233eSRafal Jaworowski lbc_banks_map(struct lbc_softc *sc) 17325c22eb4SRafal Jaworowski { 174f6703dd2SMarcel Moolenaar vm_paddr_t end, start; 175f6703dd2SMarcel Moolenaar vm_size_t size; 176f6703dd2SMarcel Moolenaar u_int i, r, ranges, s; 177f6703dd2SMarcel Moolenaar int error; 17825c22eb4SRafal Jaworowski 179f6703dd2SMarcel Moolenaar bzero(sc->sc_range, sizeof(sc->sc_range)); 18025c22eb4SRafal Jaworowski 18125c22eb4SRafal Jaworowski /* 182f6703dd2SMarcel Moolenaar * Determine number of discontiguous address ranges to program. 18325c22eb4SRafal Jaworowski */ 184f6703dd2SMarcel Moolenaar ranges = 0; 185f6703dd2SMarcel Moolenaar for (i = 0; i < LBC_DEV_MAX; i++) { 186f6703dd2SMarcel Moolenaar size = sc->sc_banks[i].size; 187f6703dd2SMarcel Moolenaar if (size == 0) 188f6703dd2SMarcel Moolenaar continue; 189f6703dd2SMarcel Moolenaar 190f6703dd2SMarcel Moolenaar start = sc->sc_banks[i].addr; 191f6703dd2SMarcel Moolenaar for (r = 0; r < ranges; r++) { 192f6703dd2SMarcel Moolenaar /* Avoid wrap-around bugs. */ 193f6703dd2SMarcel Moolenaar end = sc->sc_range[r].addr - 1 + sc->sc_range[r].size; 194f6703dd2SMarcel Moolenaar if (start > 0 && end == start - 1) { 195f6703dd2SMarcel Moolenaar sc->sc_range[r].size += size; 196f6703dd2SMarcel Moolenaar break; 197f6703dd2SMarcel Moolenaar } 198f6703dd2SMarcel Moolenaar /* Avoid wrap-around bugs. */ 199f6703dd2SMarcel Moolenaar end = start - 1 + size; 200f6703dd2SMarcel Moolenaar if (sc->sc_range[r].addr > 0 && 201f6703dd2SMarcel Moolenaar end == sc->sc_range[r].addr - 1) { 202f6703dd2SMarcel Moolenaar sc->sc_range[r].addr = start; 203f6703dd2SMarcel Moolenaar sc->sc_range[r].size += size; 204f6703dd2SMarcel Moolenaar break; 205f6703dd2SMarcel Moolenaar } 206f6703dd2SMarcel Moolenaar } 207f6703dd2SMarcel Moolenaar if (r == ranges) { 208f6703dd2SMarcel Moolenaar /* New range; add using insertion sort */ 209f6703dd2SMarcel Moolenaar r = 0; 210f6703dd2SMarcel Moolenaar while (r < ranges && sc->sc_range[r].addr < start) 211f6703dd2SMarcel Moolenaar r++; 212f6703dd2SMarcel Moolenaar for (s = ranges; s > r; s--) 213f6703dd2SMarcel Moolenaar sc->sc_range[s] = sc->sc_range[s-1]; 214f6703dd2SMarcel Moolenaar sc->sc_range[r].addr = start; 215f6703dd2SMarcel Moolenaar sc->sc_range[r].size = size; 216f6703dd2SMarcel Moolenaar ranges++; 217f6703dd2SMarcel Moolenaar } 218f6703dd2SMarcel Moolenaar } 219f6703dd2SMarcel Moolenaar 220f6703dd2SMarcel Moolenaar /* 221f6703dd2SMarcel Moolenaar * Ranges are sorted so quickly go over the list to merge ranges 222f6703dd2SMarcel Moolenaar * that grew toward each other while building the ranges. 223f6703dd2SMarcel Moolenaar */ 224f6703dd2SMarcel Moolenaar r = 0; 225f6703dd2SMarcel Moolenaar while (r < ranges - 1) { 226f6703dd2SMarcel Moolenaar end = sc->sc_range[r].addr + sc->sc_range[r].size; 227f6703dd2SMarcel Moolenaar if (end != sc->sc_range[r+1].addr) { 228f6703dd2SMarcel Moolenaar r++; 229f6703dd2SMarcel Moolenaar continue; 230f6703dd2SMarcel Moolenaar } 231f6703dd2SMarcel Moolenaar sc->sc_range[r].size += sc->sc_range[r+1].size; 232f6703dd2SMarcel Moolenaar for (s = r + 1; s < ranges - 1; s++) 233f6703dd2SMarcel Moolenaar sc->sc_range[s] = sc->sc_range[s+1]; 234f6703dd2SMarcel Moolenaar bzero(&sc->sc_range[s], sizeof(sc->sc_range[s])); 235f6703dd2SMarcel Moolenaar ranges--; 236f6703dd2SMarcel Moolenaar } 237f6703dd2SMarcel Moolenaar 238f6703dd2SMarcel Moolenaar /* 239f6703dd2SMarcel Moolenaar * Configure LAW for the LBC ranges and map the physical memory 240f6703dd2SMarcel Moolenaar * range into KVA. 241f6703dd2SMarcel Moolenaar */ 242f6703dd2SMarcel Moolenaar for (r = 0; r < ranges; r++) { 243f6703dd2SMarcel Moolenaar start = sc->sc_range[r].addr; 244f6703dd2SMarcel Moolenaar size = sc->sc_range[r].size; 24525c22eb4SRafal Jaworowski error = law_enable(OCP85XX_TGTIF_LBC, start, size); 24625c22eb4SRafal Jaworowski if (error) 24725c22eb4SRafal Jaworowski return (error); 248f6703dd2SMarcel Moolenaar sc->sc_range[r].kva = (vm_offset_t)pmap_mapdev(start, size); 249f6703dd2SMarcel Moolenaar } 25025c22eb4SRafal Jaworowski 251f6703dd2SMarcel Moolenaar /* XXX: need something better here? */ 252f6703dd2SMarcel Moolenaar if (ranges == 0) 253f6703dd2SMarcel Moolenaar return (EINVAL); 254f6703dd2SMarcel Moolenaar 255f6703dd2SMarcel Moolenaar /* Assign KVA to banks based on the enclosing range. */ 256f6703dd2SMarcel Moolenaar for (i = 0; i < LBC_DEV_MAX; i++) { 257f6703dd2SMarcel Moolenaar size = sc->sc_banks[i].size; 258f6703dd2SMarcel Moolenaar if (size == 0) 259f6703dd2SMarcel Moolenaar continue; 260f6703dd2SMarcel Moolenaar 261f6703dd2SMarcel Moolenaar start = sc->sc_banks[i].addr; 262f6703dd2SMarcel Moolenaar for (r = 0; r < ranges; r++) { 263f6703dd2SMarcel Moolenaar end = sc->sc_range[r].addr - 1 + sc->sc_range[r].size; 264f6703dd2SMarcel Moolenaar if (start >= sc->sc_range[r].addr && 265f6703dd2SMarcel Moolenaar start - 1 + size <= end) 266f6703dd2SMarcel Moolenaar break; 267f6703dd2SMarcel Moolenaar } 268f6703dd2SMarcel Moolenaar if (r < ranges) { 269f6703dd2SMarcel Moolenaar sc->sc_banks[i].kva = sc->sc_range[r].kva + 270f6703dd2SMarcel Moolenaar (start - sc->sc_range[r].addr); 27125c22eb4SRafal Jaworowski } 272d1d3233eSRafal Jaworowski } 273f6703dd2SMarcel Moolenaar 274d1d3233eSRafal Jaworowski return (0); 275d1d3233eSRafal Jaworowski } 27625c22eb4SRafal Jaworowski 277d1d3233eSRafal Jaworowski static int 278d1d3233eSRafal Jaworowski lbc_banks_enable(struct lbc_softc *sc) 279d1d3233eSRafal Jaworowski { 280295be330SJustin Hibbits uint32_t size; 281d1d3233eSRafal Jaworowski uint32_t regval; 282d1d3233eSRafal Jaworowski int error, i; 283d1d3233eSRafal Jaworowski 284d1d3233eSRafal Jaworowski for (i = 0; i < LBC_DEV_MAX; i++) { 285d1d3233eSRafal Jaworowski size = sc->sc_banks[i].size; 28623fbc06bSMarcel Moolenaar if (size == 0) 287d1d3233eSRafal Jaworowski continue; 288f6703dd2SMarcel Moolenaar 28925c22eb4SRafal Jaworowski /* 290d1d3233eSRafal Jaworowski * Compute and program BR value. 29125c22eb4SRafal Jaworowski */ 292f6703dd2SMarcel Moolenaar regval = sc->sc_banks[i].addr; 293d1d3233eSRafal Jaworowski switch (sc->sc_banks[i].width) { 29425c22eb4SRafal Jaworowski case 8: 295d1d3233eSRafal Jaworowski regval |= (1 << 11); 29625c22eb4SRafal Jaworowski break; 29725c22eb4SRafal Jaworowski case 16: 298d1d3233eSRafal Jaworowski regval |= (2 << 11); 29925c22eb4SRafal Jaworowski break; 30025c22eb4SRafal Jaworowski case 32: 301d1d3233eSRafal Jaworowski regval |= (3 << 11); 30225c22eb4SRafal Jaworowski break; 30325c22eb4SRafal Jaworowski default: 30425c22eb4SRafal Jaworowski error = EINVAL; 30525c22eb4SRafal Jaworowski goto fail; 30625c22eb4SRafal Jaworowski } 307d1d3233eSRafal Jaworowski regval |= (sc->sc_banks[i].decc << 9); 308d1d3233eSRafal Jaworowski regval |= (sc->sc_banks[i].wp << 8); 309d1d3233eSRafal Jaworowski regval |= (sc->sc_banks[i].msel << 5); 310d1d3233eSRafal Jaworowski regval |= (sc->sc_banks[i].atom << 2); 311d1d3233eSRafal Jaworowski regval |= 1; 312f6703dd2SMarcel Moolenaar bus_space_write_4(sc->sc_bst, sc->sc_bsh, 313f6703dd2SMarcel Moolenaar LBC85XX_BR(i), regval); 31425c22eb4SRafal Jaworowski 31525c22eb4SRafal Jaworowski /* 316d1d3233eSRafal Jaworowski * Compute and program OR value. 31725c22eb4SRafal Jaworowski */ 318f6703dd2SMarcel Moolenaar regval = lbc_address_mask(size); 319d1d3233eSRafal Jaworowski switch (sc->sc_banks[i].msel) { 32025c22eb4SRafal Jaworowski case LBCRES_MSEL_GPCM: 32125c22eb4SRafal Jaworowski /* TODO Add flag support for option registers */ 322f6703dd2SMarcel Moolenaar regval |= 0x0ff7; 32325c22eb4SRafal Jaworowski break; 32425c22eb4SRafal Jaworowski case LBCRES_MSEL_FCM: 325f6703dd2SMarcel Moolenaar /* TODO Add flag support for options register */ 326f6703dd2SMarcel Moolenaar regval |= 0x0796; 327f6703dd2SMarcel Moolenaar break; 32825c22eb4SRafal Jaworowski case LBCRES_MSEL_UPMA: 32925c22eb4SRafal Jaworowski case LBCRES_MSEL_UPMB: 33025c22eb4SRafal Jaworowski case LBCRES_MSEL_UPMC: 33125c22eb4SRafal Jaworowski printf("UPM mode not supported yet!"); 33225c22eb4SRafal Jaworowski error = ENOSYS; 33325c22eb4SRafal Jaworowski goto fail; 33425c22eb4SRafal Jaworowski } 335f6703dd2SMarcel Moolenaar bus_space_write_4(sc->sc_bst, sc->sc_bsh, 336f6703dd2SMarcel Moolenaar LBC85XX_OR(i), regval); 337d1d3233eSRafal Jaworowski } 33825c22eb4SRafal Jaworowski 33925c22eb4SRafal Jaworowski return (0); 340d1d3233eSRafal Jaworowski 34125c22eb4SRafal Jaworowski fail: 342d1d3233eSRafal Jaworowski lbc_banks_unmap(sc); 34325c22eb4SRafal Jaworowski return (error); 344d1d3233eSRafal Jaworowski } 345d1d3233eSRafal Jaworowski 346d1d3233eSRafal Jaworowski static void 347d1d3233eSRafal Jaworowski fdt_lbc_fixup(phandle_t node, struct lbc_softc *sc, struct lbc_devinfo *di) 348d1d3233eSRafal Jaworowski { 349d1d3233eSRafal Jaworowski pcell_t width; 350d1d3233eSRafal Jaworowski int bank; 351d1d3233eSRafal Jaworowski 352d1d3233eSRafal Jaworowski if (OF_getprop(node, "bank-width", (void *)&width, sizeof(width)) <= 0) 353d1d3233eSRafal Jaworowski return; 354d1d3233eSRafal Jaworowski 355d1d3233eSRafal Jaworowski bank = di->di_bank; 356d1d3233eSRafal Jaworowski if (sc->sc_banks[bank].size == 0) 357d1d3233eSRafal Jaworowski return; 358d1d3233eSRafal Jaworowski 359d1d3233eSRafal Jaworowski /* Express width in bits. */ 360d1d3233eSRafal Jaworowski sc->sc_banks[bank].width = width * 8; 361d1d3233eSRafal Jaworowski } 362d1d3233eSRafal Jaworowski 363d1d3233eSRafal Jaworowski static int 364d1d3233eSRafal Jaworowski fdt_lbc_reg_decode(phandle_t node, struct lbc_softc *sc, 365d1d3233eSRafal Jaworowski struct lbc_devinfo *di) 366d1d3233eSRafal Jaworowski { 36783d9b89cSJustin Hibbits rman_res_t start, end, count; 368d1d3233eSRafal Jaworowski pcell_t *reg, *regptr; 369d1d3233eSRafal Jaworowski pcell_t addr_cells, size_cells; 370d1d3233eSRafal Jaworowski int tuple_size, tuples; 37183d9b89cSJustin Hibbits int i, j, rv, bank; 372d1d3233eSRafal Jaworowski 373d1d3233eSRafal Jaworowski if (fdt_addrsize_cells(OF_parent(node), &addr_cells, &size_cells) != 0) 374d1d3233eSRafal Jaworowski return (ENXIO); 375d1d3233eSRafal Jaworowski 376d1d3233eSRafal Jaworowski tuple_size = sizeof(pcell_t) * (addr_cells + size_cells); 377f7604b1bSOleksandr Tymoshenko tuples = OF_getencprop_alloc_multi(node, "reg", tuple_size, 378f7604b1bSOleksandr Tymoshenko (void **)®); 379d1d3233eSRafal Jaworowski debugf("addr_cells = %d, size_cells = %d\n", addr_cells, size_cells); 380d1d3233eSRafal Jaworowski debugf("tuples = %d, tuple size = %d\n", tuples, tuple_size); 381d1d3233eSRafal Jaworowski if (tuples <= 0) 382d1d3233eSRafal Jaworowski /* No 'reg' property in this node. */ 383d1d3233eSRafal Jaworowski return (0); 384d1d3233eSRafal Jaworowski 385d1d3233eSRafal Jaworowski regptr = reg; 386d1d3233eSRafal Jaworowski for (i = 0; i < tuples; i++) { 387d1d3233eSRafal Jaworowski 388d1d3233eSRafal Jaworowski bank = fdt_data_get((void *)reg, 1); 389d1d3233eSRafal Jaworowski di->di_bank = bank; 390d1d3233eSRafal Jaworowski reg += 1; 391d1d3233eSRafal Jaworowski 392d1d3233eSRafal Jaworowski /* Get address/size. */ 39383d9b89cSJustin Hibbits start = count = 0; 3947d7671dbSJustin Hibbits for (j = 0; j < addr_cells - 1; j++) { 39583d9b89cSJustin Hibbits start <<= 32; 39683d9b89cSJustin Hibbits start |= reg[j]; 39783d9b89cSJustin Hibbits } 39883d9b89cSJustin Hibbits for (j = 0; j < size_cells; j++) { 39983d9b89cSJustin Hibbits count <<= 32; 4007d7671dbSJustin Hibbits count |= reg[addr_cells + j]; 401d1d3233eSRafal Jaworowski } 402d1d3233eSRafal Jaworowski reg += addr_cells - 1 + size_cells; 403d1d3233eSRafal Jaworowski 404d1d3233eSRafal Jaworowski /* Calculate address range relative to VA base. */ 405f6703dd2SMarcel Moolenaar start = sc->sc_banks[bank].kva + start; 406d1d3233eSRafal Jaworowski end = start + count - 1; 407d1d3233eSRafal Jaworowski 40883d9b89cSJustin Hibbits debugf("reg addr bank = %d, start = %jx, end = %jx, " 40983d9b89cSJustin Hibbits "count = %jx\n", bank, start, end, count); 410d1d3233eSRafal Jaworowski 411d1d3233eSRafal Jaworowski /* Use bank (CS) cell as rid. */ 412d1d3233eSRafal Jaworowski resource_list_add(&di->di_res, SYS_RES_MEMORY, bank, start, 413d1d3233eSRafal Jaworowski end, count); 414d1d3233eSRafal Jaworowski } 415d1d3233eSRafal Jaworowski rv = 0; 4160cc376c1SOleksandr Tymoshenko OF_prop_free(regptr); 417d1d3233eSRafal Jaworowski return (rv); 41825c22eb4SRafal Jaworowski } 41925c22eb4SRafal Jaworowski 42023fbc06bSMarcel Moolenaar static void 42123fbc06bSMarcel Moolenaar lbc_intr(void *arg) 42223fbc06bSMarcel Moolenaar { 42323fbc06bSMarcel Moolenaar struct lbc_softc *sc = arg; 42423fbc06bSMarcel Moolenaar uint32_t ltesr; 42523fbc06bSMarcel Moolenaar 42623fbc06bSMarcel Moolenaar ltesr = bus_space_read_4(sc->sc_bst, sc->sc_bsh, LBC85XX_LTESR); 42723fbc06bSMarcel Moolenaar sc->sc_ltesr = ltesr; 42823fbc06bSMarcel Moolenaar bus_space_write_4(sc->sc_bst, sc->sc_bsh, LBC85XX_LTESR, ltesr); 42923fbc06bSMarcel Moolenaar wakeup(sc->sc_dev); 43023fbc06bSMarcel Moolenaar } 43123fbc06bSMarcel Moolenaar 43225c22eb4SRafal Jaworowski static int 43308077f58SMarcel Moolenaar lbc_probe(device_t dev) 43408077f58SMarcel Moolenaar { 43508077f58SMarcel Moolenaar 436d1d3233eSRafal Jaworowski if (!(ofw_bus_is_compatible(dev, "fsl,lbc") || 437d1d3233eSRafal Jaworowski ofw_bus_is_compatible(dev, "fsl,elbc"))) 43808077f58SMarcel Moolenaar return (ENXIO); 43908077f58SMarcel Moolenaar 440d1d3233eSRafal Jaworowski device_set_desc(dev, "Freescale Local Bus Controller"); 44108077f58SMarcel Moolenaar return (BUS_PROBE_DEFAULT); 44208077f58SMarcel Moolenaar } 44308077f58SMarcel Moolenaar 44408077f58SMarcel Moolenaar static int 44508077f58SMarcel Moolenaar lbc_attach(device_t dev) 44608077f58SMarcel Moolenaar { 44708077f58SMarcel Moolenaar struct lbc_softc *sc; 448d1d3233eSRafal Jaworowski struct lbc_devinfo *di; 44908077f58SMarcel Moolenaar struct rman *rm; 45083d9b89cSJustin Hibbits uintmax_t offset, size; 45183d9b89cSJustin Hibbits vm_paddr_t start; 452d1d3233eSRafal Jaworowski device_t cdev; 453d1d3233eSRafal Jaworowski phandle_t node, child; 454d1d3233eSRafal Jaworowski pcell_t *ranges, *rangesptr; 455d1d3233eSRafal Jaworowski int tuple_size, tuples; 456d1d3233eSRafal Jaworowski int par_addr_cells; 45783d9b89cSJustin Hibbits int bank, error, i, j; 45808077f58SMarcel Moolenaar 45908077f58SMarcel Moolenaar sc = device_get_softc(dev); 46008077f58SMarcel Moolenaar sc->sc_dev = dev; 46108077f58SMarcel Moolenaar 46223fbc06bSMarcel Moolenaar sc->sc_mrid = 0; 46323fbc06bSMarcel Moolenaar sc->sc_mres = bus_alloc_resource_any(dev, SYS_RES_MEMORY, &sc->sc_mrid, 46408077f58SMarcel Moolenaar RF_ACTIVE); 46523fbc06bSMarcel Moolenaar if (sc->sc_mres == NULL) 46608077f58SMarcel Moolenaar return (ENXIO); 46708077f58SMarcel Moolenaar 46823fbc06bSMarcel Moolenaar sc->sc_bst = rman_get_bustag(sc->sc_mres); 46923fbc06bSMarcel Moolenaar sc->sc_bsh = rman_get_bushandle(sc->sc_mres); 47023fbc06bSMarcel Moolenaar 47123fbc06bSMarcel Moolenaar for (bank = 0; bank < LBC_DEV_MAX; bank++) { 47223fbc06bSMarcel Moolenaar bus_space_write_4(sc->sc_bst, sc->sc_bsh, LBC85XX_BR(bank), 0); 47323fbc06bSMarcel Moolenaar bus_space_write_4(sc->sc_bst, sc->sc_bsh, LBC85XX_OR(bank), 0); 47423fbc06bSMarcel Moolenaar } 47523fbc06bSMarcel Moolenaar 47623fbc06bSMarcel Moolenaar /* 47723fbc06bSMarcel Moolenaar * Initialize configuration register: 47823fbc06bSMarcel Moolenaar * - enable Local Bus 47923fbc06bSMarcel Moolenaar * - set data buffer control signal function 48023fbc06bSMarcel Moolenaar * - disable parity byte select 48123fbc06bSMarcel Moolenaar * - set ECC parity type 48223fbc06bSMarcel Moolenaar * - set bus monitor timing and timer prescale 48323fbc06bSMarcel Moolenaar */ 48423fbc06bSMarcel Moolenaar bus_space_write_4(sc->sc_bst, sc->sc_bsh, LBC85XX_LBCR, 0); 48523fbc06bSMarcel Moolenaar 48623fbc06bSMarcel Moolenaar /* 48723fbc06bSMarcel Moolenaar * Initialize clock ratio register: 48823fbc06bSMarcel Moolenaar * - disable PLL bypass mode 48923fbc06bSMarcel Moolenaar * - configure LCLK delay cycles for the assertion of LALE 49023fbc06bSMarcel Moolenaar * - set system clock divider 49123fbc06bSMarcel Moolenaar */ 49223fbc06bSMarcel Moolenaar bus_space_write_4(sc->sc_bst, sc->sc_bsh, LBC85XX_LCRR, 0x00030008); 49323fbc06bSMarcel Moolenaar 49423fbc06bSMarcel Moolenaar bus_space_write_4(sc->sc_bst, sc->sc_bsh, LBC85XX_LTEDR, 0); 49523fbc06bSMarcel Moolenaar bus_space_write_4(sc->sc_bst, sc->sc_bsh, LBC85XX_LTESR, ~0); 49623fbc06bSMarcel Moolenaar bus_space_write_4(sc->sc_bst, sc->sc_bsh, LBC85XX_LTEIR, 0x64080001); 49723fbc06bSMarcel Moolenaar 49823fbc06bSMarcel Moolenaar sc->sc_irid = 0; 49923fbc06bSMarcel Moolenaar sc->sc_ires = bus_alloc_resource_any(dev, SYS_RES_IRQ, &sc->sc_irid, 50023fbc06bSMarcel Moolenaar RF_ACTIVE | RF_SHAREABLE); 50123fbc06bSMarcel Moolenaar if (sc->sc_ires != NULL) { 50223fbc06bSMarcel Moolenaar error = bus_setup_intr(dev, sc->sc_ires, 50323fbc06bSMarcel Moolenaar INTR_TYPE_MISC | INTR_MPSAFE, NULL, lbc_intr, sc, 50423fbc06bSMarcel Moolenaar &sc->sc_icookie); 50523fbc06bSMarcel Moolenaar if (error) { 50623fbc06bSMarcel Moolenaar device_printf(dev, "could not activate interrupt\n"); 50723fbc06bSMarcel Moolenaar bus_release_resource(dev, SYS_RES_IRQ, sc->sc_irid, 50823fbc06bSMarcel Moolenaar sc->sc_ires); 50923fbc06bSMarcel Moolenaar sc->sc_ires = NULL; 51023fbc06bSMarcel Moolenaar } 51123fbc06bSMarcel Moolenaar } 51223fbc06bSMarcel Moolenaar 51323fbc06bSMarcel Moolenaar sc->sc_ltesr = ~0; 51423fbc06bSMarcel Moolenaar 515d1d3233eSRafal Jaworowski rangesptr = NULL; 51608077f58SMarcel Moolenaar 51708077f58SMarcel Moolenaar rm = &sc->sc_rman; 51808077f58SMarcel Moolenaar rm->rm_type = RMAN_ARRAY; 519d1d3233eSRafal Jaworowski rm->rm_descr = "Local Bus Space"; 52008077f58SMarcel Moolenaar error = rman_init(rm); 52108077f58SMarcel Moolenaar if (error) 52208077f58SMarcel Moolenaar goto fail; 52308077f58SMarcel Moolenaar 52408077f58SMarcel Moolenaar error = rman_manage_region(rm, rm->rm_start, rm->rm_end); 52508077f58SMarcel Moolenaar if (error) { 52608077f58SMarcel Moolenaar rman_fini(rm); 52708077f58SMarcel Moolenaar goto fail; 52808077f58SMarcel Moolenaar } 52908077f58SMarcel Moolenaar 53025c22eb4SRafal Jaworowski /* 531d1d3233eSRafal Jaworowski * Process 'ranges' property. 53225c22eb4SRafal Jaworowski */ 533d1d3233eSRafal Jaworowski node = ofw_bus_get_node(dev); 534d1d3233eSRafal Jaworowski if ((fdt_addrsize_cells(node, &sc->sc_addr_cells, 535d1d3233eSRafal Jaworowski &sc->sc_size_cells)) != 0) { 53625c22eb4SRafal Jaworowski error = ENXIO; 53725c22eb4SRafal Jaworowski goto fail; 53825c22eb4SRafal Jaworowski } 53908077f58SMarcel Moolenaar 540d1d3233eSRafal Jaworowski par_addr_cells = fdt_parent_addr_cells(node); 541d1d3233eSRafal Jaworowski if (par_addr_cells > 2) { 542d1d3233eSRafal Jaworowski device_printf(dev, "unsupported parent #addr-cells\n"); 543d1d3233eSRafal Jaworowski error = ERANGE; 544d1d3233eSRafal Jaworowski goto fail; 545d1d3233eSRafal Jaworowski } 546d1d3233eSRafal Jaworowski tuple_size = sizeof(pcell_t) * (sc->sc_addr_cells + par_addr_cells + 547d1d3233eSRafal Jaworowski sc->sc_size_cells); 548d1d3233eSRafal Jaworowski 549f7604b1bSOleksandr Tymoshenko tuples = OF_getencprop_alloc_multi(node, "ranges", tuple_size, 550d1d3233eSRafal Jaworowski (void **)&ranges); 551d1d3233eSRafal Jaworowski if (tuples < 0) { 552d1d3233eSRafal Jaworowski device_printf(dev, "could not retrieve 'ranges' property\n"); 553d1d3233eSRafal Jaworowski error = ENXIO; 554d1d3233eSRafal Jaworowski goto fail; 555d1d3233eSRafal Jaworowski } 556d1d3233eSRafal Jaworowski rangesptr = ranges; 557d1d3233eSRafal Jaworowski 558d1d3233eSRafal Jaworowski debugf("par addr_cells = %d, addr_cells = %d, size_cells = %d, " 559d1d3233eSRafal Jaworowski "tuple_size = %d, tuples = %d\n", par_addr_cells, 560d1d3233eSRafal Jaworowski sc->sc_addr_cells, sc->sc_size_cells, tuple_size, tuples); 561d1d3233eSRafal Jaworowski 562d1d3233eSRafal Jaworowski start = 0; 563d1d3233eSRafal Jaworowski size = 0; 564d1d3233eSRafal Jaworowski for (i = 0; i < tuples; i++) { 565d1d3233eSRafal Jaworowski 566d1d3233eSRafal Jaworowski /* The first cell is the bank (chip select) number. */ 56783d9b89cSJustin Hibbits bank = fdt_data_get(ranges, 1); 568d1d3233eSRafal Jaworowski if (bank < 0 || bank > LBC_DEV_MAX) { 569d1d3233eSRafal Jaworowski device_printf(dev, "bank out of range: %d\n", bank); 570d1d3233eSRafal Jaworowski error = ERANGE; 571d1d3233eSRafal Jaworowski goto fail; 572d1d3233eSRafal Jaworowski } 573d1d3233eSRafal Jaworowski ranges += 1; 574d1d3233eSRafal Jaworowski 575d1d3233eSRafal Jaworowski /* 576d1d3233eSRafal Jaworowski * Remaining cells of the child address define offset into 577d1d3233eSRafal Jaworowski * this CS. 578d1d3233eSRafal Jaworowski */ 57983d9b89cSJustin Hibbits offset = 0; 58083d9b89cSJustin Hibbits for (j = 0; j < sc->sc_addr_cells - 1; j++) { 58183d9b89cSJustin Hibbits offset <<= sizeof(pcell_t) * 8; 58283d9b89cSJustin Hibbits offset |= *ranges; 58383d9b89cSJustin Hibbits ranges++; 58483d9b89cSJustin Hibbits } 585d1d3233eSRafal Jaworowski 586d1d3233eSRafal Jaworowski /* Parent bus start address of this bank. */ 58783d9b89cSJustin Hibbits start = 0; 58883d9b89cSJustin Hibbits for (j = 0; j < par_addr_cells; j++) { 58983d9b89cSJustin Hibbits start <<= sizeof(pcell_t) * 8; 59083d9b89cSJustin Hibbits start |= *ranges; 59183d9b89cSJustin Hibbits ranges++; 59283d9b89cSJustin Hibbits } 593d1d3233eSRafal Jaworowski 594d1d3233eSRafal Jaworowski size = fdt_data_get((void *)ranges, sc->sc_size_cells); 595d1d3233eSRafal Jaworowski ranges += sc->sc_size_cells; 59683d9b89cSJustin Hibbits debugf("bank = %d, start = %jx, size = %jx\n", bank, 59783d9b89cSJustin Hibbits (uintmax_t)start, size); 598d1d3233eSRafal Jaworowski 599f6703dd2SMarcel Moolenaar sc->sc_banks[bank].addr = start + offset; 600d1d3233eSRafal Jaworowski sc->sc_banks[bank].size = size; 601d1d3233eSRafal Jaworowski 602d1d3233eSRafal Jaworowski /* 603d1d3233eSRafal Jaworowski * Attributes for the bank. 604d1d3233eSRafal Jaworowski * 605d1d3233eSRafal Jaworowski * XXX Note there are no DT bindings defined for them at the 606d1d3233eSRafal Jaworowski * moment, so we need to provide some defaults. 607d1d3233eSRafal Jaworowski */ 608d1d3233eSRafal Jaworowski sc->sc_banks[bank].width = 16; 609d1d3233eSRafal Jaworowski sc->sc_banks[bank].msel = LBCRES_MSEL_GPCM; 610d1d3233eSRafal Jaworowski sc->sc_banks[bank].decc = LBCRES_DECC_DISABLED; 611d1d3233eSRafal Jaworowski sc->sc_banks[bank].atom = LBCRES_ATOM_DISABLED; 612d1d3233eSRafal Jaworowski sc->sc_banks[bank].wp = 0; 613d1d3233eSRafal Jaworowski } 614d1d3233eSRafal Jaworowski 615d1d3233eSRafal Jaworowski /* 616d1d3233eSRafal Jaworowski * Initialize mem-mappings for the LBC banks (i.e. chip selects). 617d1d3233eSRafal Jaworowski */ 618d1d3233eSRafal Jaworowski error = lbc_banks_map(sc); 619d1d3233eSRafal Jaworowski if (error) 620d1d3233eSRafal Jaworowski goto fail; 621d1d3233eSRafal Jaworowski 622d1d3233eSRafal Jaworowski /* 623d1d3233eSRafal Jaworowski * Walk the localbus and add direct subordinates as our children. 624d1d3233eSRafal Jaworowski */ 625d1d3233eSRafal Jaworowski for (child = OF_child(node); child != 0; child = OF_peer(child)) { 626d1d3233eSRafal Jaworowski 627d1d3233eSRafal Jaworowski di = malloc(sizeof(*di), M_LBC, M_WAITOK | M_ZERO); 628d1d3233eSRafal Jaworowski 629d1d3233eSRafal Jaworowski if (ofw_bus_gen_setup_devinfo(&di->di_ofw, child) != 0) { 630d1d3233eSRafal Jaworowski free(di, M_LBC); 631d1d3233eSRafal Jaworowski device_printf(dev, "could not set up devinfo\n"); 632d1d3233eSRafal Jaworowski continue; 633d1d3233eSRafal Jaworowski } 634d1d3233eSRafal Jaworowski 635d1d3233eSRafal Jaworowski resource_list_init(&di->di_res); 636d1d3233eSRafal Jaworowski 637d1d3233eSRafal Jaworowski if (fdt_lbc_reg_decode(child, sc, di)) { 638d1d3233eSRafal Jaworowski device_printf(dev, "could not process 'reg' " 639d1d3233eSRafal Jaworowski "property\n"); 640d1d3233eSRafal Jaworowski ofw_bus_gen_destroy_devinfo(&di->di_ofw); 641d1d3233eSRafal Jaworowski free(di, M_LBC); 642d1d3233eSRafal Jaworowski continue; 643d1d3233eSRafal Jaworowski } 644d1d3233eSRafal Jaworowski 645d1d3233eSRafal Jaworowski fdt_lbc_fixup(child, sc, di); 646d1d3233eSRafal Jaworowski 647d1d3233eSRafal Jaworowski /* Add newbus device for this FDT node */ 648d1d3233eSRafal Jaworowski cdev = device_add_child(dev, NULL, -1); 649d1d3233eSRafal Jaworowski if (cdev == NULL) { 650d1d3233eSRafal Jaworowski device_printf(dev, "could not add child: %s\n", 651d1d3233eSRafal Jaworowski di->di_ofw.obd_name); 652d1d3233eSRafal Jaworowski resource_list_free(&di->di_res); 653d1d3233eSRafal Jaworowski ofw_bus_gen_destroy_devinfo(&di->di_ofw); 654d1d3233eSRafal Jaworowski free(di, M_LBC); 655d1d3233eSRafal Jaworowski continue; 656d1d3233eSRafal Jaworowski } 6578c6037c4SJustin Hibbits debugf("added child name='%s', node=%x\n", di->di_ofw.obd_name, 6588c6037c4SJustin Hibbits child); 659d1d3233eSRafal Jaworowski device_set_ivars(cdev, di); 660d1d3233eSRafal Jaworowski } 661d1d3233eSRafal Jaworowski 662d1d3233eSRafal Jaworowski /* 663d1d3233eSRafal Jaworowski * Enable the LBC. 664d1d3233eSRafal Jaworowski */ 665d1d3233eSRafal Jaworowski lbc_banks_enable(sc); 666d1d3233eSRafal Jaworowski 6670cc376c1SOleksandr Tymoshenko OF_prop_free(rangesptr); 66808077f58SMarcel Moolenaar return (bus_generic_attach(dev)); 66908077f58SMarcel Moolenaar 67008077f58SMarcel Moolenaar fail: 6710cc376c1SOleksandr Tymoshenko OF_prop_free(rangesptr); 67223fbc06bSMarcel Moolenaar bus_release_resource(dev, SYS_RES_MEMORY, sc->sc_mrid, sc->sc_mres); 67308077f58SMarcel Moolenaar return (error); 67408077f58SMarcel Moolenaar } 67508077f58SMarcel Moolenaar 67608077f58SMarcel Moolenaar static int 67708077f58SMarcel Moolenaar lbc_shutdown(device_t dev) 67808077f58SMarcel Moolenaar { 67908077f58SMarcel Moolenaar 68008077f58SMarcel Moolenaar /* TODO */ 68108077f58SMarcel Moolenaar return(0); 68208077f58SMarcel Moolenaar } 68308077f58SMarcel Moolenaar 68408077f58SMarcel Moolenaar static struct resource * 685d1d3233eSRafal Jaworowski lbc_alloc_resource(device_t bus, device_t child, int type, int *rid, 6862dd1bdf1SJustin Hibbits rman_res_t start, rman_res_t end, rman_res_t count, u_int flags) 68708077f58SMarcel Moolenaar { 68808077f58SMarcel Moolenaar struct lbc_softc *sc; 689d1d3233eSRafal Jaworowski struct lbc_devinfo *di; 690d1d3233eSRafal Jaworowski struct resource_list_entry *rle; 691d1d3233eSRafal Jaworowski struct resource *res; 69208077f58SMarcel Moolenaar struct rman *rm; 693d1d3233eSRafal Jaworowski int needactivate; 69408077f58SMarcel Moolenaar 69508077f58SMarcel Moolenaar /* We only support default allocations. */ 696f7dc5935SJustin Hibbits if (!RMAN_IS_DEFAULT_RANGE(start, end)) 69708077f58SMarcel Moolenaar return (NULL); 69808077f58SMarcel Moolenaar 699d1d3233eSRafal Jaworowski sc = device_get_softc(bus); 70008077f58SMarcel Moolenaar if (type == SYS_RES_IRQ) 701d1d3233eSRafal Jaworowski return (bus_alloc_resource(bus, type, rid, start, end, count, 70208077f58SMarcel Moolenaar flags)); 70308077f58SMarcel Moolenaar 704d1d3233eSRafal Jaworowski /* 705d1d3233eSRafal Jaworowski * Request for the default allocation with a given rid: use resource 706d1d3233eSRafal Jaworowski * list stored in the local device info. 707d1d3233eSRafal Jaworowski */ 708d1d3233eSRafal Jaworowski if ((di = device_get_ivars(child)) == NULL) 709d1d3233eSRafal Jaworowski return (NULL); 710d1d3233eSRafal Jaworowski 711d1d3233eSRafal Jaworowski if (type == SYS_RES_IOPORT) 712d1d3233eSRafal Jaworowski type = SYS_RES_MEMORY; 713d1d3233eSRafal Jaworowski 714d1d3233eSRafal Jaworowski rid = &di->di_bank; 715d1d3233eSRafal Jaworowski 716d1d3233eSRafal Jaworowski rle = resource_list_find(&di->di_res, type, *rid); 717d1d3233eSRafal Jaworowski if (rle == NULL) { 718d1d3233eSRafal Jaworowski device_printf(bus, "no default resources for " 719d1d3233eSRafal Jaworowski "rid = %d, type = %d\n", *rid, type); 72025c22eb4SRafal Jaworowski return (NULL); 72125c22eb4SRafal Jaworowski } 722d1d3233eSRafal Jaworowski start = rle->start; 723d1d3233eSRafal Jaworowski count = rle->count; 724d1d3233eSRafal Jaworowski end = start + count - 1; 72525c22eb4SRafal Jaworowski 726d1d3233eSRafal Jaworowski sc = device_get_softc(bus); 727d1d3233eSRafal Jaworowski 728d1d3233eSRafal Jaworowski needactivate = flags & RF_ACTIVE; 729d1d3233eSRafal Jaworowski flags &= ~RF_ACTIVE; 73008077f58SMarcel Moolenaar 73108077f58SMarcel Moolenaar rm = &sc->sc_rman; 732d1d3233eSRafal Jaworowski 733d1d3233eSRafal Jaworowski res = rman_reserve_resource(rm, start, end, count, flags, child); 734d1d3233eSRafal Jaworowski if (res == NULL) { 735da1b038aSJustin Hibbits device_printf(bus, "failed to reserve resource %#jx - %#jx " 736da1b038aSJustin Hibbits "(%#jx)\n", start, end, count); 737d1d3233eSRafal Jaworowski return (NULL); 73808077f58SMarcel Moolenaar } 739d1d3233eSRafal Jaworowski 740d1d3233eSRafal Jaworowski rman_set_rid(res, *rid); 741d1d3233eSRafal Jaworowski rman_set_bustag(res, &bs_be_tag); 742d1d3233eSRafal Jaworowski rman_set_bushandle(res, rman_get_start(res)); 743d1d3233eSRafal Jaworowski 744d1d3233eSRafal Jaworowski if (needactivate) 745d1d3233eSRafal Jaworowski if (bus_activate_resource(child, type, *rid, res)) { 746d1d3233eSRafal Jaworowski device_printf(child, "resource activation failed\n"); 747d1d3233eSRafal Jaworowski rman_release_resource(res); 748d1d3233eSRafal Jaworowski return (NULL); 749d1d3233eSRafal Jaworowski } 750d1d3233eSRafal Jaworowski 751d1d3233eSRafal Jaworowski return (res); 75208077f58SMarcel Moolenaar } 75308077f58SMarcel Moolenaar 75408077f58SMarcel Moolenaar static int 75508077f58SMarcel Moolenaar lbc_print_child(device_t dev, device_t child) 75608077f58SMarcel Moolenaar { 757d1d3233eSRafal Jaworowski struct lbc_devinfo *di; 758d1d3233eSRafal Jaworowski struct resource_list *rl; 759d1d3233eSRafal Jaworowski int rv; 76008077f58SMarcel Moolenaar 761d1d3233eSRafal Jaworowski di = device_get_ivars(child); 762d1d3233eSRafal Jaworowski rl = &di->di_res; 76308077f58SMarcel Moolenaar 764d1d3233eSRafal Jaworowski rv = 0; 765d1d3233eSRafal Jaworowski rv += bus_print_child_header(dev, child); 766da1b038aSJustin Hibbits rv += resource_list_print_type(rl, "mem", SYS_RES_MEMORY, "%#jx"); 767da1b038aSJustin Hibbits rv += resource_list_print_type(rl, "irq", SYS_RES_IRQ, "%jd"); 768d1d3233eSRafal Jaworowski rv += bus_print_child_footer(dev, child); 76908077f58SMarcel Moolenaar 770d1d3233eSRafal Jaworowski return (rv); 77108077f58SMarcel Moolenaar } 77208077f58SMarcel Moolenaar 77308077f58SMarcel Moolenaar static int 77408077f58SMarcel Moolenaar lbc_release_resource(device_t dev, device_t child, int type, int rid, 77508077f58SMarcel Moolenaar struct resource *res) 77608077f58SMarcel Moolenaar { 777d1d3233eSRafal Jaworowski int err; 778d1d3233eSRafal Jaworowski 779d1d3233eSRafal Jaworowski if (rman_get_flags(res) & RF_ACTIVE) { 780d1d3233eSRafal Jaworowski err = bus_deactivate_resource(child, type, rid, res); 781d1d3233eSRafal Jaworowski if (err) 782d1d3233eSRafal Jaworowski return (err); 783d1d3233eSRafal Jaworowski } 78408077f58SMarcel Moolenaar 78508077f58SMarcel Moolenaar return (rman_release_resource(res)); 78608077f58SMarcel Moolenaar } 78708077f58SMarcel Moolenaar 7888bc8506eSJustin Hibbits static int 7898bc8506eSJustin Hibbits lbc_activate_resource(device_t bus __unused, device_t child __unused, 7908bc8506eSJustin Hibbits int type __unused, int rid __unused, struct resource *r) 7918bc8506eSJustin Hibbits { 7928bc8506eSJustin Hibbits 7938bc8506eSJustin Hibbits /* Child resources were already mapped, just activate. */ 7948bc8506eSJustin Hibbits return (rman_activate_resource(r)); 7958bc8506eSJustin Hibbits } 7968bc8506eSJustin Hibbits 7978bc8506eSJustin Hibbits static int 7988bc8506eSJustin Hibbits lbc_deactivate_resource(device_t bus __unused, device_t child __unused, 7998bc8506eSJustin Hibbits int type __unused, int rid __unused, struct resource *r) 8008bc8506eSJustin Hibbits { 8018bc8506eSJustin Hibbits 8028bc8506eSJustin Hibbits return (rman_deactivate_resource(r)); 8038bc8506eSJustin Hibbits } 8048bc8506eSJustin Hibbits 805d1d3233eSRafal Jaworowski static const struct ofw_bus_devinfo * 806d1d3233eSRafal Jaworowski lbc_get_devinfo(device_t bus, device_t child) 80708077f58SMarcel Moolenaar { 808d1d3233eSRafal Jaworowski struct lbc_devinfo *di; 80908077f58SMarcel Moolenaar 810d1d3233eSRafal Jaworowski di = device_get_ivars(child); 811d1d3233eSRafal Jaworowski return (&di->di_ofw); 81208077f58SMarcel Moolenaar } 813f6703dd2SMarcel Moolenaar 814f6703dd2SMarcel Moolenaar void 815f6703dd2SMarcel Moolenaar lbc_write_reg(device_t child, u_int off, uint32_t val) 816f6703dd2SMarcel Moolenaar { 81723fbc06bSMarcel Moolenaar device_t dev; 818f6703dd2SMarcel Moolenaar struct lbc_softc *sc; 819f6703dd2SMarcel Moolenaar 82023fbc06bSMarcel Moolenaar dev = device_get_parent(child); 82123fbc06bSMarcel Moolenaar 82223fbc06bSMarcel Moolenaar if (off >= 0x1000) { 82323fbc06bSMarcel Moolenaar device_printf(dev, "%s(%s): invalid offset %#x\n", 82423fbc06bSMarcel Moolenaar __func__, device_get_nameunit(child), off); 82523fbc06bSMarcel Moolenaar return; 82623fbc06bSMarcel Moolenaar } 82723fbc06bSMarcel Moolenaar 82823fbc06bSMarcel Moolenaar sc = device_get_softc(dev); 82923fbc06bSMarcel Moolenaar 83023fbc06bSMarcel Moolenaar if (off == LBC85XX_LTESR && sc->sc_ltesr != ~0u) { 83123fbc06bSMarcel Moolenaar sc->sc_ltesr ^= (val & sc->sc_ltesr); 83223fbc06bSMarcel Moolenaar return; 83323fbc06bSMarcel Moolenaar } 83423fbc06bSMarcel Moolenaar 83523fbc06bSMarcel Moolenaar if (off == LBC85XX_LTEATR && (val & 1) == 0) 83623fbc06bSMarcel Moolenaar sc->sc_ltesr = ~0u; 837f6703dd2SMarcel Moolenaar bus_space_write_4(sc->sc_bst, sc->sc_bsh, off, val); 838f6703dd2SMarcel Moolenaar } 839f6703dd2SMarcel Moolenaar 840f6703dd2SMarcel Moolenaar uint32_t 841f6703dd2SMarcel Moolenaar lbc_read_reg(device_t child, u_int off) 842f6703dd2SMarcel Moolenaar { 84323fbc06bSMarcel Moolenaar device_t dev; 844f6703dd2SMarcel Moolenaar struct lbc_softc *sc; 84523fbc06bSMarcel Moolenaar uint32_t val; 846f6703dd2SMarcel Moolenaar 84723fbc06bSMarcel Moolenaar dev = device_get_parent(child); 84823fbc06bSMarcel Moolenaar 84923fbc06bSMarcel Moolenaar if (off >= 0x1000) { 85023fbc06bSMarcel Moolenaar device_printf(dev, "%s(%s): invalid offset %#x\n", 85123fbc06bSMarcel Moolenaar __func__, device_get_nameunit(child), off); 85223fbc06bSMarcel Moolenaar return (~0U); 85323fbc06bSMarcel Moolenaar } 85423fbc06bSMarcel Moolenaar 85523fbc06bSMarcel Moolenaar sc = device_get_softc(dev); 85623fbc06bSMarcel Moolenaar 85723fbc06bSMarcel Moolenaar if (off == LBC85XX_LTESR && sc->sc_ltesr != ~0U) 85823fbc06bSMarcel Moolenaar val = sc->sc_ltesr; 85923fbc06bSMarcel Moolenaar else 86023fbc06bSMarcel Moolenaar val = bus_space_read_4(sc->sc_bst, sc->sc_bsh, off); 86123fbc06bSMarcel Moolenaar return (val); 862f6703dd2SMarcel Moolenaar } 863