hw/core/bus.c

   1 /*
   2  *  Dynamic device configuration and creation -- buses.
   3  *
   4  *  Copyright (c) 2009 CodeSourcery
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 #include "qemu/osdep.h"
  21 #include "hw/qdev-properties.h"
  22 #include "qemu/ctype.h"
  23 #include "qemu/module.h"
  24 #include "qapi/error.h"
  25
  26 void qbus_set_hotplug_handler(BusState *bus, Object *handler, Error **errp)
  27 {
  28     object_property_set_link(OBJECT(bus), OBJECT(handler),
  29                              QDEV_HOTPLUG_HANDLER_PROPERTY, errp);
  30 }
  31
  32 void qbus_set_bus_hotplug_handler(BusState *bus, Error **errp)
  33 {
  34     qbus_set_hotplug_handler(bus, OBJECT(bus), errp);
  35 }
  36
  37 int qbus_walk_children(BusState *bus,
  38                        qdev_walkerfn *pre_devfn, qbus_walkerfn *pre_busfn,
  39                        qdev_walkerfn *post_devfn, qbus_walkerfn *post_busfn,
  40                        void *opaque)
  41 {
  42     BusChild *kid;
  43     int err;
  44
  45     if (pre_busfn) {
  46         err = pre_busfn(bus, opaque);
  47         if (err) {
  48             return err;
  49         }
  50     }
  51
  52     QTAILQ_FOREACH(kid, &bus->children, sibling) {
  53         err = qdev_walk_children(kid->child,
  54                                  pre_devfn, pre_busfn,
  55                                  post_devfn, post_busfn, opaque);
  56         if (err < 0) {
  57             return err;
  58         }
  59     }
  60
  61     if (post_busfn) {
  62         err = post_busfn(bus, opaque);
  63         if (err) {
  64             return err;
  65         }
  66     }
  67
  68     return 0;
  69 }
  70
  71 void bus_cold_reset(BusState *bus)
  72 {
  73     resettable_reset(OBJECT(bus), RESET_TYPE_COLD);
  74 }
  75
  76 bool bus_is_in_reset(BusState *bus)
  77 {
  78     return resettable_is_in_reset(OBJECT(bus));
  79 }
  80
  81 static ResettableState *bus_get_reset_state(Object *obj)
  82 {
  83     BusState *bus = BUS(obj);
  84     return &bus->reset;
  85 }
  86
  87 static void bus_reset_child_foreach(Object *obj, ResettableChildCallback cb,
  88                                     void *opaque, ResetType type)
  89 {
  90     BusState *bus = BUS(obj);
  91     BusChild *kid;
  92
  93     QTAILQ_FOREACH(kid, &bus->children, sibling) {
  94         cb(OBJECT(kid->child), opaque, type);
  95     }
  96 }
  97
  98 static void qbus_realize(BusState *bus, DeviceState *parent, const char *name)
  99 {
 100     const char *typename = object_get_typename(OBJECT(bus));
 101     BusClass *bc;
 102     int i, bus_id;
 103
 104     bus->parent = parent;
 105
 106     if (name) {
 107         bus->name = g_strdup(name);
 108     } else if (bus->parent && bus->parent->id) {
 109         /* parent device has id -> use it plus parent-bus-id for bus name */
 110         bus_id = bus->parent->num_child_bus;
 111         bus->name = g_strdup_printf("%s.%d", bus->parent->id, bus_id);
 112     } else {
 113         /* no id -> use lowercase bus type plus global bus-id for bus name */
 114         bc = BUS_GET_CLASS(bus);
 115         bus_id = bc->automatic_ids++;
 116         bus->name = g_strdup_printf("%s.%d", typename, bus_id);
 117         for (i = 0; bus->name[i]; i++) {
 118             bus->name[i] = qemu_tolower(bus->name[i]);
 119         }
 120     }
 121
 122     if (bus->parent) {
 123         QLIST_INSERT_HEAD(&bus->parent->child_bus, bus, sibling);
 124         bus->parent->num_child_bus++;
 125         object_property_add_child(OBJECT(bus->parent), bus->name, OBJECT(bus), NULL);
 126         object_unref(OBJECT(bus));
 127     } else {
 128         /* The only bus without a parent is the main system bus */
 129         assert(bus == sysbus_get_default());
 130     }
 131 }
 132
 133 static void bus_unparent(Object *obj)
 134 {
 135     BusState *bus = BUS(obj);
 136     BusChild *kid;
 137
 138     /* Only the main system bus has no parent, and that bus is never freed */
 139     assert(bus->parent);
 140
 141     while ((kid = QTAILQ_FIRST(&bus->children)) != NULL) {
 142         DeviceState *dev = kid->child;
 143         object_unparent(OBJECT(dev));
 144     }
 145     QLIST_REMOVE(bus, sibling);
 146     bus->parent->num_child_bus--;
 147     bus->parent = NULL;
 148 }
 149
 150 void qbus_create_inplace(void *bus, size_t size, const char *typename,
 151                          DeviceState *parent, const char *name)
 152 {
 153     object_initialize(bus, size, typename);
 154     qbus_realize(bus, parent, name);
 155 }
 156
 157 BusState *qbus_create(const char *typename, DeviceState *parent, const char *name)
 158 {
 159     BusState *bus;
 160
 161     bus = BUS(object_new(typename));
 162     qbus_realize(bus, parent, name);
 163
 164     return bus;
 165 }
 166
 167 static bool bus_get_realized(Object *obj, Error **errp)
 168 {
 169     BusState *bus = BUS(obj);
 170
 171     return bus->realized;
 172 }
 173
 174 static void bus_set_realized(Object *obj, bool value, Error **errp)
 175 {
 176     BusState *bus = BUS(obj);
 177     BusClass *bc = BUS_GET_CLASS(bus);
 178     BusChild *kid;
 179     Error *local_err = NULL;
 180
 181     if (value && !bus->realized) {
 182         if (bc->realize) {
 183             bc->realize(bus, &local_err);
 184         }
 185
 186         /* TODO: recursive realization */
 187     } else if (!value && bus->realized) {
 188         QTAILQ_FOREACH(kid, &bus->children, sibling) {
 189             DeviceState *dev = kid->child;
 190             object_property_set_bool(OBJECT(dev), false, "realized",
 191                                      &local_err);
 192             if (local_err != NULL) {
 193                 break;
 194             }
 195         }
 196         if (bc->unrealize && local_err == NULL) {
 197             bc->unrealize(bus, &local_err);
 198         }
 199     }
 200
 201     if (local_err != NULL) {
 202         error_propagate(errp, local_err);
 203         return;
 204     }
 205
 206     bus->realized = value;
 207 }
 208
 209 static void qbus_initfn(Object *obj)
 210 {
 211     BusState *bus = BUS(obj);
 212
 213     QTAILQ_INIT(&bus->children);
 214     object_property_add_link(obj, QDEV_HOTPLUG_HANDLER_PROPERTY,
 215                              TYPE_HOTPLUG_HANDLER,
 216                              (Object **)&bus->hotplug_handler,
 217                              object_property_allow_set_link,
 218                              0,
 219                              NULL);
 220     object_property_add_bool(obj, "realized",
 221                              bus_get_realized, bus_set_realized, NULL);
 222 }
 223
 224 static char *default_bus_get_fw_dev_path(DeviceState *dev)
 225 {
 226     return g_strdup(object_get_typename(OBJECT(dev)));
 227 }
 228
 229 /**
 230  * bus_phases_reset:
 231  * Transition reset method for buses to allow moving
 232  * smoothly from legacy reset method to multi-phases
 233  */
 234 static void bus_phases_reset(BusState *bus)
 235 {
 236     ResettableClass *rc = RESETTABLE_GET_CLASS(bus);
 237
 238     if (rc->phases.enter) {
 239         rc->phases.enter(OBJECT(bus), RESET_TYPE_COLD);
 240     }
 241     if (rc->phases.hold) {
 242         rc->phases.hold(OBJECT(bus));
 243     }
 244     if (rc->phases.exit) {
 245         rc->phases.exit(OBJECT(bus));
 246     }
 247 }
 248
 249 static void bus_transitional_reset(Object *obj)
 250 {
 251     BusClass *bc = BUS_GET_CLASS(obj);
 252
 253     /*
 254      * This will call either @bus_phases_reset (for multi-phases transitioned
 255      * buses) or a bus's specific method for not-yet transitioned buses.
 256      * In both case, it does not reset children.
 257      */
 258     if (bc->reset) {
 259         bc->reset(BUS(obj));
 260     }
 261 }
 262
 263 /**
 264  * bus_get_transitional_reset:
 265  * check if the bus's class is ready for multi-phase
 266  */
 267 static ResettableTrFunction bus_get_transitional_reset(Object *obj)
 268 {
 269     BusClass *dc = BUS_GET_CLASS(obj);
 270     if (dc->reset != bus_phases_reset) {
 271         /*
 272          * dc->reset has been overridden by a subclass,
 273          * the bus is not ready for multi phase yet.
 274          */
 275         return bus_transitional_reset;
 276     }
 277     return NULL;
 278 }
 279
 280 static void bus_class_init(ObjectClass *class, void *data)
 281 {
 282     BusClass *bc = BUS_CLASS(class);
 283     ResettableClass *rc = RESETTABLE_CLASS(class);
 284
 285     class->unparent = bus_unparent;
 286     bc->get_fw_dev_path = default_bus_get_fw_dev_path;
 287
 288     rc->get_state = bus_get_reset_state;
 289     rc->child_foreach = bus_reset_child_foreach;
 290
 291     /*
 292      * @bus_phases_reset is put as the default reset method below, allowing
 293      * to do the multi-phase transition from base classes to leaf classes. It
 294      * allows a legacy-reset Bus class to extend a multi-phases-reset
 295      * Bus class for the following reason:
 296      * + If a base class B has been moved to multi-phase, then it does not
 297      *   override this default reset method and may have defined phase methods.
 298      * + A child class C (extending class B) which uses
 299      *   bus_class_set_parent_reset() (or similar means) to override the
 300      *   reset method will still work as expected. @bus_phases_reset function
 301      *   will be registered as the parent reset method and effectively call
 302      *   parent reset phases.
 303      */
 304     bc->reset = bus_phases_reset;
 305     rc->get_transitional_function = bus_get_transitional_reset;
 306 }
 307
 308 static void qbus_finalize(Object *obj)
 309 {
 310     BusState *bus = BUS(obj);
 311
 312     g_free(bus->name);
 313 }
 314
 315 static const TypeInfo bus_info = {
 316     .name = TYPE_BUS,
 317     .parent = TYPE_OBJECT,
 318     .instance_size = sizeof(BusState),
 319     .abstract = true,
 320     .class_size = sizeof(BusClass),
 321     .instance_init = qbus_initfn,
 322     .instance_finalize = qbus_finalize,
 323     .class_init = bus_class_init,
 324     .interfaces = (InterfaceInfo[]) {
 325         { TYPE_RESETTABLE_INTERFACE },
 326         { }
 327     },
 328 };
 329
 330 static void bus_register_types(void)
 331 {
 332     type_register_static(&bus_info);
 333 }
 334
 335 type_init(bus_register_types)