1/*- 2 * Copyright (c) 2006 Marius Strobl <marius@FreeBSD.org> 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 24 * SUCH DAMAGE. 25 */ 26 27#include <sys/cdefs.h> 28__FBSDID("$FreeBSD$"); 29 30#include <sys/param.h> 31#include <sys/systm.h> 32#include <sys/bus.h> 33#include <sys/kernel.h> 34#include <sys/module.h> 35#include <sys/resource.h> 36#include <sys/rman.h> 37 38#include <dev/ofw/ofw_bus.h> 39#include <dev/ofw/ofw_bus_subr.h> 40#include <dev/ofw/openfirm.h> 41 42#include <machine/bus.h> 43#include <machine/bus_common.h> 44#include <machine/resource.h> 45 46#include <sparc64/sbus/ofw_sbus.h> 47#include <sparc64/sbus/sbusreg.h> 48#include <sparc64/sbus/sbusvar.h> 49 50struct lebuffer_devinfo { 51 struct ofw_bus_devinfo ldi_obdinfo; 52 struct resource_list ldi_rl; 53}; 54 55static devclass_t lebuffer_devclass; 56 57static device_probe_t lebuffer_probe; 58static device_attach_t lebuffer_attach; 59static device_detach_t lebuffer_detach; 60static bus_print_child_t lebuffer_print_child; 61static bus_probe_nomatch_t lebuffer_probe_nomatch; 62static bus_get_resource_list_t lebuffer_get_resource_list; 63static ofw_bus_get_devinfo_t lebuffer_get_devinfo; 64 65static struct lebuffer_devinfo *lebuffer_setup_dinfo(device_t, phandle_t); 66static void lebuffer_destroy_dinfo(struct lebuffer_devinfo *); 67static int lebuffer_print_res(struct lebuffer_devinfo *); 68 69static device_method_t lebuffer_methods[] = { 70 /* Device interface */ 71 DEVMETHOD(device_probe, lebuffer_probe), 72 DEVMETHOD(device_attach, lebuffer_attach), 73 DEVMETHOD(device_detach, lebuffer_detach), 74 DEVMETHOD(device_shutdown, bus_generic_shutdown), 75 DEVMETHOD(device_suspend, bus_generic_suspend), 76 DEVMETHOD(device_resume, bus_generic_resume), 77 78 /* Bus interface */ 79 DEVMETHOD(bus_print_child, lebuffer_print_child), 80 DEVMETHOD(bus_probe_nomatch, lebuffer_probe_nomatch), 81 DEVMETHOD(bus_setup_intr, bus_generic_setup_intr), 82 DEVMETHOD(bus_teardown_intr, bus_generic_teardown_intr), 83 DEVMETHOD(bus_alloc_resource, bus_generic_rl_alloc_resource), 84 DEVMETHOD(bus_adjust_resource, bus_generic_adjust_resource), 85 DEVMETHOD(bus_release_resource, bus_generic_rl_release_resource), 86 DEVMETHOD(bus_activate_resource, bus_generic_activate_resource), 87 DEVMETHOD(bus_deactivate_resource, bus_generic_deactivate_resource), 88 DEVMETHOD(bus_get_resource_list, lebuffer_get_resource_list), 89 DEVMETHOD(bus_get_resource, bus_generic_rl_get_resource), 90 91 /* ofw_bus interface */ 92 DEVMETHOD(ofw_bus_get_devinfo, lebuffer_get_devinfo), 93 DEVMETHOD(ofw_bus_get_compat, ofw_bus_gen_get_compat), 94 DEVMETHOD(ofw_bus_get_model, ofw_bus_gen_get_model), 95 DEVMETHOD(ofw_bus_get_name, ofw_bus_gen_get_name), 96 DEVMETHOD(ofw_bus_get_node, ofw_bus_gen_get_node), 97 DEVMETHOD(ofw_bus_get_type, ofw_bus_gen_get_type), 98 99 { 0, 0 } 100}; 101 102DEFINE_CLASS_0(lebuffer, lebuffer_driver, lebuffer_methods, 1); 103DRIVER_MODULE(lebuffer, sbus, lebuffer_driver, lebuffer_devclass, 0, 0); 104MODULE_DEPEND(lebuffer, sbus, 1, 1, 1); 105MODULE_VERSION(lebuffer, 1); 106 107static int 108lebuffer_probe(device_t dev) 109{ 110 const char *name; 111 112 name = ofw_bus_get_name(dev); 113 if (strcmp(name, "lebuffer") == 0) { 114 device_set_desc_copy(dev, name); 115 return (0); 116 } 117 return (ENXIO); 118} 119 120static int 121lebuffer_attach(device_t dev) 122{ 123 struct lebuffer_devinfo *ldi; 124 device_t cdev; 125 phandle_t child; 126 int children; 127 128 children = 0; 129 for (child = OF_child(ofw_bus_get_node(dev)); child != 0; 130 child = OF_peer(child)) { 131 if ((ldi = lebuffer_setup_dinfo(dev, child)) == NULL) 132 continue; 133 if (children != 0) { 134 device_printf(dev, 135 "<%s>: only one child per buffer supported\n", 136 ldi->ldi_obdinfo.obd_name); 137 lebuffer_destroy_dinfo(ldi); 138 continue; 139 } 140 if ((cdev = device_add_child(dev, NULL, -1)) == NULL) { 141 device_printf(dev, "<%s>: device_add_child failed\n", 142 ldi->ldi_obdinfo.obd_name); 143 lebuffer_destroy_dinfo(ldi); 144 continue; 145 } 146 device_set_ivars(cdev, ldi); 147 children++; 148 } 149 return (bus_generic_attach(dev)); 150} 151 152static int 153lebuffer_detach(device_t dev) 154{ 155 device_t *children; 156 int i, nchildren; 157 158 bus_generic_detach(dev); 159 if (device_get_children(dev, &children, &nchildren) == 0) { 160 for (i = 0; i < nchildren; i++) { 161 lebuffer_destroy_dinfo(device_get_ivars(children[i])); 162 device_delete_child(dev, children[i]); 163 } 164 free(children, M_TEMP); 165 } 166 return (0); 167} 168 169static struct lebuffer_devinfo * 170lebuffer_setup_dinfo(device_t dev, phandle_t node) 171{ 172 struct lebuffer_devinfo *ldi; 173 struct sbus_regs *reg; 174 uint32_t base, iv, *intr; 175 int i, nreg, nintr, slot, rslot; 176 177 ldi = malloc(sizeof(*ldi), M_DEVBUF, M_WAITOK | M_ZERO); 178 if (ofw_bus_gen_setup_devinfo(&ldi->ldi_obdinfo, node) != 0) { 179 free(ldi, M_DEVBUF); 180 return (NULL); 181 } 182 resource_list_init(&ldi->ldi_rl); 183 slot = -1; 184 nreg = OF_getprop_alloc(node, "reg", sizeof(*reg), (void **)®); 185 if (nreg == -1) { 186 device_printf(dev, "<%s>: incomplete\n", 187 ldi->ldi_obdinfo.obd_name); 188 goto fail; 189 } 190 for (i = 0; i < nreg; i++) { 191 base = reg[i].sbr_offset; 192 if (SBUS_ABS(base)) { 193 rslot = SBUS_ABS_TO_SLOT(base); 194 base = SBUS_ABS_TO_OFFSET(base); 195 } else 196 rslot = reg[i].sbr_slot; 197 if (slot != -1 && slot != rslot) { 198 device_printf(dev, "<%s>: multiple slots\n", 199 ldi->ldi_obdinfo.obd_name); 200 free(reg, M_OFWPROP); 201 goto fail; 202 } 203 slot = rslot; 204 205 resource_list_add(&ldi->ldi_rl, SYS_RES_MEMORY, i, base, 206 base + reg[i].sbr_size, reg[i].sbr_size); 207 } 208 free(reg, M_OFWPROP); 209 if (slot != sbus_get_slot(dev)) { 210 device_printf(dev, "<%s>: parent and child slot do not match\n", 211 ldi->ldi_obdinfo.obd_name); 212 goto fail; 213 } 214 215 /* 216 * The `interrupts' property contains the SBus interrupt level. 217 */ 218 nintr = OF_getprop_alloc(node, "interrupts", sizeof(*intr), 219 (void **)&intr); 220 if (nintr != -1) { 221 for (i = 0; i < nintr; i++) { 222 iv = intr[i]; 223 /* 224 * SBus card devices need the slot number encoded into 225 * the vector as this is generally not done. 226 */ 227 if ((iv & INTMAP_OBIO_MASK) == 0) 228 iv |= slot << 3; 229 /* Set the IGN as appropriate. */ 230 iv |= sbus_get_ign(dev) << INTMAP_IGN_SHIFT; 231 resource_list_add(&ldi->ldi_rl, SYS_RES_IRQ, i, 232 iv, iv, 1); 233 } 234 free(intr, M_OFWPROP); 235 } 236 return (ldi); 237 238 fail: 239 lebuffer_destroy_dinfo(ldi); 240 return (NULL); 241} 242 243static void 244lebuffer_destroy_dinfo(struct lebuffer_devinfo *dinfo) 245{ 246 247 resource_list_free(&dinfo->ldi_rl); 248 ofw_bus_gen_destroy_devinfo(&dinfo->ldi_obdinfo); 249 free(dinfo, M_DEVBUF); 250} 251 252static int 253lebuffer_print_child(device_t dev, device_t child) 254{ 255 int rv; 256 257 rv = bus_print_child_header(dev, child); 258 rv += lebuffer_print_res(device_get_ivars(child)); 259 rv += bus_print_child_footer(dev, child); 260 return (rv); 261} 262 263static void 264lebuffer_probe_nomatch(device_t dev, device_t child) 265{ 266 const char *type; 267 268 device_printf(dev, "<%s>", ofw_bus_get_name(child)); 269 lebuffer_print_res(device_get_ivars(child)); 270 type = ofw_bus_get_type(child); 271 printf(" type %s (no driver attached)\n", 272 type != NULL ? type : "unknown"); 273} 274 275static struct resource_list * 276lebuffer_get_resource_list(device_t dev, device_t child) 277{ 278 struct lebuffer_devinfo *ldi; 279 280 ldi = device_get_ivars(child); 281 return (&ldi->ldi_rl); 282} 283 284static const struct ofw_bus_devinfo * 285lebuffer_get_devinfo(device_t bus, device_t child) 286{ 287 struct lebuffer_devinfo *ldi; 288 289 ldi = device_get_ivars(child); 290 return (&ldi->ldi_obdinfo); 291} 292 293static int 294lebuffer_print_res(struct lebuffer_devinfo *ldi) 295{ 296 int rv; 297 298 rv = 0; 299 rv += resource_list_print_type(&ldi->ldi_rl, "mem", SYS_RES_MEMORY, 300 "%#lx"); 301 rv += resource_list_print_type(&ldi->ldi_rl, "irq", SYS_RES_IRQ, "%ld"); 302 return (rv); 303} 304