]>
Commit | Line | Data |
---|---|---|
aae9460e PB |
1 | /* |
2 | * Dynamic device configuration and creation. | |
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 | |
8167ee88 | 17 | * License along with this library; if not, see <http://www.gnu.org/licenses/>. |
aae9460e PB |
18 | */ |
19 | ||
20 | /* The theory here is that it should be possible to create a machine without | |
21 | knowledge of specific devices. Historically board init routines have | |
22 | passed a bunch of arguments to each device, requiring the board know | |
23 | exactly which device it is dealing with. This file provides an abstract | |
24 | API for device configuration and initialization. Devices will generally | |
25 | inherit from a particular bus (e.g. PCI or I2C) rather than | |
26 | this API directly. */ | |
27 | ||
83c9f4ca | 28 | #include "hw/qdev.h" |
6b1566cb | 29 | #include "hw/fw-path-provider.h" |
9c17d615 | 30 | #include "sysemu/sysemu.h" |
7b1b5d19 | 31 | #include "qapi/error.h" |
b4a42f81 | 32 | #include "qapi/qmp/qerror.h" |
7b1b5d19 | 33 | #include "qapi/visitor.h" |
0402a5d6 | 34 | #include "qapi/qmp/qjson.h" |
0ee4de6c | 35 | #include "hw/hotplug.h" |
b7454548 | 36 | #include "hw/boards.h" |
24b699fb | 37 | #include "qapi-event.h" |
aae9460e | 38 | |
ee46d8a5 | 39 | int qdev_hotplug = 0; |
0ac8ef71 AW |
40 | static bool qdev_hot_added = false; |
41 | static bool qdev_hot_removed = false; | |
3418bd25 | 42 | |
4be9f0d1 AL |
43 | const VMStateDescription *qdev_get_vmsd(DeviceState *dev) |
44 | { | |
6e008585 AL |
45 | DeviceClass *dc = DEVICE_GET_CLASS(dev); |
46 | return dc->vmsd; | |
4be9f0d1 AL |
47 | } |
48 | ||
4be9f0d1 AL |
49 | const char *qdev_fw_name(DeviceState *dev) |
50 | { | |
6e008585 | 51 | DeviceClass *dc = DEVICE_GET_CLASS(dev); |
4be9f0d1 | 52 | |
6e008585 AL |
53 | if (dc->fw_name) { |
54 | return dc->fw_name; | |
4be9f0d1 AL |
55 | } |
56 | ||
57 | return object_get_typename(OBJECT(dev)); | |
58 | } | |
59 | ||
ca2cc788 PB |
60 | static void qdev_property_add_legacy(DeviceState *dev, Property *prop, |
61 | Error **errp); | |
62 | ||
0866aca1 | 63 | static void bus_remove_child(BusState *bus, DeviceState *child) |
0c17542d | 64 | { |
0866aca1 AL |
65 | BusChild *kid; |
66 | ||
67 | QTAILQ_FOREACH(kid, &bus->children, sibling) { | |
68 | if (kid->child == child) { | |
69 | char name[32]; | |
70 | ||
71 | snprintf(name, sizeof(name), "child[%d]", kid->index); | |
72 | QTAILQ_REMOVE(&bus->children, kid, sibling); | |
9d127820 PB |
73 | |
74 | /* This gives back ownership of kid->child back to us. */ | |
0866aca1 | 75 | object_property_del(OBJECT(bus), name, NULL); |
9d127820 | 76 | object_unref(OBJECT(kid->child)); |
0866aca1 AL |
77 | g_free(kid); |
78 | return; | |
79 | } | |
80 | } | |
81 | } | |
82 | ||
83 | static void bus_add_child(BusState *bus, DeviceState *child) | |
84 | { | |
85 | char name[32]; | |
86 | BusChild *kid = g_malloc0(sizeof(*kid)); | |
0c17542d | 87 | |
0c17542d | 88 | if (qdev_hotplug) { |
39b888bd | 89 | assert(qbus_is_hotpluggable(bus)); |
0c17542d | 90 | } |
a5296ca9 | 91 | |
0866aca1 AL |
92 | kid->index = bus->max_index++; |
93 | kid->child = child; | |
9d127820 | 94 | object_ref(OBJECT(kid->child)); |
a5296ca9 | 95 | |
0866aca1 AL |
96 | QTAILQ_INSERT_HEAD(&bus->children, kid, sibling); |
97 | ||
9d127820 | 98 | /* This transfers ownership of kid->child to the property. */ |
0866aca1 AL |
99 | snprintf(name, sizeof(name), "child[%d]", kid->index); |
100 | object_property_add_link(OBJECT(bus), name, | |
101 | object_get_typename(OBJECT(child)), | |
39f72ef9 SH |
102 | (Object **)&kid->child, |
103 | NULL, /* read-only property */ | |
104 | 0, /* return ownership on prop deletion */ | |
105 | NULL); | |
0866aca1 AL |
106 | } |
107 | ||
108 | void qdev_set_parent_bus(DeviceState *dev, BusState *bus) | |
109 | { | |
9fbe6127 | 110 | dev->parent_bus = bus; |
62d7ba66 | 111 | object_ref(OBJECT(bus)); |
0866aca1 | 112 | bus_add_child(bus, dev); |
0c17542d MA |
113 | } |
114 | ||
aae9460e PB |
115 | /* Create a new device. This only initializes the device state structure |
116 | and allows properties to be set. qdev_init should be called to | |
117 | initialize the actual device emulation. */ | |
02e2da45 | 118 | DeviceState *qdev_create(BusState *bus, const char *name) |
0bcdeda7 BS |
119 | { |
120 | DeviceState *dev; | |
121 | ||
122 | dev = qdev_try_create(bus, name); | |
123 | if (!dev) { | |
e92714c7 | 124 | if (bus) { |
312fd5f2 | 125 | error_report("Unknown device '%s' for bus '%s'", name, |
23e3fbec | 126 | object_get_typename(OBJECT(bus))); |
e92714c7 | 127 | } else { |
312fd5f2 | 128 | error_report("Unknown device '%s' for default sysbus", name); |
e92714c7 | 129 | } |
01ed1d52 | 130 | abort(); |
0bcdeda7 BS |
131 | } |
132 | ||
133 | return dev; | |
134 | } | |
135 | ||
da57febf | 136 | DeviceState *qdev_try_create(BusState *bus, const char *type) |
aae9460e | 137 | { |
9fbe6127 AL |
138 | DeviceState *dev; |
139 | ||
da57febf | 140 | if (object_class_by_name(type) == NULL) { |
4ed658ca AF |
141 | return NULL; |
142 | } | |
da57febf | 143 | dev = DEVICE(object_new(type)); |
9fbe6127 AL |
144 | if (!dev) { |
145 | return NULL; | |
146 | } | |
147 | ||
10c4c98a | 148 | if (!bus) { |
68694897 | 149 | bus = sysbus_get_default(); |
10c4c98a GH |
150 | } |
151 | ||
9fbe6127 | 152 | qdev_set_parent_bus(dev, bus); |
b09995ae | 153 | object_unref(OBJECT(dev)); |
9fbe6127 | 154 | return dev; |
aae9460e PB |
155 | } |
156 | ||
157 | /* Initialize a device. Device properties should be set before calling | |
158 | this function. IRQs and MMIO regions should be connected/mapped after | |
18cfeb52 MA |
159 | calling this function. |
160 | On failure, destroy the device and return negative value. | |
161 | Return 0 on success. */ | |
81a322d4 | 162 | int qdev_init(DeviceState *dev) |
aae9460e | 163 | { |
249d4172 | 164 | Error *local_err = NULL; |
959f733a | 165 | |
7983c8a3 | 166 | assert(!dev->realized); |
6e008585 | 167 | |
249d4172 AF |
168 | object_property_set_bool(OBJECT(dev), true, "realized", &local_err); |
169 | if (local_err != NULL) { | |
cffc5113 | 170 | qerror_report_err(local_err); |
249d4172 | 171 | error_free(local_err); |
02a5c4c9 | 172 | object_unparent(OBJECT(dev)); |
249d4172 | 173 | return -1; |
18cfeb52 | 174 | } |
249d4172 AF |
175 | return 0; |
176 | } | |
da57febf | 177 | |
a7737e44 | 178 | static void device_realize(DeviceState *dev, Error **errp) |
249d4172 AF |
179 | { |
180 | DeviceClass *dc = DEVICE_GET_CLASS(dev); | |
da57febf | 181 | |
249d4172 AF |
182 | if (dc->init) { |
183 | int rc = dc->init(dev); | |
184 | if (rc < 0) { | |
a7737e44 | 185 | error_setg(errp, "Device initialization failed."); |
249d4172 AF |
186 | return; |
187 | } | |
5ab28c83 | 188 | } |
02e2da45 PB |
189 | } |
190 | ||
fe6c2117 AF |
191 | static void device_unrealize(DeviceState *dev, Error **errp) |
192 | { | |
193 | DeviceClass *dc = DEVICE_GET_CLASS(dev); | |
194 | ||
195 | if (dc->exit) { | |
196 | int rc = dc->exit(dev); | |
197 | if (rc < 0) { | |
198 | error_setg(errp, "Device exit failed."); | |
199 | return; | |
200 | } | |
201 | } | |
202 | } | |
203 | ||
4d2ffa08 JK |
204 | void qdev_set_legacy_instance_id(DeviceState *dev, int alias_id, |
205 | int required_for_version) | |
206 | { | |
7983c8a3 | 207 | assert(!dev->realized); |
4d2ffa08 JK |
208 | dev->instance_id_alias = alias_id; |
209 | dev->alias_required_for_version = required_for_version; | |
210 | } | |
211 | ||
56f9107e | 212 | void qdev_unplug(DeviceState *dev, Error **errp) |
3418bd25 | 213 | { |
6e008585 AL |
214 | DeviceClass *dc = DEVICE_GET_CLASS(dev); |
215 | ||
39b888bd | 216 | if (dev->parent_bus && !qbus_is_hotpluggable(dev->parent_bus)) { |
56f9107e LC |
217 | error_set(errp, QERR_BUS_NO_HOTPLUG, dev->parent_bus->name); |
218 | return; | |
3418bd25 | 219 | } |
593831de | 220 | |
1a37eca1 IM |
221 | if (!dc->hotpluggable) { |
222 | error_set(errp, QERR_DEVICE_NO_HOTPLUG, | |
223 | object_get_typename(OBJECT(dev))); | |
224 | return; | |
225 | } | |
226 | ||
0ac8ef71 AW |
227 | qdev_hot_removed = true; |
228 | ||
5e954943 IM |
229 | if (dev->parent_bus && dev->parent_bus->hotplug_handler) { |
230 | hotplug_handler_unplug(dev->parent_bus->hotplug_handler, dev, errp); | |
231 | } else { | |
232 | assert(dc->unplug != NULL); | |
233 | if (dc->unplug(dev) < 0) { /* legacy handler */ | |
234 | error_set(errp, QERR_UNDEFINED_ERROR); | |
235 | } | |
56f9107e | 236 | } |
3418bd25 GH |
237 | } |
238 | ||
ec990eb6 AL |
239 | static int qdev_reset_one(DeviceState *dev, void *opaque) |
240 | { | |
94afdadc | 241 | device_reset(dev); |
ec990eb6 AL |
242 | |
243 | return 0; | |
244 | } | |
245 | ||
b4694b7c IY |
246 | static int qbus_reset_one(BusState *bus, void *opaque) |
247 | { | |
0d936928 AL |
248 | BusClass *bc = BUS_GET_CLASS(bus); |
249 | if (bc->reset) { | |
dcc20931 | 250 | bc->reset(bus); |
b4694b7c IY |
251 | } |
252 | return 0; | |
253 | } | |
254 | ||
5af0a04b IY |
255 | void qdev_reset_all(DeviceState *dev) |
256 | { | |
dcc20931 | 257 | qdev_walk_children(dev, NULL, NULL, qdev_reset_one, qbus_reset_one, NULL); |
5af0a04b IY |
258 | } |
259 | ||
d0508c36 PB |
260 | void qbus_reset_all(BusState *bus) |
261 | { | |
dcc20931 | 262 | qbus_walk_children(bus, NULL, NULL, qdev_reset_one, qbus_reset_one, NULL); |
d0508c36 PB |
263 | } |
264 | ||
80376c3f IY |
265 | void qbus_reset_all_fn(void *opaque) |
266 | { | |
267 | BusState *bus = opaque; | |
d0508c36 | 268 | qbus_reset_all(bus); |
80376c3f IY |
269 | } |
270 | ||
3418bd25 GH |
271 | /* can be used as ->unplug() callback for the simple cases */ |
272 | int qdev_simple_unplug_cb(DeviceState *dev) | |
273 | { | |
274 | /* just zap it */ | |
02a5c4c9 | 275 | object_unparent(OBJECT(dev)); |
3418bd25 GH |
276 | return 0; |
277 | } | |
278 | ||
3b29a101 MT |
279 | |
280 | /* Like qdev_init(), but terminate program via error_report() instead of | |
e23a1b33 MA |
281 | returning an error value. This is okay during machine creation. |
282 | Don't use for hotplug, because there callers need to recover from | |
283 | failure. Exception: if you know the device's init() callback can't | |
284 | fail, then qdev_init_nofail() can't fail either, and is therefore | |
285 | usable even then. But relying on the device implementation that | |
286 | way is somewhat unclean, and best avoided. */ | |
287 | void qdev_init_nofail(DeviceState *dev) | |
288 | { | |
7de3abe5 AL |
289 | const char *typename = object_get_typename(OBJECT(dev)); |
290 | ||
bd6c9a61 | 291 | if (qdev_init(dev) < 0) { |
7de3abe5 | 292 | error_report("Initialization of device %s failed", typename); |
bd6c9a61 MA |
293 | exit(1); |
294 | } | |
e23a1b33 MA |
295 | } |
296 | ||
3418bd25 GH |
297 | void qdev_machine_creation_done(void) |
298 | { | |
299 | /* | |
300 | * ok, initial machine setup is done, starting from now we can | |
301 | * only create hotpluggable devices | |
302 | */ | |
303 | qdev_hotplug = 1; | |
304 | } | |
305 | ||
0ac8ef71 AW |
306 | bool qdev_machine_modified(void) |
307 | { | |
308 | return qdev_hot_added || qdev_hot_removed; | |
309 | } | |
310 | ||
02e2da45 | 311 | BusState *qdev_get_parent_bus(DeviceState *dev) |
aae9460e | 312 | { |
02e2da45 | 313 | return dev->parent_bus; |
aae9460e PB |
314 | } |
315 | ||
a5f54290 PC |
316 | static NamedGPIOList *qdev_get_named_gpio_list(DeviceState *dev, |
317 | const char *name) | |
318 | { | |
319 | NamedGPIOList *ngl; | |
320 | ||
321 | QLIST_FOREACH(ngl, &dev->gpios, node) { | |
322 | /* NULL is a valid and matchable name, otherwise do a normal | |
323 | * strcmp match. | |
324 | */ | |
325 | if ((!ngl->name && !name) || | |
326 | (name && ngl->name && strcmp(name, ngl->name) == 0)) { | |
327 | return ngl; | |
328 | } | |
329 | } | |
330 | ||
331 | ngl = g_malloc0(sizeof(*ngl)); | |
332 | ngl->name = g_strdup(name); | |
333 | QLIST_INSERT_HEAD(&dev->gpios, ngl, node); | |
334 | return ngl; | |
335 | } | |
336 | ||
337 | void qdev_init_gpio_in_named(DeviceState *dev, qemu_irq_handler handler, | |
338 | const char *name, int n) | |
339 | { | |
a69bef1c | 340 | int i; |
a5f54290 | 341 | NamedGPIOList *gpio_list = qdev_get_named_gpio_list(dev, name); |
a69bef1c | 342 | char *propname = g_strdup_printf("%s[*]", name ? name : "unnamed-gpio-in"); |
a5f54290 | 343 | |
b235a71f | 344 | assert(gpio_list->num_out == 0 || !name); |
a5f54290 PC |
345 | gpio_list->in = qemu_extend_irqs(gpio_list->in, gpio_list->num_in, handler, |
346 | dev, n); | |
a69bef1c PC |
347 | |
348 | for (i = gpio_list->num_in; i < gpio_list->num_in + n; i++) { | |
349 | object_property_add_child(OBJECT(dev), propname, | |
350 | OBJECT(gpio_list->in[i]), &error_abort); | |
351 | } | |
352 | g_free(propname); | |
353 | ||
a5f54290 PC |
354 | gpio_list->num_in += n; |
355 | } | |
356 | ||
aae9460e PB |
357 | void qdev_init_gpio_in(DeviceState *dev, qemu_irq_handler handler, int n) |
358 | { | |
a5f54290 PC |
359 | qdev_init_gpio_in_named(dev, handler, NULL, n); |
360 | } | |
361 | ||
362 | void qdev_init_gpio_out_named(DeviceState *dev, qemu_irq *pins, | |
363 | const char *name, int n) | |
364 | { | |
688b057a | 365 | int i; |
a5f54290 | 366 | NamedGPIOList *gpio_list = qdev_get_named_gpio_list(dev, name); |
688b057a | 367 | char *propname = g_strdup_printf("%s[*]", name ? name : "unnamed-gpio-out"); |
a5f54290 | 368 | |
b235a71f | 369 | assert(gpio_list->num_in == 0 || !name); |
a5f54290 PC |
370 | assert(gpio_list->num_out == 0); |
371 | gpio_list->num_out = n; | |
372 | gpio_list->out = pins; | |
688b057a PC |
373 | |
374 | for (i = 0; i < n; ++i) { | |
375 | memset(&pins[i], 0, sizeof(*pins)); | |
376 | object_property_add_link(OBJECT(dev), propname, TYPE_IRQ, | |
377 | (Object **)&pins[i], | |
378 | object_property_allow_set_link, | |
379 | OBJ_PROP_LINK_UNREF_ON_RELEASE, | |
380 | &error_abort); | |
381 | } | |
382 | g_free(propname); | |
aae9460e PB |
383 | } |
384 | ||
385 | void qdev_init_gpio_out(DeviceState *dev, qemu_irq *pins, int n) | |
386 | { | |
a5f54290 PC |
387 | qdev_init_gpio_out_named(dev, pins, NULL, n); |
388 | } | |
389 | ||
390 | qemu_irq qdev_get_gpio_in_named(DeviceState *dev, const char *name, int n) | |
391 | { | |
392 | NamedGPIOList *gpio_list = qdev_get_named_gpio_list(dev, name); | |
393 | ||
394 | assert(n >= 0 && n < gpio_list->num_in); | |
395 | return gpio_list->in[n]; | |
aae9460e PB |
396 | } |
397 | ||
398 | qemu_irq qdev_get_gpio_in(DeviceState *dev, int n) | |
399 | { | |
a5f54290 PC |
400 | return qdev_get_gpio_in_named(dev, NULL, n); |
401 | } | |
402 | ||
403 | void qdev_connect_gpio_out_named(DeviceState *dev, const char *name, int n, | |
404 | qemu_irq pin) | |
405 | { | |
406 | NamedGPIOList *gpio_list = qdev_get_named_gpio_list(dev, name); | |
407 | ||
408 | assert(n >= 0 && n < gpio_list->num_out); | |
409 | gpio_list->out[n] = pin; | |
aae9460e PB |
410 | } |
411 | ||
412 | void qdev_connect_gpio_out(DeviceState * dev, int n, qemu_irq pin) | |
413 | { | |
a5f54290 | 414 | qdev_connect_gpio_out_named(dev, NULL, n, pin); |
aae9460e PB |
415 | } |
416 | ||
02e2da45 | 417 | BusState *qdev_get_child_bus(DeviceState *dev, const char *name) |
4d6ae674 | 418 | { |
02e2da45 | 419 | BusState *bus; |
4d6ae674 | 420 | |
72cf2d4f | 421 | QLIST_FOREACH(bus, &dev->child_bus, sibling) { |
4d6ae674 | 422 | if (strcmp(name, bus->name) == 0) { |
02e2da45 | 423 | return bus; |
4d6ae674 PB |
424 | } |
425 | } | |
426 | return NULL; | |
427 | } | |
428 | ||
0293214b PB |
429 | int qbus_walk_children(BusState *bus, |
430 | qdev_walkerfn *pre_devfn, qbus_walkerfn *pre_busfn, | |
431 | qdev_walkerfn *post_devfn, qbus_walkerfn *post_busfn, | |
432 | void *opaque) | |
81699d8a | 433 | { |
0866aca1 | 434 | BusChild *kid; |
81699d8a AL |
435 | int err; |
436 | ||
0293214b PB |
437 | if (pre_busfn) { |
438 | err = pre_busfn(bus, opaque); | |
81699d8a AL |
439 | if (err) { |
440 | return err; | |
441 | } | |
442 | } | |
443 | ||
0866aca1 | 444 | QTAILQ_FOREACH(kid, &bus->children, sibling) { |
0293214b PB |
445 | err = qdev_walk_children(kid->child, |
446 | pre_devfn, pre_busfn, | |
447 | post_devfn, post_busfn, opaque); | |
81699d8a AL |
448 | if (err < 0) { |
449 | return err; | |
450 | } | |
451 | } | |
452 | ||
0293214b PB |
453 | if (post_busfn) { |
454 | err = post_busfn(bus, opaque); | |
455 | if (err) { | |
456 | return err; | |
457 | } | |
458 | } | |
459 | ||
81699d8a AL |
460 | return 0; |
461 | } | |
462 | ||
0293214b PB |
463 | int qdev_walk_children(DeviceState *dev, |
464 | qdev_walkerfn *pre_devfn, qbus_walkerfn *pre_busfn, | |
465 | qdev_walkerfn *post_devfn, qbus_walkerfn *post_busfn, | |
466 | void *opaque) | |
81699d8a AL |
467 | { |
468 | BusState *bus; | |
469 | int err; | |
470 | ||
0293214b PB |
471 | if (pre_devfn) { |
472 | err = pre_devfn(dev, opaque); | |
81699d8a AL |
473 | if (err) { |
474 | return err; | |
475 | } | |
476 | } | |
477 | ||
478 | QLIST_FOREACH(bus, &dev->child_bus, sibling) { | |
0293214b PB |
479 | err = qbus_walk_children(bus, pre_devfn, pre_busfn, |
480 | post_devfn, post_busfn, opaque); | |
81699d8a AL |
481 | if (err < 0) { |
482 | return err; | |
483 | } | |
484 | } | |
485 | ||
0293214b PB |
486 | if (post_devfn) { |
487 | err = post_devfn(dev, opaque); | |
488 | if (err) { | |
489 | return err; | |
490 | } | |
491 | } | |
492 | ||
81699d8a AL |
493 | return 0; |
494 | } | |
495 | ||
a2ee6b4f | 496 | DeviceState *qdev_find_recursive(BusState *bus, const char *id) |
3418bd25 | 497 | { |
0866aca1 AL |
498 | BusChild *kid; |
499 | DeviceState *ret; | |
3418bd25 GH |
500 | BusState *child; |
501 | ||
0866aca1 AL |
502 | QTAILQ_FOREACH(kid, &bus->children, sibling) { |
503 | DeviceState *dev = kid->child; | |
504 | ||
505 | if (dev->id && strcmp(dev->id, id) == 0) { | |
3418bd25 | 506 | return dev; |
0866aca1 AL |
507 | } |
508 | ||
3418bd25 GH |
509 | QLIST_FOREACH(child, &dev->child_bus, sibling) { |
510 | ret = qdev_find_recursive(child, id); | |
511 | if (ret) { | |
512 | return ret; | |
513 | } | |
514 | } | |
515 | } | |
516 | return NULL; | |
517 | } | |
518 | ||
013e1182 | 519 | static void qbus_realize(BusState *bus, DeviceState *parent, const char *name) |
02e2da45 | 520 | { |
ac7d1ba6 | 521 | const char *typename = object_get_typename(OBJECT(bus)); |
61de3676 | 522 | BusClass *bc; |
d271de9f | 523 | char *buf; |
61de3676 | 524 | int i, len, bus_id; |
02e2da45 | 525 | |
013e1182 PB |
526 | bus->parent = parent; |
527 | ||
528 | if (name) { | |
529 | bus->name = g_strdup(name); | |
ac7d1ba6 | 530 | } else if (bus->parent && bus->parent->id) { |
61de3676 AG |
531 | /* parent device has id -> use it plus parent-bus-id for bus name */ |
532 | bus_id = bus->parent->num_child_bus; | |
533 | ||
ac7d1ba6 | 534 | len = strlen(bus->parent->id) + 16; |
7267c094 | 535 | buf = g_malloc(len); |
61de3676 | 536 | snprintf(buf, len, "%s.%d", bus->parent->id, bus_id); |
d271de9f GH |
537 | bus->name = buf; |
538 | } else { | |
61de3676 AG |
539 | /* no id -> use lowercase bus type plus global bus-id for bus name */ |
540 | bc = BUS_GET_CLASS(bus); | |
541 | bus_id = bc->automatic_ids++; | |
542 | ||
0d936928 | 543 | len = strlen(typename) + 16; |
7267c094 | 544 | buf = g_malloc(len); |
61de3676 AG |
545 | len = snprintf(buf, len, "%s.%d", typename, bus_id); |
546 | for (i = 0; i < len; i++) { | |
bb87ece5 | 547 | buf[i] = qemu_tolower(buf[i]); |
61de3676 | 548 | } |
d271de9f GH |
549 | bus->name = buf; |
550 | } | |
551 | ||
ac7d1ba6 AL |
552 | if (bus->parent) { |
553 | QLIST_INSERT_HEAD(&bus->parent->child_bus, bus, sibling); | |
554 | bus->parent->num_child_bus++; | |
555 | object_property_add_child(OBJECT(bus->parent), bus->name, OBJECT(bus), NULL); | |
b09995ae | 556 | object_unref(OBJECT(bus)); |
8185d216 | 557 | } else if (bus != sysbus_get_default()) { |
80376c3f IY |
558 | /* TODO: once all bus devices are qdevified, |
559 | only reset handler for main_system_bus should be registered here. */ | |
560 | qemu_register_reset(qbus_reset_all_fn, bus); | |
02e2da45 | 561 | } |
cd739fb6 GH |
562 | } |
563 | ||
6853d27a PB |
564 | static void bus_unparent(Object *obj) |
565 | { | |
566 | BusState *bus = BUS(obj); | |
567 | BusChild *kid; | |
568 | ||
569 | while ((kid = QTAILQ_FIRST(&bus->children)) != NULL) { | |
570 | DeviceState *dev = kid->child; | |
02a5c4c9 | 571 | object_unparent(OBJECT(dev)); |
6853d27a PB |
572 | } |
573 | if (bus->parent) { | |
574 | QLIST_REMOVE(bus, sibling); | |
575 | bus->parent->num_child_bus--; | |
576 | bus->parent = NULL; | |
577 | } else { | |
578 | assert(bus != sysbus_get_default()); /* main_system_bus is never freed */ | |
579 | qemu_unregister_reset(qbus_reset_all_fn, bus); | |
580 | } | |
581 | } | |
582 | ||
a7737e44 | 583 | static bool bus_get_realized(Object *obj, Error **errp) |
02e7f85d BD |
584 | { |
585 | BusState *bus = BUS(obj); | |
586 | ||
587 | return bus->realized; | |
588 | } | |
589 | ||
a7737e44 | 590 | static void bus_set_realized(Object *obj, bool value, Error **errp) |
02e7f85d BD |
591 | { |
592 | BusState *bus = BUS(obj); | |
593 | BusClass *bc = BUS_GET_CLASS(bus); | |
5942a190 | 594 | BusChild *kid; |
02e7f85d BD |
595 | Error *local_err = NULL; |
596 | ||
597 | if (value && !bus->realized) { | |
598 | if (bc->realize) { | |
599 | bc->realize(bus, &local_err); | |
02e7f85d | 600 | } |
5942a190 PB |
601 | |
602 | /* TODO: recursive realization */ | |
02e7f85d | 603 | } else if (!value && bus->realized) { |
5942a190 PB |
604 | QTAILQ_FOREACH(kid, &bus->children, sibling) { |
605 | DeviceState *dev = kid->child; | |
606 | object_property_set_bool(OBJECT(dev), false, "realized", | |
607 | &local_err); | |
608 | if (local_err != NULL) { | |
609 | break; | |
610 | } | |
611 | } | |
612 | if (bc->unrealize && local_err == NULL) { | |
02e7f85d | 613 | bc->unrealize(bus, &local_err); |
02e7f85d BD |
614 | } |
615 | } | |
616 | ||
b7b34d05 PB |
617 | if (local_err != NULL) { |
618 | error_propagate(errp, local_err); | |
619 | return; | |
620 | } | |
02e7f85d | 621 | |
b7b34d05 | 622 | bus->realized = value; |
02e7f85d BD |
623 | } |
624 | ||
fb17dfe0 | 625 | void qbus_create_inplace(void *bus, size_t size, const char *typename, |
0d936928 | 626 | DeviceState *parent, const char *name) |
cd739fb6 | 627 | { |
213f0c4f | 628 | object_initialize(bus, size, typename); |
013e1182 | 629 | qbus_realize(bus, parent, name); |
02e2da45 | 630 | } |
cae4956e | 631 | |
0d936928 | 632 | BusState *qbus_create(const char *typename, DeviceState *parent, const char *name) |
2da8bb92 | 633 | { |
cd739fb6 GH |
634 | BusState *bus; |
635 | ||
0d936928 | 636 | bus = BUS(object_new(typename)); |
013e1182 | 637 | qbus_realize(bus, parent, name); |
ac7d1ba6 | 638 | |
02e2da45 | 639 | return bus; |
2da8bb92 IY |
640 | } |
641 | ||
0d936928 AL |
642 | static char *bus_get_fw_dev_path(BusState *bus, DeviceState *dev) |
643 | { | |
644 | BusClass *bc = BUS_GET_CLASS(bus); | |
645 | ||
646 | if (bc->get_fw_dev_path) { | |
647 | return bc->get_fw_dev_path(dev); | |
131ec1bd | 648 | } |
0d936928 AL |
649 | |
650 | return NULL; | |
131ec1bd GH |
651 | } |
652 | ||
6b1566cb PB |
653 | static char *qdev_get_fw_dev_path_from_handler(BusState *bus, DeviceState *dev) |
654 | { | |
655 | Object *obj = OBJECT(dev); | |
656 | char *d = NULL; | |
657 | ||
658 | while (!d && obj->parent) { | |
659 | obj = obj->parent; | |
660 | d = fw_path_provider_try_get_dev_path(obj, bus, dev); | |
661 | } | |
662 | return d; | |
663 | } | |
664 | ||
1ca4d09a GN |
665 | static int qdev_get_fw_dev_path_helper(DeviceState *dev, char *p, int size) |
666 | { | |
667 | int l = 0; | |
668 | ||
669 | if (dev && dev->parent_bus) { | |
670 | char *d; | |
671 | l = qdev_get_fw_dev_path_helper(dev->parent_bus->parent, p, size); | |
6b1566cb PB |
672 | d = qdev_get_fw_dev_path_from_handler(dev->parent_bus, dev); |
673 | if (!d) { | |
674 | d = bus_get_fw_dev_path(dev->parent_bus, dev); | |
675 | } | |
0d936928 | 676 | if (d) { |
1ca4d09a | 677 | l += snprintf(p + l, size - l, "%s", d); |
7267c094 | 678 | g_free(d); |
1ca4d09a | 679 | } else { |
bbfa18fc | 680 | return l; |
1ca4d09a GN |
681 | } |
682 | } | |
683 | l += snprintf(p + l , size - l, "/"); | |
684 | ||
685 | return l; | |
686 | } | |
687 | ||
688 | char* qdev_get_fw_dev_path(DeviceState *dev) | |
689 | { | |
690 | char path[128]; | |
691 | int l; | |
692 | ||
693 | l = qdev_get_fw_dev_path_helper(dev, path, 128); | |
694 | ||
695 | path[l-1] = '\0'; | |
696 | ||
a5cf8262 | 697 | return g_strdup(path); |
1ca4d09a | 698 | } |
85ed303b | 699 | |
09e5ab63 | 700 | char *qdev_get_dev_path(DeviceState *dev) |
85ed303b | 701 | { |
0d936928 | 702 | BusClass *bc; |
09e5ab63 AL |
703 | |
704 | if (!dev || !dev->parent_bus) { | |
705 | return NULL; | |
706 | } | |
707 | ||
0d936928 AL |
708 | bc = BUS_GET_CLASS(dev->parent_bus); |
709 | if (bc->get_dev_path) { | |
710 | return bc->get_dev_path(dev); | |
09e5ab63 AL |
711 | } |
712 | ||
713 | return NULL; | |
44677ded | 714 | } |
a5296ca9 AL |
715 | |
716 | /** | |
717 | * Legacy property handling | |
718 | */ | |
719 | ||
57c9fafe | 720 | static void qdev_get_legacy_property(Object *obj, Visitor *v, void *opaque, |
a5296ca9 AL |
721 | const char *name, Error **errp) |
722 | { | |
57c9fafe | 723 | DeviceState *dev = DEVICE(obj); |
a5296ca9 AL |
724 | Property *prop = opaque; |
725 | ||
e3cb6ba6 PB |
726 | char buffer[1024]; |
727 | char *ptr = buffer; | |
a5296ca9 | 728 | |
e3cb6ba6 PB |
729 | prop->info->print(dev, prop, buffer, sizeof(buffer)); |
730 | visit_type_str(v, &ptr, name, errp); | |
a5296ca9 AL |
731 | } |
732 | ||
a5296ca9 AL |
733 | /** |
734 | * @qdev_add_legacy_property - adds a legacy property | |
735 | * | |
736 | * Do not use this is new code! Properties added through this interface will | |
ca2cc788 | 737 | * be given names and types in the "legacy" namespace. |
a5296ca9 | 738 | * |
68ee3569 PB |
739 | * Legacy properties are string versions of other OOM properties. The format |
740 | * of the string depends on the property type. | |
a5296ca9 | 741 | */ |
f5a014d2 SW |
742 | static void qdev_property_add_legacy(DeviceState *dev, Property *prop, |
743 | Error **errp) | |
a5296ca9 | 744 | { |
7ce7ffe0 | 745 | gchar *name; |
a5296ca9 | 746 | |
f3be016d | 747 | /* Register pointer properties as legacy properties */ |
03ff7770 | 748 | if (!prop->info->print && prop->info->get) { |
68ee3569 PB |
749 | return; |
750 | } | |
f3be016d | 751 | |
ca2cc788 | 752 | name = g_strdup_printf("legacy-%s", prop->name); |
7ce7ffe0 | 753 | object_property_add(OBJECT(dev), name, "str", |
68ee3569 | 754 | prop->info->print ? qdev_get_legacy_property : prop->info->get, |
03ff7770 | 755 | NULL, |
57c9fafe AL |
756 | NULL, |
757 | prop, errp); | |
a5296ca9 | 758 | |
ca2cc788 PB |
759 | g_free(name); |
760 | } | |
761 | ||
762 | /** | |
763 | * @qdev_property_add_static - add a @Property to a device. | |
764 | * | |
765 | * Static properties access data in a struct. The actual type of the | |
766 | * property and the field depends on the property type. | |
767 | */ | |
768 | void qdev_property_add_static(DeviceState *dev, Property *prop, | |
769 | Error **errp) | |
770 | { | |
fdae245f PB |
771 | Error *local_err = NULL; |
772 | Object *obj = OBJECT(dev); | |
773 | ||
d822979b PB |
774 | /* |
775 | * TODO qdev_prop_ptr does not have getters or setters. It must | |
776 | * go now that it can be replaced with links. The test should be | |
777 | * removed along with it: all static properties are read/write. | |
778 | */ | |
779 | if (!prop->info->get && !prop->info->set) { | |
780 | return; | |
781 | } | |
782 | ||
fdae245f | 783 | object_property_add(obj, prop->name, prop->info->name, |
57c9fafe | 784 | prop->info->get, prop->info->set, |
dd0ba250 | 785 | prop->info->release, |
fdae245f PB |
786 | prop, &local_err); |
787 | ||
788 | if (local_err) { | |
789 | error_propagate(errp, local_err); | |
790 | return; | |
791 | } | |
792 | if (prop->qtype == QTYPE_NONE) { | |
793 | return; | |
794 | } | |
795 | ||
796 | if (prop->qtype == QTYPE_QBOOL) { | |
5433a0a8 | 797 | object_property_set_bool(obj, prop->defval, prop->name, &error_abort); |
fdae245f PB |
798 | } else if (prop->info->enum_table) { |
799 | object_property_set_str(obj, prop->info->enum_table[prop->defval], | |
5433a0a8 | 800 | prop->name, &error_abort); |
fdae245f | 801 | } else if (prop->qtype == QTYPE_QINT) { |
5433a0a8 | 802 | object_property_set_int(obj, prop->defval, prop->name, &error_abort); |
fdae245f | 803 | } |
6a146eba | 804 | } |
1de81d28 | 805 | |
67cc7e0a SH |
806 | /* @qdev_alias_all_properties - Add alias properties to the source object for |
807 | * all qdev properties on the target DeviceState. | |
808 | */ | |
809 | void qdev_alias_all_properties(DeviceState *target, Object *source) | |
810 | { | |
811 | ObjectClass *class; | |
812 | Property *prop; | |
813 | ||
814 | class = object_get_class(OBJECT(target)); | |
815 | do { | |
816 | DeviceClass *dc = DEVICE_CLASS(class); | |
817 | ||
818 | for (prop = dc->props; prop && prop->name; prop++) { | |
819 | object_property_add_alias(source, prop->name, | |
820 | OBJECT(target), prop->name, | |
821 | &error_abort); | |
822 | } | |
823 | class = object_class_get_parent(class); | |
824 | } while (class != object_class_by_name(TYPE_DEVICE)); | |
825 | } | |
826 | ||
a7737e44 | 827 | static bool device_get_realized(Object *obj, Error **errp) |
249d4172 AF |
828 | { |
829 | DeviceState *dev = DEVICE(obj); | |
830 | return dev->realized; | |
831 | } | |
832 | ||
a7737e44 | 833 | static void device_set_realized(Object *obj, bool value, Error **errp) |
249d4172 AF |
834 | { |
835 | DeviceState *dev = DEVICE(obj); | |
836 | DeviceClass *dc = DEVICE_GET_CLASS(dev); | |
5c21ce77 | 837 | BusState *bus; |
249d4172 AF |
838 | Error *local_err = NULL; |
839 | ||
1a37eca1 | 840 | if (dev->hotplugged && !dc->hotpluggable) { |
a7737e44 | 841 | error_set(errp, QERR_DEVICE_NO_HOTPLUG, object_get_typename(obj)); |
1a37eca1 IM |
842 | return; |
843 | } | |
844 | ||
249d4172 | 845 | if (value && !dev->realized) { |
d578029e | 846 | if (!obj->parent) { |
249d4172 AF |
847 | static int unattached_count; |
848 | gchar *name = g_strdup_printf("device[%d]", unattached_count++); | |
849 | ||
850 | object_property_add_child(container_get(qdev_get_machine(), | |
851 | "/unattached"), | |
d578029e | 852 | name, obj, &error_abort); |
249d4172 AF |
853 | g_free(name); |
854 | } | |
855 | ||
a7ddba52 IM |
856 | if (dc->realize) { |
857 | dc->realize(dev, &local_err); | |
858 | } | |
859 | ||
1d45a705 GA |
860 | if (local_err != NULL) { |
861 | goto fail; | |
862 | } | |
863 | ||
864 | if (dev->parent_bus && dev->parent_bus->hotplug_handler) { | |
5e954943 IM |
865 | hotplug_handler_plug(dev->parent_bus->hotplug_handler, |
866 | dev, &local_err); | |
1d45a705 | 867 | } else if (object_dynamic_cast(qdev_get_machine(), TYPE_MACHINE)) { |
b7454548 IM |
868 | HotplugHandler *hotplug_ctrl; |
869 | MachineState *machine = MACHINE(qdev_get_machine()); | |
870 | MachineClass *mc = MACHINE_GET_CLASS(machine); | |
871 | ||
872 | if (mc->get_hotplug_handler) { | |
873 | hotplug_ctrl = mc->get_hotplug_handler(machine, dev); | |
874 | if (hotplug_ctrl) { | |
875 | hotplug_handler_plug(hotplug_ctrl, dev, &local_err); | |
876 | } | |
877 | } | |
5e954943 IM |
878 | } |
879 | ||
1d45a705 GA |
880 | if (local_err != NULL) { |
881 | goto post_realize_fail; | |
882 | } | |
883 | ||
884 | if (qdev_get_vmsd(dev)) { | |
249d4172 AF |
885 | vmstate_register_with_alias_id(dev, -1, qdev_get_vmsd(dev), dev, |
886 | dev->instance_id_alias, | |
887 | dev->alias_required_for_version); | |
888 | } | |
1d45a705 GA |
889 | |
890 | QLIST_FOREACH(bus, &dev->child_bus, sibling) { | |
891 | object_property_set_bool(OBJECT(bus), true, "realized", | |
5c21ce77 | 892 | &local_err); |
1d45a705 GA |
893 | if (local_err != NULL) { |
894 | goto child_realize_fail; | |
5c21ce77 BD |
895 | } |
896 | } | |
1d45a705 | 897 | if (dev->hotplugged) { |
249d4172 AF |
898 | device_reset(dev); |
899 | } | |
352e8da7 | 900 | dev->pending_deleted_event = false; |
249d4172 | 901 | } else if (!value && dev->realized) { |
cd4520ad | 902 | Error **local_errp = NULL; |
5c21ce77 | 903 | QLIST_FOREACH(bus, &dev->child_bus, sibling) { |
cd4520ad | 904 | local_errp = local_err ? NULL : &local_err; |
5c21ce77 | 905 | object_property_set_bool(OBJECT(bus), false, "realized", |
cd4520ad | 906 | local_errp); |
5c21ce77 | 907 | } |
cd4520ad | 908 | if (qdev_get_vmsd(dev)) { |
fe6c2117 AF |
909 | vmstate_unregister(dev, qdev_get_vmsd(dev), dev); |
910 | } | |
cd4520ad GA |
911 | if (dc->unrealize) { |
912 | local_errp = local_err ? NULL : &local_err; | |
913 | dc->unrealize(dev, local_errp); | |
249d4172 | 914 | } |
352e8da7 | 915 | dev->pending_deleted_event = true; |
249d4172 AF |
916 | } |
917 | ||
918 | if (local_err != NULL) { | |
1d45a705 | 919 | goto fail; |
249d4172 AF |
920 | } |
921 | ||
922 | dev->realized = value; | |
1d45a705 GA |
923 | return; |
924 | ||
925 | child_realize_fail: | |
926 | QLIST_FOREACH(bus, &dev->child_bus, sibling) { | |
927 | object_property_set_bool(OBJECT(bus), false, "realized", | |
928 | NULL); | |
929 | } | |
930 | ||
931 | if (qdev_get_vmsd(dev)) { | |
932 | vmstate_unregister(dev, qdev_get_vmsd(dev), dev); | |
933 | } | |
934 | ||
935 | post_realize_fail: | |
936 | if (dc->unrealize) { | |
937 | dc->unrealize(dev, NULL); | |
938 | } | |
939 | ||
940 | fail: | |
941 | error_propagate(errp, local_err); | |
942 | return; | |
249d4172 AF |
943 | } |
944 | ||
a7737e44 | 945 | static bool device_get_hotpluggable(Object *obj, Error **errp) |
1a37eca1 IM |
946 | { |
947 | DeviceClass *dc = DEVICE_GET_CLASS(obj); | |
948 | DeviceState *dev = DEVICE(obj); | |
949 | ||
2b81b35f | 950 | return dc->hotpluggable && (dev->parent_bus == NULL || |
39b888bd | 951 | qbus_is_hotpluggable(dev->parent_bus)); |
1a37eca1 IM |
952 | } |
953 | ||
d012ffc1 IM |
954 | static bool device_get_hotplugged(Object *obj, Error **err) |
955 | { | |
956 | DeviceState *dev = DEVICE(obj); | |
957 | ||
958 | return dev->hotplugged; | |
959 | } | |
960 | ||
961 | static void device_set_hotplugged(Object *obj, bool value, Error **err) | |
962 | { | |
963 | DeviceState *dev = DEVICE(obj); | |
964 | ||
965 | dev->hotplugged = value; | |
966 | } | |
967 | ||
9674bfe4 AL |
968 | static void device_initfn(Object *obj) |
969 | { | |
970 | DeviceState *dev = DEVICE(obj); | |
bce54474 | 971 | ObjectClass *class; |
9674bfe4 AL |
972 | Property *prop; |
973 | ||
974 | if (qdev_hotplug) { | |
975 | dev->hotplugged = 1; | |
976 | qdev_hot_added = true; | |
977 | } | |
978 | ||
979 | dev->instance_id_alias = -1; | |
7983c8a3 | 980 | dev->realized = false; |
9674bfe4 | 981 | |
249d4172 AF |
982 | object_property_add_bool(obj, "realized", |
983 | device_get_realized, device_set_realized, NULL); | |
1a37eca1 IM |
984 | object_property_add_bool(obj, "hotpluggable", |
985 | device_get_hotpluggable, NULL, NULL); | |
d012ffc1 IM |
986 | object_property_add_bool(obj, "hotplugged", |
987 | device_get_hotplugged, device_set_hotplugged, | |
988 | &error_abort); | |
249d4172 | 989 | |
bce54474 PB |
990 | class = object_get_class(OBJECT(dev)); |
991 | do { | |
992 | for (prop = DEVICE_CLASS(class)->props; prop && prop->name; prop++) { | |
5433a0a8 PC |
993 | qdev_property_add_legacy(dev, prop, &error_abort); |
994 | qdev_property_add_static(dev, prop, &error_abort); | |
bce54474 | 995 | } |
bce54474 PB |
996 | class = object_class_get_parent(class); |
997 | } while (class != object_class_by_name(TYPE_DEVICE)); | |
9674bfe4 | 998 | |
f968fc68 | 999 | object_property_add_link(OBJECT(dev), "parent_bus", TYPE_BUS, |
39f72ef9 | 1000 | (Object **)&dev->parent_bus, NULL, 0, |
9561fda8 | 1001 | &error_abort); |
a5f54290 | 1002 | QLIST_INIT(&dev->gpios); |
9674bfe4 AL |
1003 | } |
1004 | ||
99a0b036 EH |
1005 | static void device_post_init(Object *obj) |
1006 | { | |
31962700 EH |
1007 | Error *err = NULL; |
1008 | qdev_prop_set_globals(DEVICE(obj), &err); | |
1009 | if (err) { | |
1010 | qerror_report_err(err); | |
1011 | error_free(err); | |
1012 | exit(EXIT_FAILURE); | |
1013 | } | |
99a0b036 EH |
1014 | } |
1015 | ||
60adba37 AL |
1016 | /* Unlink device from bus and free the structure. */ |
1017 | static void device_finalize(Object *obj) | |
1018 | { | |
a5f54290 PC |
1019 | NamedGPIOList *ngl, *next; |
1020 | ||
60adba37 | 1021 | DeviceState *dev = DEVICE(obj); |
06f7f2bb PB |
1022 | if (dev->opts) { |
1023 | qemu_opts_del(dev->opts); | |
60adba37 | 1024 | } |
a5f54290 PC |
1025 | |
1026 | QLIST_FOREACH_SAFE(ngl, &dev->gpios, node, next) { | |
1027 | QLIST_REMOVE(ngl, node); | |
f173d57a | 1028 | qemu_free_irqs(ngl->in, ngl->num_in); |
a5f54290 PC |
1029 | g_free(ngl->name); |
1030 | g_free(ngl); | |
1031 | /* ngl->out irqs are owned by the other end and should not be freed | |
1032 | * here | |
1033 | */ | |
1034 | } | |
60adba37 AL |
1035 | } |
1036 | ||
bce54474 PB |
1037 | static void device_class_base_init(ObjectClass *class, void *data) |
1038 | { | |
1039 | DeviceClass *klass = DEVICE_CLASS(class); | |
1040 | ||
1041 | /* We explicitly look up properties in the superclasses, | |
1042 | * so do not propagate them to the subclasses. | |
1043 | */ | |
1044 | klass->props = NULL; | |
60adba37 AL |
1045 | } |
1046 | ||
5d5b24d0 | 1047 | static void device_unparent(Object *obj) |
667d22d1 PB |
1048 | { |
1049 | DeviceState *dev = DEVICE(obj); | |
06f7f2bb | 1050 | BusState *bus; |
667d22d1 | 1051 | |
5c21ce77 BD |
1052 | if (dev->realized) { |
1053 | object_property_set_bool(obj, false, "realized", NULL); | |
1054 | } | |
06f7f2bb PB |
1055 | while (dev->num_child_bus) { |
1056 | bus = QLIST_FIRST(&dev->child_bus); | |
6780a22c | 1057 | object_unparent(OBJECT(bus)); |
06f7f2bb | 1058 | } |
06f7f2bb | 1059 | if (dev->parent_bus) { |
5d5b24d0 | 1060 | bus_remove_child(dev->parent_bus, dev); |
62d7ba66 PB |
1061 | object_unref(OBJECT(dev->parent_bus)); |
1062 | dev->parent_bus = NULL; | |
5d5b24d0 | 1063 | } |
0402a5d6 | 1064 | |
b1ee5829 | 1065 | /* Only send event if the device had been completely realized */ |
352e8da7 | 1066 | if (dev->pending_deleted_event) { |
b1ee5829 AL |
1067 | gchar *path = object_get_canonical_path(OBJECT(dev)); |
1068 | ||
24b699fb | 1069 | qapi_event_send_device_deleted(!!dev->id, dev->id, path, &error_abort); |
b1ee5829 | 1070 | g_free(path); |
0402a5d6 | 1071 | } |
667d22d1 PB |
1072 | } |
1073 | ||
1074 | static void device_class_init(ObjectClass *class, void *data) | |
1075 | { | |
249d4172 AF |
1076 | DeviceClass *dc = DEVICE_CLASS(class); |
1077 | ||
5d5b24d0 | 1078 | class->unparent = device_unparent; |
249d4172 | 1079 | dc->realize = device_realize; |
fe6c2117 | 1080 | dc->unrealize = device_unrealize; |
267a3264 IM |
1081 | |
1082 | /* by default all devices were considered as hotpluggable, | |
1083 | * so with intent to check it in generic qdev_unplug() / | |
1084 | * device_set_realized() functions make every device | |
1085 | * hotpluggable. Devices that shouldn't be hotpluggable, | |
1086 | * should override it in their class_init() | |
1087 | */ | |
1088 | dc->hotpluggable = true; | |
667d22d1 PB |
1089 | } |
1090 | ||
94afdadc AL |
1091 | void device_reset(DeviceState *dev) |
1092 | { | |
1093 | DeviceClass *klass = DEVICE_GET_CLASS(dev); | |
1094 | ||
1095 | if (klass->reset) { | |
1096 | klass->reset(dev); | |
1097 | } | |
1098 | } | |
1099 | ||
f05f6b4a PB |
1100 | Object *qdev_get_machine(void) |
1101 | { | |
1102 | static Object *dev; | |
1103 | ||
1104 | if (dev == NULL) { | |
dfe47e70 | 1105 | dev = container_get(object_get_root(), "/machine"); |
f05f6b4a PB |
1106 | } |
1107 | ||
1108 | return dev; | |
1109 | } | |
1110 | ||
8c43a6f0 | 1111 | static const TypeInfo device_type_info = { |
32fea402 AL |
1112 | .name = TYPE_DEVICE, |
1113 | .parent = TYPE_OBJECT, | |
1114 | .instance_size = sizeof(DeviceState), | |
9674bfe4 | 1115 | .instance_init = device_initfn, |
99a0b036 | 1116 | .instance_post_init = device_post_init, |
60adba37 | 1117 | .instance_finalize = device_finalize, |
bce54474 | 1118 | .class_base_init = device_class_base_init, |
667d22d1 | 1119 | .class_init = device_class_init, |
32fea402 AL |
1120 | .abstract = true, |
1121 | .class_size = sizeof(DeviceClass), | |
1122 | }; | |
1123 | ||
ac7d1ba6 AL |
1124 | static void qbus_initfn(Object *obj) |
1125 | { | |
1126 | BusState *bus = BUS(obj); | |
1127 | ||
1128 | QTAILQ_INIT(&bus->children); | |
0ee4de6c IM |
1129 | object_property_add_link(obj, QDEV_HOTPLUG_HANDLER_PROPERTY, |
1130 | TYPE_HOTPLUG_HANDLER, | |
9561fda8 | 1131 | (Object **)&bus->hotplug_handler, |
39f72ef9 | 1132 | object_property_allow_set_link, |
9561fda8 SH |
1133 | OBJ_PROP_LINK_UNREF_ON_RELEASE, |
1134 | NULL); | |
02e7f85d BD |
1135 | object_property_add_bool(obj, "realized", |
1136 | bus_get_realized, bus_set_realized, NULL); | |
ac7d1ba6 AL |
1137 | } |
1138 | ||
bbfa18fc AK |
1139 | static char *default_bus_get_fw_dev_path(DeviceState *dev) |
1140 | { | |
1141 | return g_strdup(object_get_typename(OBJECT(dev))); | |
1142 | } | |
1143 | ||
6853d27a PB |
1144 | static void bus_class_init(ObjectClass *class, void *data) |
1145 | { | |
bbfa18fc AK |
1146 | BusClass *bc = BUS_CLASS(class); |
1147 | ||
6853d27a | 1148 | class->unparent = bus_unparent; |
bbfa18fc | 1149 | bc->get_fw_dev_path = default_bus_get_fw_dev_path; |
6853d27a PB |
1150 | } |
1151 | ||
ac7d1ba6 AL |
1152 | static void qbus_finalize(Object *obj) |
1153 | { | |
1154 | BusState *bus = BUS(obj); | |
ac7d1ba6 | 1155 | |
ac7d1ba6 AL |
1156 | g_free((char *)bus->name); |
1157 | } | |
1158 | ||
0d936928 AL |
1159 | static const TypeInfo bus_info = { |
1160 | .name = TYPE_BUS, | |
1161 | .parent = TYPE_OBJECT, | |
1162 | .instance_size = sizeof(BusState), | |
1163 | .abstract = true, | |
1164 | .class_size = sizeof(BusClass), | |
ac7d1ba6 AL |
1165 | .instance_init = qbus_initfn, |
1166 | .instance_finalize = qbus_finalize, | |
6853d27a | 1167 | .class_init = bus_class_init, |
0d936928 AL |
1168 | }; |
1169 | ||
83f7d43a | 1170 | static void qdev_register_types(void) |
32fea402 | 1171 | { |
0d936928 | 1172 | type_register_static(&bus_info); |
32fea402 AL |
1173 | type_register_static(&device_type_info); |
1174 | } | |
1175 | ||
83f7d43a | 1176 | type_init(qdev_register_types) |