The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/mips/beri/beri_simplebus.c

Version: -  FREEBSD  -  FREEBSD-13-STABLE  -  FREEBSD-13-0  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  l41  -  OPENBSD  -  linux-2.6  -  MK84  -  PLAN9  -  xnu-8792 
SearchContext: -  none  -  3  -  10 

    1 /*-
    2  * Copyright (c) 2009-2010 The FreeBSD Foundation
    3  * All rights reserved.
    4  *
    5  * This software was developed by Semihalf under sponsorship from
    6  * the FreeBSD Foundation.
    7  *
    8  * Redistribution and use in source and binary forms, with or without
    9  * modification, are permitted provided that the following conditions
   10  * are met:
   11  * 1. Redistributions of source code must retain the above copyright
   12  *    notice, this list of conditions and the following disclaimer.
   13  * 2. Redistributions in binary form must reproduce the above copyright
   14  *    notice, this list of conditions and the following disclaimer in the
   15  *    documentation and/or other materials provided with the distribution.
   16  *
   17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
   18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   20  * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
   21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   27  * SUCH DAMAGE.
   28  */
   29 
   30 #include <sys/cdefs.h>
   31 __FBSDID("$FreeBSD: releng/11.1/sys/mips/beri/beri_simplebus.c 297199 2016-03-22 22:25:08Z jhibbits $");
   32 
   33 #include "opt_platform.h"
   34 #include <sys/param.h>
   35 #include <sys/systm.h>
   36 #include <sys/ktr.h>
   37 #include <sys/kernel.h>
   38 #include <sys/module.h>
   39 #include <sys/bus.h>
   40 #include <sys/rman.h>
   41 #include <sys/malloc.h>
   42 
   43 #include <dev/ofw/ofw_bus.h>
   44 #include <dev/ofw/ofw_bus_subr.h>
   45 #include <dev/ofw/openfirm.h>
   46 
   47 #include <dev/fdt/fdt_common.h>
   48 #include "fdt_ic_if.h"
   49 #include "ofw_bus_if.h"
   50 
   51 #ifdef DEBUG
   52 #define debugf(fmt, args...) do { printf("%s(): ", __func__);   \
   53     printf(fmt,##args); } while (0)
   54 #else
   55 #define debugf(fmt, args...)
   56 #endif
   57 
   58 static MALLOC_DEFINE(M_SIMPLEBUS, "simplebus", "simplebus devices information");
   59 
   60 struct simplebus_softc {
   61         int     sc_addr_cells;
   62         int     sc_size_cells;
   63 };
   64 
   65 struct simplebus_devinfo {
   66         struct ofw_bus_devinfo  di_ofw;
   67         struct resource_list    di_res;
   68 
   69         /* Interrupts sense-level info for this device */
   70         struct fdt_sense_level  di_intr_sl[DI_MAX_INTR_NUM];
   71 };
   72 
   73 /*
   74  * Prototypes.
   75  */
   76 static int simplebus_probe(device_t);
   77 static int simplebus_attach(device_t);
   78 
   79 static int simplebus_print_child(device_t, device_t);
   80 static int simplebus_setup_intr(device_t, device_t, struct resource *, int,
   81     driver_filter_t *, driver_intr_t *, void *, void **);
   82 static int simplebus_teardown_intr(device_t, device_t, struct resource *,
   83     void *);
   84 
   85 static int simplebus_activate_resource(device_t, device_t, int, int,
   86     struct resource *);
   87 static struct resource *simplebus_alloc_resource(device_t, device_t, int,
   88     int *, rman_res_t, rman_res_t, rman_res_t, u_int);
   89 static int simplebus_deactivate_resource(device_t, device_t, int, int,
   90     struct resource *);
   91 static int simplebus_release_resource(device_t, device_t, int, int,
   92     struct resource *);
   93 static device_t simplebus_get_interrupt_parent(device_t);
   94 static struct resource_list *simplebus_get_resource_list(device_t, device_t);
   95 
   96 static ofw_bus_get_devinfo_t simplebus_get_devinfo;
   97 
   98 /*
   99  * Bus interface definition.
  100  */
  101 static device_method_t simplebus_methods[] = {
  102         /* Device interface */
  103         DEVMETHOD(device_probe,         simplebus_probe),
  104         DEVMETHOD(device_attach,        simplebus_attach),
  105         DEVMETHOD(device_detach,        bus_generic_detach),
  106         DEVMETHOD(device_shutdown,      bus_generic_shutdown),
  107         DEVMETHOD(device_suspend,       bus_generic_suspend),
  108         DEVMETHOD(device_resume,        bus_generic_resume),
  109 
  110         /* Bus interface */
  111         DEVMETHOD(bus_print_child,      simplebus_print_child),
  112         DEVMETHOD(bus_alloc_resource,   simplebus_alloc_resource),
  113         DEVMETHOD(bus_release_resource, simplebus_release_resource),
  114         DEVMETHOD(bus_activate_resource, simplebus_activate_resource),
  115         DEVMETHOD(bus_deactivate_resource, simplebus_deactivate_resource),
  116         DEVMETHOD(bus_setup_intr,       simplebus_setup_intr),
  117         DEVMETHOD(bus_teardown_intr,    simplebus_teardown_intr),
  118         DEVMETHOD(bus_get_resource_list, simplebus_get_resource_list),
  119 
  120         /* OFW bus interface */
  121         DEVMETHOD(ofw_bus_get_devinfo,  simplebus_get_devinfo),
  122         DEVMETHOD(ofw_bus_get_compat,   ofw_bus_gen_get_compat),
  123         DEVMETHOD(ofw_bus_get_model,    ofw_bus_gen_get_model),
  124         DEVMETHOD(ofw_bus_get_name,     ofw_bus_gen_get_name),
  125         DEVMETHOD(ofw_bus_get_node,     ofw_bus_gen_get_node),
  126         DEVMETHOD(ofw_bus_get_type,     ofw_bus_gen_get_type),
  127 
  128         { 0, 0 }
  129 };
  130 
  131 static driver_t simplebus_driver = {
  132         "simplebus",
  133         simplebus_methods,
  134         sizeof(struct simplebus_softc)
  135 };
  136 
  137 devclass_t simplebus_devclass;
  138 
  139 DRIVER_MODULE(beri_simplebus, ofwbus, simplebus_driver, simplebus_devclass, 0,
  140     0);
  141 DRIVER_MODULE(beri_simplebus, simplebus, simplebus_driver, simplebus_devclass,
  142     0, 0);
  143 
  144 static int
  145 simplebus_probe(device_t dev)
  146 {
  147 
  148         if (!ofw_bus_status_okay(dev))
  149                 return (ENXIO);
  150 
  151         if (!ofw_bus_is_compatible(dev, "simple-bus"))
  152                 return (ENXIO);
  153 
  154         device_set_desc(dev, "Flattened device tree simple bus (BERI version)");
  155 
  156         return (BUS_PROBE_SPECIFIC);
  157 }
  158 
  159 static int
  160 simplebus_attach(device_t dev)
  161 {
  162         device_t dev_child;
  163         struct simplebus_devinfo *di;
  164         struct simplebus_softc *sc;
  165         phandle_t dt_node, dt_child;
  166 
  167         sc = device_get_softc(dev);
  168 
  169         /*
  170          * Walk simple-bus and add direct subordinates as our children.
  171          */
  172         dt_node = ofw_bus_get_node(dev);
  173         for (dt_child = OF_child(dt_node); dt_child != 0;
  174             dt_child = OF_peer(dt_child)) {
  175 
  176                 /* Check and process 'status' property. */
  177                 if (!(fdt_is_enabled(dt_child)))
  178                         continue;
  179 
  180                 if (!(fdt_pm_is_enabled(dt_child)))
  181                         continue;
  182 
  183                 di = malloc(sizeof(*di), M_SIMPLEBUS, M_WAITOK | M_ZERO);
  184 
  185                 if (ofw_bus_gen_setup_devinfo(&di->di_ofw, dt_child) != 0) {
  186                         free(di, M_SIMPLEBUS);
  187                         device_printf(dev, "could not set up devinfo\n");
  188                         continue;
  189                 }
  190 
  191                 resource_list_init(&di->di_res);
  192                 if (fdt_reg_to_rl(dt_child, &di->di_res)) {
  193                         device_printf(dev,
  194                             "%s: could not process 'reg' "
  195                             "property\n", di->di_ofw.obd_name);
  196                         ofw_bus_gen_destroy_devinfo(&di->di_ofw);
  197                         free(di, M_SIMPLEBUS);
  198                         continue;
  199                 }
  200 
  201                 if (ofw_bus_intr_to_rl(dev, dt_child, &di->di_res, NULL)) {
  202                         device_printf(dev, "%s: could not process "
  203                             "'interrupts' property\n", di->di_ofw.obd_name);
  204                         resource_list_free(&di->di_res);
  205                         ofw_bus_gen_destroy_devinfo(&di->di_ofw);
  206                         free(di, M_SIMPLEBUS);
  207                         continue;
  208                 }
  209 
  210                 /* Add newbus device for this FDT node */
  211                 dev_child = device_add_child(dev, NULL, -1);
  212                 if (dev_child == NULL) {
  213                         device_printf(dev, "could not add child: %s\n",
  214                             di->di_ofw.obd_name);
  215                         resource_list_free(&di->di_res);
  216                         ofw_bus_gen_destroy_devinfo(&di->di_ofw);
  217                         free(di, M_SIMPLEBUS);
  218                         continue;
  219                 }
  220 #ifdef DEBUG
  221                 device_printf(dev, "added child: %s\n\n", di->di_ofw.obd_name);
  222 #endif
  223                 device_set_ivars(dev_child, di);
  224         }
  225 
  226         return (bus_generic_attach(dev));
  227 }
  228 
  229 static int
  230 simplebus_print_child(device_t dev, device_t child)
  231 {
  232         device_t ip;
  233         struct simplebus_devinfo *di;
  234         struct resource_list *rl;
  235         int rv;
  236 
  237         di = device_get_ivars(child);
  238         rl = &di->di_res;
  239 
  240         rv = 0;
  241         rv += bus_print_child_header(dev, child);
  242         rv += resource_list_print_type(rl, "mem", SYS_RES_MEMORY, "%#jx");
  243         rv += resource_list_print_type(rl, "irq", SYS_RES_IRQ, "%jd");
  244         if ((ip = simplebus_get_interrupt_parent(child)) != NULL)
  245                 rv += printf(" (%s)", device_get_nameunit(ip));
  246         rv += bus_print_child_footer(dev, child);
  247 
  248         return (rv);
  249 }
  250 
  251 static struct resource *
  252 simplebus_alloc_resource(device_t bus, device_t child, int type, int *rid,
  253     rman_res_t start, rman_res_t end, rman_res_t count, u_int flags)
  254 {
  255         device_t ic;
  256         struct simplebus_devinfo *di;
  257         struct resource_list_entry *rle;
  258 
  259         /*
  260          * Request for the default allocation with a given rid: use resource
  261          * list stored in the local device info.
  262          */
  263         if (RMAN_IS_DEFAULT_RANGE(start, end)) {
  264                 if ((di = device_get_ivars(child)) == NULL)
  265                         return (NULL);
  266 
  267                 if (type == SYS_RES_IOPORT)
  268                         type = SYS_RES_MEMORY;
  269 
  270                 rle = resource_list_find(&di->di_res, type, *rid);
  271                 if (rle == NULL) {
  272                         if (bootverbose)
  273                                 device_printf(bus, "no default resources for "
  274                                     "rid = %d, type = %d\n", *rid, type);
  275                         return (NULL);
  276                 }
  277                 start = rle->start;
  278                 end = rle->end;
  279                 count = rle->count;
  280         }
  281 
  282         if (type == SYS_RES_IRQ &&
  283             (ic = simplebus_get_interrupt_parent(child)) != NULL)
  284                 return(FDT_IC_ALLOC_INTR(ic, child, rid, start, flags));
  285 
  286         return (bus_generic_alloc_resource(bus, child, type, rid, start, end,
  287             count, flags));
  288 }
  289 
  290 static int
  291 simplebus_activate_resource(device_t dev, device_t child, int type, int rid,
  292     struct resource *r)
  293 {
  294         device_t ic;
  295 
  296         if (type == SYS_RES_IRQ &&
  297             (ic = simplebus_get_interrupt_parent(child)) != NULL)
  298                 return (FDT_IC_ACTIVATE_INTR(ic, r));
  299 
  300         return (bus_generic_activate_resource(dev, child, type, rid, r));
  301 }
  302 
  303 static int
  304 simplebus_deactivate_resource(device_t dev, device_t child, int type, int rid,
  305     struct resource *r)
  306 {
  307         device_t ic;
  308 
  309         if (type == SYS_RES_IRQ &&
  310             (ic = simplebus_get_interrupt_parent(child)) != NULL)
  311                 return (FDT_IC_DEACTIVATE_INTR(ic, r));
  312 
  313         return (bus_generic_deactivate_resource(dev, child, type, rid, r));
  314 }
  315 
  316 static int
  317 simplebus_release_resource(device_t dev, device_t child, int type, int rid,
  318     struct resource *r)
  319 {
  320         device_t ic;
  321 
  322         if (type == SYS_RES_IRQ &&
  323             (ic = simplebus_get_interrupt_parent(child)) != NULL)
  324                 return (FDT_IC_RELEASE_INTR(ic, r));
  325 
  326         return (bus_generic_release_resource(dev, child, type, rid, r));
  327 }
  328 
  329 static struct resource_list *
  330 simplebus_get_resource_list(device_t bus, device_t child)
  331 {
  332         struct simplebus_devinfo *di;
  333 
  334         di = device_get_ivars(child);
  335         return (&di->di_res);
  336 }
  337 
  338 static device_t
  339 simplebus_get_interrupt_parent(device_t dev)
  340 {
  341         struct simplebus_devinfo *di;
  342         struct fdt_ic *ic;
  343         device_t ip;
  344         phandle_t ph, iph;
  345 
  346         ip = NULL;
  347 
  348         di = device_get_ivars(dev);
  349         if (di == NULL)
  350                 return (NULL);
  351 
  352         if (OF_getencprop(di->di_ofw.obd_node, "interrupt-parent", &iph,
  353             sizeof(iph)) > 0) {
  354                 ph = OF_node_from_xref(iph);
  355                 SLIST_FOREACH(ic, &fdt_ic_list_head, fdt_ics) {
  356                         if (ic->iph == ph) {
  357                                 ip = ic->dev;
  358                                 break;
  359                         }
  360                 }
  361         }
  362         return (ip);
  363 }
  364 
  365 static int
  366 simplebus_setup_intr(device_t bus, device_t child, struct resource *res,
  367     int flags, driver_filter_t *filter, driver_intr_t *ihand, void *arg,
  368     void **cookiep)
  369 {
  370         struct simplebus_devinfo *di;
  371         device_t ic;
  372         enum intr_trigger trig;
  373         enum intr_polarity pol;
  374         int error, irq, rid;
  375 
  376         di = device_get_ivars(child);
  377         if (di == NULL)
  378                 return (ENXIO);
  379 
  380         if (res == NULL)
  381                 return (EINVAL);
  382 
  383         rid = rman_get_rid(res);
  384         if (rid >= DI_MAX_INTR_NUM)
  385                 return (ENOENT);
  386 
  387         ic = simplebus_get_interrupt_parent(child);
  388 
  389         trig = di->di_intr_sl[rid].trig;
  390         pol = di->di_intr_sl[rid].pol;
  391         if (trig != INTR_TRIGGER_CONFORM || pol != INTR_POLARITY_CONFORM) {
  392                 irq = rman_get_start(res);
  393                 if (ic != NULL)
  394                         error = FDT_IC_CONFIG_INTR(ic, irq, trig, pol);
  395                 else
  396                         error = bus_generic_config_intr(bus, irq, trig, pol);
  397                 if (error)
  398                         return (error);
  399         }
  400 
  401         if (ic != NULL)
  402                 error = FDT_IC_SETUP_INTR(ic, child, res, flags, filter,
  403                     ihand, arg, cookiep);
  404         else
  405                 error = bus_generic_setup_intr(bus, child, res, flags, filter,
  406                     ihand, arg, cookiep);
  407         return (error);
  408 }
  409 
  410 static int
  411 simplebus_teardown_intr(device_t bus, device_t child, struct resource *res,
  412     void *cookie)
  413 {
  414         device_t ic;
  415 
  416         if ((ic = simplebus_get_interrupt_parent(child)) != NULL)
  417                 return (FDT_IC_TEARDOWN_INTR(ic, child, res, cookie));
  418 
  419         return (bus_generic_teardown_intr(bus, child, res, cookie));
  420 }
  421 
  422 static const struct ofw_bus_devinfo *
  423 simplebus_get_devinfo(device_t bus, device_t child)
  424 {
  425         struct simplebus_devinfo *di;
  426 
  427         di = device_get_ivars(child);
  428         return (&di->di_ofw);
  429 }

Cache object: 062d90f242c38131210526c3bbaa58c4


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.