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