2 * Dynamic device configuration and creation.
4 * Copyright (c) 2009 CodeSourcery
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.
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.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, see <http://www.gnu.org/licenses/>.
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
29 #include "hw/fw-path-provider.h"
30 #include "sysemu/sysemu.h"
31 #include "qapi/error.h"
32 #include "qapi/qmp/qerror.h"
33 #include "qapi/visitor.h"
34 #include "qapi/qmp/qjson.h"
35 #include "hw/hotplug.h"
36 #include "hw/boards.h"
37 #include "qapi-event.h"
40 static bool qdev_hot_added
= false;
41 static bool qdev_hot_removed
= false;
43 const VMStateDescription
*qdev_get_vmsd(DeviceState
*dev
)
45 DeviceClass
*dc
= DEVICE_GET_CLASS(dev
);
49 const char *qdev_fw_name(DeviceState
*dev
)
51 DeviceClass
*dc
= DEVICE_GET_CLASS(dev
);
57 return object_get_typename(OBJECT(dev
));
60 static void qdev_property_add_legacy(DeviceState
*dev
, Property
*prop
,
63 static void bus_remove_child(BusState
*bus
, DeviceState
*child
)
67 QTAILQ_FOREACH(kid
, &bus
->children
, sibling
) {
68 if (kid
->child
== child
) {
71 snprintf(name
, sizeof(name
), "child[%d]", kid
->index
);
72 QTAILQ_REMOVE(&bus
->children
, kid
, sibling
);
74 /* This gives back ownership of kid->child back to us. */
75 object_property_del(OBJECT(bus
), name
, NULL
);
76 object_unref(OBJECT(kid
->child
));
83 static void bus_add_child(BusState
*bus
, DeviceState
*child
)
86 BusChild
*kid
= g_malloc0(sizeof(*kid
));
88 kid
->index
= bus
->max_index
++;
90 object_ref(OBJECT(kid
->child
));
92 QTAILQ_INSERT_HEAD(&bus
->children
, kid
, sibling
);
94 /* This transfers ownership of kid->child to the property. */
95 snprintf(name
, sizeof(name
), "child[%d]", kid
->index
);
96 object_property_add_link(OBJECT(bus
), name
,
97 object_get_typename(OBJECT(child
)),
98 (Object
**)&kid
->child
,
99 NULL
, /* read-only property */
100 0, /* return ownership on prop deletion */
104 void qdev_set_parent_bus(DeviceState
*dev
, BusState
*bus
)
106 dev
->parent_bus
= bus
;
107 object_ref(OBJECT(bus
));
108 bus_add_child(bus
, dev
);
111 static void qbus_set_hotplug_handler_internal(BusState
*bus
, Object
*handler
,
115 object_property_set_link(OBJECT(bus
), OBJECT(handler
),
116 QDEV_HOTPLUG_HANDLER_PROPERTY
, errp
);
119 void qbus_set_hotplug_handler(BusState
*bus
, DeviceState
*handler
, Error
**errp
)
121 qbus_set_hotplug_handler_internal(bus
, OBJECT(handler
), errp
);
124 void qbus_set_bus_hotplug_handler(BusState
*bus
, Error
**errp
)
126 qbus_set_hotplug_handler_internal(bus
, OBJECT(bus
), errp
);
129 /* Create a new device. This only initializes the device state
130 structure and allows properties to be set. The device still needs
131 to be realized. See qdev-core.h. */
132 DeviceState
*qdev_create(BusState
*bus
, const char *name
)
136 dev
= qdev_try_create(bus
, name
);
139 error_report("Unknown device '%s' for bus '%s'", name
,
140 object_get_typename(OBJECT(bus
)));
142 error_report("Unknown device '%s' for default sysbus", name
);
150 DeviceState
*qdev_try_create(BusState
*bus
, const char *type
)
154 if (object_class_by_name(type
) == NULL
) {
157 dev
= DEVICE(object_new(type
));
163 bus
= sysbus_get_default();
166 qdev_set_parent_bus(dev
, bus
);
167 object_unref(OBJECT(dev
));
171 static QTAILQ_HEAD(device_listeners
, DeviceListener
) device_listeners
172 = QTAILQ_HEAD_INITIALIZER(device_listeners
);
174 enum ListenerDirection
{ Forward
, Reverse
};
176 #define DEVICE_LISTENER_CALL(_callback, _direction, _args...) \
178 DeviceListener *_listener; \
180 switch (_direction) { \
182 QTAILQ_FOREACH(_listener, &device_listeners, link) { \
183 if (_listener->_callback) { \
184 _listener->_callback(_listener, ##_args); \
189 QTAILQ_FOREACH_REVERSE(_listener, &device_listeners, \
190 device_listeners, link) { \
191 if (_listener->_callback) { \
192 _listener->_callback(_listener, ##_args); \
201 static int device_listener_add(DeviceState
*dev
, void *opaque
)
203 DEVICE_LISTENER_CALL(realize
, Forward
, dev
);
208 void device_listener_register(DeviceListener
*listener
)
210 QTAILQ_INSERT_TAIL(&device_listeners
, listener
, link
);
212 qbus_walk_children(sysbus_get_default(), NULL
, NULL
, device_listener_add
,
216 void device_listener_unregister(DeviceListener
*listener
)
218 QTAILQ_REMOVE(&device_listeners
, listener
, link
);
221 static void device_realize(DeviceState
*dev
, Error
**errp
)
223 DeviceClass
*dc
= DEVICE_GET_CLASS(dev
);
226 int rc
= dc
->init(dev
);
228 error_setg(errp
, "Device initialization failed.");
234 static void device_unrealize(DeviceState
*dev
, Error
**errp
)
236 DeviceClass
*dc
= DEVICE_GET_CLASS(dev
);
239 int rc
= dc
->exit(dev
);
241 error_setg(errp
, "Device exit failed.");
247 void qdev_set_legacy_instance_id(DeviceState
*dev
, int alias_id
,
248 int required_for_version
)
250 assert(!dev
->realized
);
251 dev
->instance_id_alias
= alias_id
;
252 dev
->alias_required_for_version
= required_for_version
;
255 HotplugHandler
*qdev_get_hotplug_handler(DeviceState
*dev
)
257 HotplugHandler
*hotplug_ctrl
= NULL
;
259 if (dev
->parent_bus
&& dev
->parent_bus
->hotplug_handler
) {
260 hotplug_ctrl
= dev
->parent_bus
->hotplug_handler
;
261 } else if (object_dynamic_cast(qdev_get_machine(), TYPE_MACHINE
)) {
262 MachineState
*machine
= MACHINE(qdev_get_machine());
263 MachineClass
*mc
= MACHINE_GET_CLASS(machine
);
265 if (mc
->get_hotplug_handler
) {
266 hotplug_ctrl
= mc
->get_hotplug_handler(machine
, dev
);
272 void qdev_unplug(DeviceState
*dev
, Error
**errp
)
274 DeviceClass
*dc
= DEVICE_GET_CLASS(dev
);
275 HotplugHandler
*hotplug_ctrl
;
276 HotplugHandlerClass
*hdc
;
278 if (dev
->parent_bus
&& !qbus_is_hotpluggable(dev
->parent_bus
)) {
279 error_setg(errp
, QERR_BUS_NO_HOTPLUG
, dev
->parent_bus
->name
);
283 if (!dc
->hotpluggable
) {
284 error_setg(errp
, QERR_DEVICE_NO_HOTPLUG
,
285 object_get_typename(OBJECT(dev
)));
289 qdev_hot_removed
= true;
291 hotplug_ctrl
= qdev_get_hotplug_handler(dev
);
292 /* hotpluggable device MUST have HotplugHandler, if it doesn't
293 * then something is very wrong with it */
294 g_assert(hotplug_ctrl
);
296 /* If device supports async unplug just request it to be done,
297 * otherwise just remove it synchronously */
298 hdc
= HOTPLUG_HANDLER_GET_CLASS(hotplug_ctrl
);
299 if (hdc
->unplug_request
) {
300 hotplug_handler_unplug_request(hotplug_ctrl
, dev
, errp
);
302 hotplug_handler_unplug(hotplug_ctrl
, dev
, errp
);
306 static int qdev_reset_one(DeviceState
*dev
, void *opaque
)
313 static int qbus_reset_one(BusState
*bus
, void *opaque
)
315 BusClass
*bc
= BUS_GET_CLASS(bus
);
322 void qdev_reset_all(DeviceState
*dev
)
324 qdev_walk_children(dev
, NULL
, NULL
, qdev_reset_one
, qbus_reset_one
, NULL
);
327 void qbus_reset_all(BusState
*bus
)
329 qbus_walk_children(bus
, NULL
, NULL
, qdev_reset_one
, qbus_reset_one
, NULL
);
332 void qbus_reset_all_fn(void *opaque
)
334 BusState
*bus
= opaque
;
338 /* can be used as ->unplug() callback for the simple cases */
339 void qdev_simple_device_unplug_cb(HotplugHandler
*hotplug_dev
,
340 DeviceState
*dev
, Error
**errp
)
343 object_unparent(OBJECT(dev
));
348 * Device properties should be set before calling this function. IRQs
349 * and MMIO regions should be connected/mapped after calling this
351 * On failure, report an error with error_report() and terminate the
352 * program. This is okay during machine creation. Don't use for
353 * hotplug, because there callers need to recover from failure.
354 * Exception: if you know the device's init() callback can't fail,
355 * then qdev_init_nofail() can't fail either, and is therefore usable
356 * even then. But relying on the device implementation that way is
357 * somewhat unclean, and best avoided.
359 void qdev_init_nofail(DeviceState
*dev
)
363 assert(!dev
->realized
);
365 object_property_set_bool(OBJECT(dev
), true, "realized", &err
);
367 error_report("Initialization of device %s failed: %s",
368 object_get_typename(OBJECT(dev
)),
369 error_get_pretty(err
));
374 void qdev_machine_creation_done(void)
377 * ok, initial machine setup is done, starting from now we can
378 * only create hotpluggable devices
383 bool qdev_machine_modified(void)
385 return qdev_hot_added
|| qdev_hot_removed
;
388 BusState
*qdev_get_parent_bus(DeviceState
*dev
)
390 return dev
->parent_bus
;
393 static NamedGPIOList
*qdev_get_named_gpio_list(DeviceState
*dev
,
398 QLIST_FOREACH(ngl
, &dev
->gpios
, node
) {
399 /* NULL is a valid and matchable name, otherwise do a normal
402 if ((!ngl
->name
&& !name
) ||
403 (name
&& ngl
->name
&& strcmp(name
, ngl
->name
) == 0)) {
408 ngl
= g_malloc0(sizeof(*ngl
));
409 ngl
->name
= g_strdup(name
);
410 QLIST_INSERT_HEAD(&dev
->gpios
, ngl
, node
);
414 void qdev_init_gpio_in_named(DeviceState
*dev
, qemu_irq_handler handler
,
415 const char *name
, int n
)
418 NamedGPIOList
*gpio_list
= qdev_get_named_gpio_list(dev
, name
);
419 char *propname
= g_strdup_printf("%s[*]", name
? name
: "unnamed-gpio-in");
421 assert(gpio_list
->num_out
== 0 || !name
);
422 gpio_list
->in
= qemu_extend_irqs(gpio_list
->in
, gpio_list
->num_in
, handler
,
425 for (i
= gpio_list
->num_in
; i
< gpio_list
->num_in
+ n
; i
++) {
426 object_property_add_child(OBJECT(dev
), propname
,
427 OBJECT(gpio_list
->in
[i
]), &error_abort
);
431 gpio_list
->num_in
+= n
;
434 void qdev_init_gpio_in(DeviceState
*dev
, qemu_irq_handler handler
, int n
)
436 qdev_init_gpio_in_named(dev
, handler
, NULL
, n
);
439 void qdev_init_gpio_out_named(DeviceState
*dev
, qemu_irq
*pins
,
440 const char *name
, int n
)
443 NamedGPIOList
*gpio_list
= qdev_get_named_gpio_list(dev
, name
);
444 char *propname
= g_strdup_printf("%s[*]", name
? name
: "unnamed-gpio-out");
446 assert(gpio_list
->num_in
== 0 || !name
);
447 gpio_list
->num_out
+= n
;
449 for (i
= 0; i
< n
; ++i
) {
450 memset(&pins
[i
], 0, sizeof(*pins
));
451 object_property_add_link(OBJECT(dev
), propname
, TYPE_IRQ
,
453 object_property_allow_set_link
,
454 OBJ_PROP_LINK_UNREF_ON_RELEASE
,
460 void qdev_init_gpio_out(DeviceState
*dev
, qemu_irq
*pins
, int n
)
462 qdev_init_gpio_out_named(dev
, pins
, NULL
, n
);
465 qemu_irq
qdev_get_gpio_in_named(DeviceState
*dev
, const char *name
, int n
)
467 NamedGPIOList
*gpio_list
= qdev_get_named_gpio_list(dev
, name
);
469 assert(n
>= 0 && n
< gpio_list
->num_in
);
470 return gpio_list
->in
[n
];
473 qemu_irq
qdev_get_gpio_in(DeviceState
*dev
, int n
)
475 return qdev_get_gpio_in_named(dev
, NULL
, n
);
478 void qdev_connect_gpio_out_named(DeviceState
*dev
, const char *name
, int n
,
481 char *propname
= g_strdup_printf("%s[%d]",
482 name
? name
: "unnamed-gpio-out", n
);
484 /* We need a name for object_property_set_link to work. If the
485 * object has a parent, object_property_add_child will come back
486 * with an error without doing anything. If it has none, it will
487 * never fail. So we can just call it with a NULL Error pointer.
489 object_property_add_child(container_get(qdev_get_machine(),
491 "non-qdev-gpio[*]", OBJECT(pin
), NULL
);
493 object_property_set_link(OBJECT(dev
), OBJECT(pin
), propname
, &error_abort
);
497 qemu_irq
qdev_get_gpio_out_connector(DeviceState
*dev
, const char *name
, int n
)
499 char *propname
= g_strdup_printf("%s[%d]",
500 name
? name
: "unnamed-gpio-out", n
);
502 qemu_irq ret
= (qemu_irq
)object_property_get_link(OBJECT(dev
), propname
,
508 /* disconnect a GPIO ouput, returning the disconnected input (if any) */
510 static qemu_irq
qdev_disconnect_gpio_out_named(DeviceState
*dev
,
511 const char *name
, int n
)
513 char *propname
= g_strdup_printf("%s[%d]",
514 name
? name
: "unnamed-gpio-out", n
);
516 qemu_irq ret
= (qemu_irq
)object_property_get_link(OBJECT(dev
), propname
,
519 object_property_set_link(OBJECT(dev
), NULL
, propname
, NULL
);
525 qemu_irq
qdev_intercept_gpio_out(DeviceState
*dev
, qemu_irq icpt
,
526 const char *name
, int n
)
528 qemu_irq disconnected
= qdev_disconnect_gpio_out_named(dev
, name
, n
);
529 qdev_connect_gpio_out_named(dev
, name
, n
, icpt
);
533 void qdev_connect_gpio_out(DeviceState
* dev
, int n
, qemu_irq pin
)
535 qdev_connect_gpio_out_named(dev
, NULL
, n
, pin
);
538 void qdev_pass_gpios(DeviceState
*dev
, DeviceState
*container
,
542 NamedGPIOList
*ngl
= qdev_get_named_gpio_list(dev
, name
);
544 for (i
= 0; i
< ngl
->num_in
; i
++) {
545 const char *nm
= ngl
->name
? ngl
->name
: "unnamed-gpio-in";
546 char *propname
= g_strdup_printf("%s[%d]", nm
, i
);
548 object_property_add_alias(OBJECT(container
), propname
,
549 OBJECT(dev
), propname
,
553 for (i
= 0; i
< ngl
->num_out
; i
++) {
554 const char *nm
= ngl
->name
? ngl
->name
: "unnamed-gpio-out";
555 char *propname
= g_strdup_printf("%s[%d]", nm
, i
);
557 object_property_add_alias(OBJECT(container
), propname
,
558 OBJECT(dev
), propname
,
562 QLIST_REMOVE(ngl
, node
);
563 QLIST_INSERT_HEAD(&container
->gpios
, ngl
, node
);
566 BusState
*qdev_get_child_bus(DeviceState
*dev
, const char *name
)
570 QLIST_FOREACH(bus
, &dev
->child_bus
, sibling
) {
571 if (strcmp(name
, bus
->name
) == 0) {
578 int qbus_walk_children(BusState
*bus
,
579 qdev_walkerfn
*pre_devfn
, qbus_walkerfn
*pre_busfn
,
580 qdev_walkerfn
*post_devfn
, qbus_walkerfn
*post_busfn
,
587 err
= pre_busfn(bus
, opaque
);
593 QTAILQ_FOREACH(kid
, &bus
->children
, sibling
) {
594 err
= qdev_walk_children(kid
->child
,
595 pre_devfn
, pre_busfn
,
596 post_devfn
, post_busfn
, opaque
);
603 err
= post_busfn(bus
, opaque
);
612 int qdev_walk_children(DeviceState
*dev
,
613 qdev_walkerfn
*pre_devfn
, qbus_walkerfn
*pre_busfn
,
614 qdev_walkerfn
*post_devfn
, qbus_walkerfn
*post_busfn
,
621 err
= pre_devfn(dev
, opaque
);
627 QLIST_FOREACH(bus
, &dev
->child_bus
, sibling
) {
628 err
= qbus_walk_children(bus
, pre_devfn
, pre_busfn
,
629 post_devfn
, post_busfn
, opaque
);
636 err
= post_devfn(dev
, opaque
);
645 DeviceState
*qdev_find_recursive(BusState
*bus
, const char *id
)
651 QTAILQ_FOREACH(kid
, &bus
->children
, sibling
) {
652 DeviceState
*dev
= kid
->child
;
654 if (dev
->id
&& strcmp(dev
->id
, id
) == 0) {
658 QLIST_FOREACH(child
, &dev
->child_bus
, sibling
) {
659 ret
= qdev_find_recursive(child
, id
);
668 static void qbus_realize(BusState
*bus
, DeviceState
*parent
, const char *name
)
670 const char *typename
= object_get_typename(OBJECT(bus
));
675 bus
->parent
= parent
;
678 bus
->name
= g_strdup(name
);
679 } else if (bus
->parent
&& bus
->parent
->id
) {
680 /* parent device has id -> use it plus parent-bus-id for bus name */
681 bus_id
= bus
->parent
->num_child_bus
;
683 len
= strlen(bus
->parent
->id
) + 16;
685 snprintf(buf
, len
, "%s.%d", bus
->parent
->id
, bus_id
);
688 /* no id -> use lowercase bus type plus global bus-id for bus name */
689 bc
= BUS_GET_CLASS(bus
);
690 bus_id
= bc
->automatic_ids
++;
692 len
= strlen(typename
) + 16;
694 len
= snprintf(buf
, len
, "%s.%d", typename
, bus_id
);
695 for (i
= 0; i
< len
; i
++) {
696 buf
[i
] = qemu_tolower(buf
[i
]);
702 QLIST_INSERT_HEAD(&bus
->parent
->child_bus
, bus
, sibling
);
703 bus
->parent
->num_child_bus
++;
704 object_property_add_child(OBJECT(bus
->parent
), bus
->name
, OBJECT(bus
), NULL
);
705 object_unref(OBJECT(bus
));
706 } else if (bus
!= sysbus_get_default()) {
707 /* TODO: once all bus devices are qdevified,
708 only reset handler for main_system_bus should be registered here. */
709 qemu_register_reset(qbus_reset_all_fn
, bus
);
713 static void bus_unparent(Object
*obj
)
715 BusState
*bus
= BUS(obj
);
718 while ((kid
= QTAILQ_FIRST(&bus
->children
)) != NULL
) {
719 DeviceState
*dev
= kid
->child
;
720 object_unparent(OBJECT(dev
));
723 QLIST_REMOVE(bus
, sibling
);
724 bus
->parent
->num_child_bus
--;
727 assert(bus
!= sysbus_get_default()); /* main_system_bus is never freed */
728 qemu_unregister_reset(qbus_reset_all_fn
, bus
);
732 static bool bus_get_realized(Object
*obj
, Error
**errp
)
734 BusState
*bus
= BUS(obj
);
736 return bus
->realized
;
739 static void bus_set_realized(Object
*obj
, bool value
, Error
**errp
)
741 BusState
*bus
= BUS(obj
);
742 BusClass
*bc
= BUS_GET_CLASS(bus
);
744 Error
*local_err
= NULL
;
746 if (value
&& !bus
->realized
) {
748 bc
->realize(bus
, &local_err
);
751 /* TODO: recursive realization */
752 } else if (!value
&& bus
->realized
) {
753 QTAILQ_FOREACH(kid
, &bus
->children
, sibling
) {
754 DeviceState
*dev
= kid
->child
;
755 object_property_set_bool(OBJECT(dev
), false, "realized",
757 if (local_err
!= NULL
) {
761 if (bc
->unrealize
&& local_err
== NULL
) {
762 bc
->unrealize(bus
, &local_err
);
766 if (local_err
!= NULL
) {
767 error_propagate(errp
, local_err
);
771 bus
->realized
= value
;
774 void qbus_create_inplace(void *bus
, size_t size
, const char *typename
,
775 DeviceState
*parent
, const char *name
)
777 object_initialize(bus
, size
, typename
);
778 qbus_realize(bus
, parent
, name
);
781 BusState
*qbus_create(const char *typename
, DeviceState
*parent
, const char *name
)
785 bus
= BUS(object_new(typename
));
786 qbus_realize(bus
, parent
, name
);
791 static char *bus_get_fw_dev_path(BusState
*bus
, DeviceState
*dev
)
793 BusClass
*bc
= BUS_GET_CLASS(bus
);
795 if (bc
->get_fw_dev_path
) {
796 return bc
->get_fw_dev_path(dev
);
802 static char *qdev_get_fw_dev_path_from_handler(BusState
*bus
, DeviceState
*dev
)
804 Object
*obj
= OBJECT(dev
);
807 while (!d
&& obj
->parent
) {
809 d
= fw_path_provider_try_get_dev_path(obj
, bus
, dev
);
814 char *qdev_get_own_fw_dev_path_from_handler(BusState
*bus
, DeviceState
*dev
)
816 Object
*obj
= OBJECT(dev
);
818 return fw_path_provider_try_get_dev_path(obj
, bus
, dev
);
821 static int qdev_get_fw_dev_path_helper(DeviceState
*dev
, char *p
, int size
)
825 if (dev
&& dev
->parent_bus
) {
827 l
= qdev_get_fw_dev_path_helper(dev
->parent_bus
->parent
, p
, size
);
828 d
= qdev_get_fw_dev_path_from_handler(dev
->parent_bus
, dev
);
830 d
= bus_get_fw_dev_path(dev
->parent_bus
, dev
);
833 l
+= snprintf(p
+ l
, size
- l
, "%s", d
);
839 l
+= snprintf(p
+ l
, size
- l
, "/");
844 char* qdev_get_fw_dev_path(DeviceState
*dev
)
849 l
= qdev_get_fw_dev_path_helper(dev
, path
, 128);
853 return g_strdup(path
);
856 char *qdev_get_dev_path(DeviceState
*dev
)
860 if (!dev
|| !dev
->parent_bus
) {
864 bc
= BUS_GET_CLASS(dev
->parent_bus
);
865 if (bc
->get_dev_path
) {
866 return bc
->get_dev_path(dev
);
873 * Legacy property handling
876 static void qdev_get_legacy_property(Object
*obj
, Visitor
*v
, void *opaque
,
877 const char *name
, Error
**errp
)
879 DeviceState
*dev
= DEVICE(obj
);
880 Property
*prop
= opaque
;
885 prop
->info
->print(dev
, prop
, buffer
, sizeof(buffer
));
886 visit_type_str(v
, &ptr
, name
, errp
);
890 * @qdev_add_legacy_property - adds a legacy property
892 * Do not use this is new code! Properties added through this interface will
893 * be given names and types in the "legacy" namespace.
895 * Legacy properties are string versions of other OOM properties. The format
896 * of the string depends on the property type.
898 static void qdev_property_add_legacy(DeviceState
*dev
, Property
*prop
,
903 /* Register pointer properties as legacy properties */
904 if (!prop
->info
->print
&& prop
->info
->get
) {
908 name
= g_strdup_printf("legacy-%s", prop
->name
);
909 object_property_add(OBJECT(dev
), name
, "str",
910 prop
->info
->print
? qdev_get_legacy_property
: prop
->info
->get
,
919 * @qdev_property_add_static - add a @Property to a device.
921 * Static properties access data in a struct. The actual type of the
922 * property and the field depends on the property type.
924 void qdev_property_add_static(DeviceState
*dev
, Property
*prop
,
927 Error
*local_err
= NULL
;
928 Object
*obj
= OBJECT(dev
);
931 * TODO qdev_prop_ptr does not have getters or setters. It must
932 * go now that it can be replaced with links. The test should be
933 * removed along with it: all static properties are read/write.
935 if (!prop
->info
->get
&& !prop
->info
->set
) {
939 object_property_add(obj
, prop
->name
, prop
->info
->name
,
940 prop
->info
->get
, prop
->info
->set
,
945 error_propagate(errp
, local_err
);
949 object_property_set_description(obj
, prop
->name
,
950 prop
->info
->description
,
953 if (prop
->qtype
== QTYPE_NONE
) {
957 if (prop
->qtype
== QTYPE_QBOOL
) {
958 object_property_set_bool(obj
, prop
->defval
, prop
->name
, &error_abort
);
959 } else if (prop
->info
->enum_table
) {
960 object_property_set_str(obj
, prop
->info
->enum_table
[prop
->defval
],
961 prop
->name
, &error_abort
);
962 } else if (prop
->qtype
== QTYPE_QINT
) {
963 object_property_set_int(obj
, prop
->defval
, prop
->name
, &error_abort
);
967 /* @qdev_alias_all_properties - Add alias properties to the source object for
968 * all qdev properties on the target DeviceState.
970 void qdev_alias_all_properties(DeviceState
*target
, Object
*source
)
975 class = object_get_class(OBJECT(target
));
977 DeviceClass
*dc
= DEVICE_CLASS(class);
979 for (prop
= dc
->props
; prop
&& prop
->name
; prop
++) {
980 object_property_add_alias(source
, prop
->name
,
981 OBJECT(target
), prop
->name
,
984 class = object_class_get_parent(class);
985 } while (class != object_class_by_name(TYPE_DEVICE
));
988 static int qdev_add_hotpluggable_device(Object
*obj
, void *opaque
)
990 GSList
**list
= opaque
;
991 DeviceState
*dev
= (DeviceState
*)object_dynamic_cast(OBJECT(obj
),
998 if (dev
->realized
&& object_property_get_bool(obj
, "hotpluggable", NULL
)) {
999 *list
= g_slist_append(*list
, dev
);
1005 GSList
*qdev_build_hotpluggable_device_list(Object
*peripheral
)
1007 GSList
*list
= NULL
;
1009 object_child_foreach(peripheral
, qdev_add_hotpluggable_device
, &list
);
1014 static bool device_get_realized(Object
*obj
, Error
**errp
)
1016 DeviceState
*dev
= DEVICE(obj
);
1017 return dev
->realized
;
1020 static void device_set_realized(Object
*obj
, bool value
, Error
**errp
)
1022 DeviceState
*dev
= DEVICE(obj
);
1023 DeviceClass
*dc
= DEVICE_GET_CLASS(dev
);
1024 HotplugHandler
*hotplug_ctrl
;
1026 Error
*local_err
= NULL
;
1028 if (dev
->hotplugged
&& !dc
->hotpluggable
) {
1029 error_setg(errp
, QERR_DEVICE_NO_HOTPLUG
, object_get_typename(obj
));
1033 if (value
&& !dev
->realized
) {
1035 static int unattached_count
;
1036 gchar
*name
= g_strdup_printf("device[%d]", unattached_count
++);
1038 object_property_add_child(container_get(qdev_get_machine(),
1040 name
, obj
, &error_abort
);
1045 dc
->realize(dev
, &local_err
);
1048 if (local_err
!= NULL
) {
1052 DEVICE_LISTENER_CALL(realize
, Forward
, dev
);
1054 hotplug_ctrl
= qdev_get_hotplug_handler(dev
);
1056 hotplug_handler_plug(hotplug_ctrl
, dev
, &local_err
);
1059 if (local_err
!= NULL
) {
1060 goto post_realize_fail
;
1063 if (qdev_get_vmsd(dev
)) {
1064 vmstate_register_with_alias_id(dev
, -1, qdev_get_vmsd(dev
), dev
,
1065 dev
->instance_id_alias
,
1066 dev
->alias_required_for_version
);
1069 QLIST_FOREACH(bus
, &dev
->child_bus
, sibling
) {
1070 object_property_set_bool(OBJECT(bus
), true, "realized",
1072 if (local_err
!= NULL
) {
1073 goto child_realize_fail
;
1076 if (dev
->hotplugged
) {
1079 dev
->pending_deleted_event
= false;
1080 } else if (!value
&& dev
->realized
) {
1081 Error
**local_errp
= NULL
;
1082 QLIST_FOREACH(bus
, &dev
->child_bus
, sibling
) {
1083 local_errp
= local_err
? NULL
: &local_err
;
1084 object_property_set_bool(OBJECT(bus
), false, "realized",
1087 if (qdev_get_vmsd(dev
)) {
1088 vmstate_unregister(dev
, qdev_get_vmsd(dev
), dev
);
1090 if (dc
->unrealize
) {
1091 local_errp
= local_err
? NULL
: &local_err
;
1092 dc
->unrealize(dev
, local_errp
);
1094 dev
->pending_deleted_event
= true;
1095 DEVICE_LISTENER_CALL(unrealize
, Reverse
, dev
);
1098 if (local_err
!= NULL
) {
1102 dev
->realized
= value
;
1106 QLIST_FOREACH(bus
, &dev
->child_bus
, sibling
) {
1107 object_property_set_bool(OBJECT(bus
), false, "realized",
1111 if (qdev_get_vmsd(dev
)) {
1112 vmstate_unregister(dev
, qdev_get_vmsd(dev
), dev
);
1116 if (dc
->unrealize
) {
1117 dc
->unrealize(dev
, NULL
);
1121 error_propagate(errp
, local_err
);
1125 static bool device_get_hotpluggable(Object
*obj
, Error
**errp
)
1127 DeviceClass
*dc
= DEVICE_GET_CLASS(obj
);
1128 DeviceState
*dev
= DEVICE(obj
);
1130 return dc
->hotpluggable
&& (dev
->parent_bus
== NULL
||
1131 qbus_is_hotpluggable(dev
->parent_bus
));
1134 static bool device_get_hotplugged(Object
*obj
, Error
**err
)
1136 DeviceState
*dev
= DEVICE(obj
);
1138 return dev
->hotplugged
;
1141 static void device_set_hotplugged(Object
*obj
, bool value
, Error
**err
)
1143 DeviceState
*dev
= DEVICE(obj
);
1145 dev
->hotplugged
= value
;
1148 static void device_initfn(Object
*obj
)
1150 DeviceState
*dev
= DEVICE(obj
);
1155 dev
->hotplugged
= 1;
1156 qdev_hot_added
= true;
1159 dev
->instance_id_alias
= -1;
1160 dev
->realized
= false;
1162 object_property_add_bool(obj
, "realized",
1163 device_get_realized
, device_set_realized
, NULL
);
1164 object_property_add_bool(obj
, "hotpluggable",
1165 device_get_hotpluggable
, NULL
, NULL
);
1166 object_property_add_bool(obj
, "hotplugged",
1167 device_get_hotplugged
, device_set_hotplugged
,
1170 class = object_get_class(OBJECT(dev
));
1172 for (prop
= DEVICE_CLASS(class)->props
; prop
&& prop
->name
; prop
++) {
1173 qdev_property_add_legacy(dev
, prop
, &error_abort
);
1174 qdev_property_add_static(dev
, prop
, &error_abort
);
1176 class = object_class_get_parent(class);
1177 } while (class != object_class_by_name(TYPE_DEVICE
));
1179 object_property_add_link(OBJECT(dev
), "parent_bus", TYPE_BUS
,
1180 (Object
**)&dev
->parent_bus
, NULL
, 0,
1182 QLIST_INIT(&dev
->gpios
);
1185 static void device_post_init(Object
*obj
)
1187 qdev_prop_set_globals(DEVICE(obj
));
1190 /* Unlink device from bus and free the structure. */
1191 static void device_finalize(Object
*obj
)
1193 NamedGPIOList
*ngl
, *next
;
1195 DeviceState
*dev
= DEVICE(obj
);
1196 qemu_opts_del(dev
->opts
);
1198 QLIST_FOREACH_SAFE(ngl
, &dev
->gpios
, node
, next
) {
1199 QLIST_REMOVE(ngl
, node
);
1200 qemu_free_irqs(ngl
->in
, ngl
->num_in
);
1203 /* ngl->out irqs are owned by the other end and should not be freed
1209 static void device_class_base_init(ObjectClass
*class, void *data
)
1211 DeviceClass
*klass
= DEVICE_CLASS(class);
1213 /* We explicitly look up properties in the superclasses,
1214 * so do not propagate them to the subclasses.
1216 klass
->props
= NULL
;
1219 static void device_unparent(Object
*obj
)
1221 DeviceState
*dev
= DEVICE(obj
);
1224 if (dev
->realized
) {
1225 object_property_set_bool(obj
, false, "realized", NULL
);
1227 while (dev
->num_child_bus
) {
1228 bus
= QLIST_FIRST(&dev
->child_bus
);
1229 object_unparent(OBJECT(bus
));
1231 if (dev
->parent_bus
) {
1232 bus_remove_child(dev
->parent_bus
, dev
);
1233 object_unref(OBJECT(dev
->parent_bus
));
1234 dev
->parent_bus
= NULL
;
1237 /* Only send event if the device had been completely realized */
1238 if (dev
->pending_deleted_event
) {
1239 gchar
*path
= object_get_canonical_path(OBJECT(dev
));
1241 qapi_event_send_device_deleted(!!dev
->id
, dev
->id
, path
, &error_abort
);
1246 static void device_class_init(ObjectClass
*class, void *data
)
1248 DeviceClass
*dc
= DEVICE_CLASS(class);
1250 class->unparent
= device_unparent
;
1251 dc
->realize
= device_realize
;
1252 dc
->unrealize
= device_unrealize
;
1254 /* by default all devices were considered as hotpluggable,
1255 * so with intent to check it in generic qdev_unplug() /
1256 * device_set_realized() functions make every device
1257 * hotpluggable. Devices that shouldn't be hotpluggable,
1258 * should override it in their class_init()
1260 dc
->hotpluggable
= true;
1263 void device_reset(DeviceState
*dev
)
1265 DeviceClass
*klass
= DEVICE_GET_CLASS(dev
);
1272 Object
*qdev_get_machine(void)
1277 dev
= container_get(object_get_root(), "/machine");
1283 static const TypeInfo device_type_info
= {
1284 .name
= TYPE_DEVICE
,
1285 .parent
= TYPE_OBJECT
,
1286 .instance_size
= sizeof(DeviceState
),
1287 .instance_init
= device_initfn
,
1288 .instance_post_init
= device_post_init
,
1289 .instance_finalize
= device_finalize
,
1290 .class_base_init
= device_class_base_init
,
1291 .class_init
= device_class_init
,
1293 .class_size
= sizeof(DeviceClass
),
1296 static void qbus_initfn(Object
*obj
)
1298 BusState
*bus
= BUS(obj
);
1300 QTAILQ_INIT(&bus
->children
);
1301 object_property_add_link(obj
, QDEV_HOTPLUG_HANDLER_PROPERTY
,
1302 TYPE_HOTPLUG_HANDLER
,
1303 (Object
**)&bus
->hotplug_handler
,
1304 object_property_allow_set_link
,
1305 OBJ_PROP_LINK_UNREF_ON_RELEASE
,
1307 object_property_add_bool(obj
, "realized",
1308 bus_get_realized
, bus_set_realized
, NULL
);
1311 static char *default_bus_get_fw_dev_path(DeviceState
*dev
)
1313 return g_strdup(object_get_typename(OBJECT(dev
)));
1316 static void bus_class_init(ObjectClass
*class, void *data
)
1318 BusClass
*bc
= BUS_CLASS(class);
1320 class->unparent
= bus_unparent
;
1321 bc
->get_fw_dev_path
= default_bus_get_fw_dev_path
;
1324 static void qbus_finalize(Object
*obj
)
1326 BusState
*bus
= BUS(obj
);
1328 g_free((char *)bus
->name
);
1331 static const TypeInfo bus_info
= {
1333 .parent
= TYPE_OBJECT
,
1334 .instance_size
= sizeof(BusState
),
1336 .class_size
= sizeof(BusClass
),
1337 .instance_init
= qbus_initfn
,
1338 .instance_finalize
= qbus_finalize
,
1339 .class_init
= bus_class_init
,
1342 static void qdev_register_types(void)
1344 type_register_static(&bus_info
);
1345 type_register_static(&device_type_info
);
1348 type_init(qdev_register_types
)