xref: /openbmc/qemu/hw/core/bus.c (revision cb711a6d)
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.1 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 
qbus_set_hotplug_handler(BusState * bus,Object * handler)26 void qbus_set_hotplug_handler(BusState *bus, Object *handler)
27 {
28     object_property_set_link(OBJECT(bus), QDEV_HOTPLUG_HANDLER_PROPERTY,
29                              handler, &error_abort);
30 }
31 
qbus_set_bus_hotplug_handler(BusState * bus)32 void qbus_set_bus_hotplug_handler(BusState *bus)
33 {
34     qbus_set_hotplug_handler(bus, OBJECT(bus));
35 }
36 
qbus_walk_children(BusState * bus,qdev_walkerfn * pre_devfn,qbus_walkerfn * pre_busfn,qdev_walkerfn * post_devfn,qbus_walkerfn * post_busfn,void * opaque)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     WITH_RCU_READ_LOCK_GUARD() {
53         QTAILQ_FOREACH_RCU(kid, &bus->children, sibling) {
54             err = qdev_walk_children(kid->child,
55                                      pre_devfn, pre_busfn,
56                                      post_devfn, post_busfn, opaque);
57             if (err < 0) {
58                 return err;
59             }
60         }
61     }
62 
63     if (post_busfn) {
64         err = post_busfn(bus, opaque);
65         if (err) {
66             return err;
67         }
68     }
69 
70     return 0;
71 }
72 
bus_cold_reset(BusState * bus)73 void bus_cold_reset(BusState *bus)
74 {
75     resettable_reset(OBJECT(bus), RESET_TYPE_COLD);
76 }
77 
bus_is_in_reset(BusState * bus)78 bool bus_is_in_reset(BusState *bus)
79 {
80     return resettable_is_in_reset(OBJECT(bus));
81 }
82 
bus_get_reset_state(Object * obj)83 static ResettableState *bus_get_reset_state(Object *obj)
84 {
85     BusState *bus = BUS(obj);
86     return &bus->reset;
87 }
88 
bus_reset_child_foreach(Object * obj,ResettableChildCallback cb,void * opaque,ResetType type)89 static void bus_reset_child_foreach(Object *obj, ResettableChildCallback cb,
90                                     void *opaque, ResetType type)
91 {
92     BusState *bus = BUS(obj);
93     BusChild *kid;
94 
95     WITH_RCU_READ_LOCK_GUARD() {
96         QTAILQ_FOREACH_RCU(kid, &bus->children, sibling) {
97             cb(OBJECT(kid->child), opaque, type);
98         }
99     }
100 }
101 
qbus_init_internal(BusState * bus,DeviceState * parent,const char * name)102 static void qbus_init_internal(BusState *bus, DeviceState *parent,
103                                const char *name)
104 {
105     const char *typename = object_get_typename(OBJECT(bus));
106     BusClass *bc;
107     int i, bus_id;
108 
109     bus->parent = parent;
110 
111     if (name) {
112         bus->name = g_strdup(name);
113     } else if (bus->parent && bus->parent->id) {
114         /* parent device has id -> use it plus parent-bus-id for bus name */
115         bus_id = bus->parent->num_child_bus;
116         bus->name = g_strdup_printf("%s.%d", bus->parent->id, bus_id);
117     } else {
118         /* no id -> use lowercase bus type plus global bus-id for bus name */
119         bc = BUS_GET_CLASS(bus);
120         bus_id = bc->automatic_ids++;
121         bus->name = g_strdup_printf("%s.%d", typename, bus_id);
122         for (i = 0; bus->name[i]; i++) {
123             bus->name[i] = qemu_tolower(bus->name[i]);
124         }
125     }
126 
127     if (bus->parent) {
128         QLIST_INSERT_HEAD(&bus->parent->child_bus, bus, sibling);
129         bus->parent->num_child_bus++;
130         object_property_add_child(OBJECT(bus->parent), bus->name, OBJECT(bus));
131         object_unref(OBJECT(bus));
132     } else {
133         /* The only bus without a parent is the main system bus */
134         assert(bus == sysbus_get_default());
135     }
136 }
137 
bus_unparent(Object * obj)138 static void bus_unparent(Object *obj)
139 {
140     BusState *bus = BUS(obj);
141     BusChild *kid;
142 
143     /* Only the main system bus has no parent, and that bus is never freed */
144     assert(bus->parent);
145 
146     while ((kid = QTAILQ_FIRST(&bus->children)) != NULL) {
147         DeviceState *dev = kid->child;
148         object_unparent(OBJECT(dev));
149     }
150     QLIST_REMOVE(bus, sibling);
151     bus->parent->num_child_bus--;
152     bus->parent = NULL;
153 }
154 
qbus_init(void * bus,size_t size,const char * typename,DeviceState * parent,const char * name)155 void qbus_init(void *bus, size_t size, const char *typename,
156                DeviceState *parent, const char *name)
157 {
158     object_initialize(bus, size, typename);
159     qbus_init_internal(bus, parent, name);
160 }
161 
qbus_new(const char * typename,DeviceState * parent,const char * name)162 BusState *qbus_new(const char *typename, DeviceState *parent, const char *name)
163 {
164     BusState *bus;
165 
166     bus = BUS(object_new(typename));
167     qbus_init_internal(bus, parent, name);
168 
169     return bus;
170 }
171 
qbus_realize(BusState * bus,Error ** errp)172 bool qbus_realize(BusState *bus, Error **errp)
173 {
174     return object_property_set_bool(OBJECT(bus), "realized", true, errp);
175 }
176 
qbus_unrealize(BusState * bus)177 void qbus_unrealize(BusState *bus)
178 {
179     object_property_set_bool(OBJECT(bus), "realized", false, &error_abort);
180 }
181 
bus_get_realized(Object * obj,Error ** errp)182 static bool bus_get_realized(Object *obj, Error **errp)
183 {
184     BusState *bus = BUS(obj);
185 
186     return bus->realized;
187 }
188 
bus_set_realized(Object * obj,bool value,Error ** errp)189 static void bus_set_realized(Object *obj, bool value, Error **errp)
190 {
191     BusState *bus = BUS(obj);
192     BusClass *bc = BUS_GET_CLASS(bus);
193     BusChild *kid;
194 
195     if (value && !bus->realized) {
196         if (bc->realize) {
197             bc->realize(bus, errp);
198         }
199 
200         /* TODO: recursive realization */
201     } else if (!value && bus->realized) {
202         WITH_RCU_READ_LOCK_GUARD() {
203             QTAILQ_FOREACH_RCU(kid, &bus->children, sibling) {
204                 DeviceState *dev = kid->child;
205                 qdev_unrealize(dev);
206             }
207         }
208         if (bc->unrealize) {
209             bc->unrealize(bus);
210         }
211     }
212 
213     bus->realized = value;
214 }
215 
qbus_initfn(Object * obj)216 static void qbus_initfn(Object *obj)
217 {
218     BusState *bus = BUS(obj);
219 
220     QTAILQ_INIT(&bus->children);
221     object_property_add_link(obj, QDEV_HOTPLUG_HANDLER_PROPERTY,
222                              TYPE_HOTPLUG_HANDLER,
223                              (Object **)&bus->hotplug_handler,
224                              object_property_allow_set_link,
225                              0);
226     object_property_add_bool(obj, "realized",
227                              bus_get_realized, bus_set_realized);
228 }
229 
default_bus_get_fw_dev_path(DeviceState * dev)230 static char *default_bus_get_fw_dev_path(DeviceState *dev)
231 {
232     return g_strdup(object_get_typename(OBJECT(dev)));
233 }
234 
bus_class_init(ObjectClass * class,void * data)235 static void bus_class_init(ObjectClass *class, void *data)
236 {
237     BusClass *bc = BUS_CLASS(class);
238     ResettableClass *rc = RESETTABLE_CLASS(class);
239 
240     class->unparent = bus_unparent;
241     bc->get_fw_dev_path = default_bus_get_fw_dev_path;
242 
243     rc->get_state = bus_get_reset_state;
244     rc->child_foreach = bus_reset_child_foreach;
245 }
246 
qbus_finalize(Object * obj)247 static void qbus_finalize(Object *obj)
248 {
249     BusState *bus = BUS(obj);
250 
251     g_free(bus->name);
252 }
253 
254 static const TypeInfo bus_info = {
255     .name = TYPE_BUS,
256     .parent = TYPE_OBJECT,
257     .instance_size = sizeof(BusState),
258     .abstract = true,
259     .class_size = sizeof(BusClass),
260     .instance_init = qbus_initfn,
261     .instance_finalize = qbus_finalize,
262     .class_init = bus_class_init,
263     .interfaces = (InterfaceInfo[]) {
264         { TYPE_RESETTABLE_INTERFACE },
265         { }
266     },
267 };
268 
bus_register_types(void)269 static void bus_register_types(void)
270 {
271     type_register_static(&bus_info);
272 }
273 
274 type_init(bus_register_types)
275