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
28 #include "qemu/osdep.h"
30 #include "hw/fw-path-provider.h"
31 #include "sysemu/sysemu.h"
32 #include "qapi/qmp/qerror.h"
33 #include "qapi/visitor.h"
34 #include "qapi/qmp/qjson.h"
35 #include "qemu/error-report.h"
36 #include "hw/hotplug.h"
37 #include "hw/boards.h"
38 #include "hw/sysbus.h"
39 #include "qapi-event.h"
42 static bool qdev_hot_added
= false;
43 static bool qdev_hot_removed
= false;
45 const VMStateDescription
*qdev_get_vmsd(DeviceState
*dev
)
47 DeviceClass
*dc
= DEVICE_GET_CLASS(dev
);
51 const char *qdev_fw_name(DeviceState
*dev
)
53 DeviceClass
*dc
= DEVICE_GET_CLASS(dev
);
59 return object_get_typename(OBJECT(dev
));
62 static void bus_remove_child(BusState
*bus
, DeviceState
*child
)
66 QTAILQ_FOREACH(kid
, &bus
->children
, sibling
) {
67 if (kid
->child
== child
) {
70 snprintf(name
, sizeof(name
), "child[%d]", kid
->index
);
71 QTAILQ_REMOVE(&bus
->children
, kid
, sibling
);
73 /* This gives back ownership of kid->child back to us. */
74 object_property_del(OBJECT(bus
), name
, NULL
);
75 object_unref(OBJECT(kid
->child
));
82 static void bus_add_child(BusState
*bus
, DeviceState
*child
)
85 BusChild
*kid
= g_malloc0(sizeof(*kid
));
87 kid
->index
= bus
->max_index
++;
89 object_ref(OBJECT(kid
->child
));
91 QTAILQ_INSERT_HEAD(&bus
->children
, kid
, sibling
);
93 /* This transfers ownership of kid->child to the property. */
94 snprintf(name
, sizeof(name
), "child[%d]", kid
->index
);
95 object_property_add_link(OBJECT(bus
), name
,
96 object_get_typename(OBJECT(child
)),
97 (Object
**)&kid
->child
,
98 NULL
, /* read-only property */
99 0, /* return ownership on prop deletion */
103 void qdev_set_parent_bus(DeviceState
*dev
, BusState
*bus
)
105 dev
->parent_bus
= bus
;
106 object_ref(OBJECT(bus
));
107 bus_add_child(bus
, dev
);
110 /* Create a new device. This only initializes the device state
111 structure and allows properties to be set. The device still needs
112 to be realized. See qdev-core.h. */
113 DeviceState
*qdev_create(BusState
*bus
, const char *name
)
117 dev
= qdev_try_create(bus
, name
);
120 error_report("Unknown device '%s' for bus '%s'", name
,
121 object_get_typename(OBJECT(bus
)));
123 error_report("Unknown device '%s' for default sysbus", name
);
131 DeviceState
*qdev_try_create(BusState
*bus
, const char *type
)
135 if (object_class_by_name(type
) == NULL
) {
138 dev
= DEVICE(object_new(type
));
144 /* Assert that the device really is a SysBusDevice before
145 * we put it onto the sysbus. Non-sysbus devices which aren't
146 * being put onto a bus should be created with object_new(TYPE_FOO),
147 * not qdev_create(NULL, TYPE_FOO).
149 g_assert(object_dynamic_cast(OBJECT(dev
), TYPE_SYS_BUS_DEVICE
));
150 bus
= sysbus_get_default();
153 qdev_set_parent_bus(dev
, bus
);
154 object_unref(OBJECT(dev
));
158 static QTAILQ_HEAD(device_listeners
, DeviceListener
) device_listeners
159 = QTAILQ_HEAD_INITIALIZER(device_listeners
);
161 enum ListenerDirection
{ Forward
, Reverse
};
163 #define DEVICE_LISTENER_CALL(_callback, _direction, _args...) \
165 DeviceListener *_listener; \
167 switch (_direction) { \
169 QTAILQ_FOREACH(_listener, &device_listeners, link) { \
170 if (_listener->_callback) { \
171 _listener->_callback(_listener, ##_args); \
176 QTAILQ_FOREACH_REVERSE(_listener, &device_listeners, \
177 device_listeners, link) { \
178 if (_listener->_callback) { \
179 _listener->_callback(_listener, ##_args); \
188 static int device_listener_add(DeviceState
*dev
, void *opaque
)
190 DEVICE_LISTENER_CALL(realize
, Forward
, dev
);
195 void device_listener_register(DeviceListener
*listener
)
197 QTAILQ_INSERT_TAIL(&device_listeners
, listener
, link
);
199 qbus_walk_children(sysbus_get_default(), NULL
, NULL
, device_listener_add
,
203 void device_listener_unregister(DeviceListener
*listener
)
205 QTAILQ_REMOVE(&device_listeners
, listener
, link
);
208 static void device_realize(DeviceState
*dev
, Error
**errp
)
210 DeviceClass
*dc
= DEVICE_GET_CLASS(dev
);
213 int rc
= dc
->init(dev
);
215 error_setg(errp
, "Device initialization failed.");
221 static void device_unrealize(DeviceState
*dev
, Error
**errp
)
223 DeviceClass
*dc
= DEVICE_GET_CLASS(dev
);
226 int rc
= dc
->exit(dev
);
228 error_setg(errp
, "Device exit failed.");
234 void qdev_set_legacy_instance_id(DeviceState
*dev
, int alias_id
,
235 int required_for_version
)
237 assert(!dev
->realized
);
238 dev
->instance_id_alias
= alias_id
;
239 dev
->alias_required_for_version
= required_for_version
;
242 HotplugHandler
*qdev_get_hotplug_handler(DeviceState
*dev
)
244 HotplugHandler
*hotplug_ctrl
= NULL
;
246 if (dev
->parent_bus
&& dev
->parent_bus
->hotplug_handler
) {
247 hotplug_ctrl
= dev
->parent_bus
->hotplug_handler
;
248 } else if (object_dynamic_cast(qdev_get_machine(), TYPE_MACHINE
)) {
249 MachineState
*machine
= MACHINE(qdev_get_machine());
250 MachineClass
*mc
= MACHINE_GET_CLASS(machine
);
252 if (mc
->get_hotplug_handler
) {
253 hotplug_ctrl
= mc
->get_hotplug_handler(machine
, dev
);
259 void qdev_unplug(DeviceState
*dev
, Error
**errp
)
261 DeviceClass
*dc
= DEVICE_GET_CLASS(dev
);
262 HotplugHandler
*hotplug_ctrl
;
263 HotplugHandlerClass
*hdc
;
265 if (dev
->parent_bus
&& !qbus_is_hotpluggable(dev
->parent_bus
)) {
266 error_setg(errp
, QERR_BUS_NO_HOTPLUG
, dev
->parent_bus
->name
);
270 if (!dc
->hotpluggable
) {
271 error_setg(errp
, QERR_DEVICE_NO_HOTPLUG
,
272 object_get_typename(OBJECT(dev
)));
276 qdev_hot_removed
= true;
278 hotplug_ctrl
= qdev_get_hotplug_handler(dev
);
279 /* hotpluggable device MUST have HotplugHandler, if it doesn't
280 * then something is very wrong with it */
281 g_assert(hotplug_ctrl
);
283 /* If device supports async unplug just request it to be done,
284 * otherwise just remove it synchronously */
285 hdc
= HOTPLUG_HANDLER_GET_CLASS(hotplug_ctrl
);
286 if (hdc
->unplug_request
) {
287 hotplug_handler_unplug_request(hotplug_ctrl
, dev
, errp
);
289 hotplug_handler_unplug(hotplug_ctrl
, dev
, errp
);
293 static int qdev_reset_one(DeviceState
*dev
, void *opaque
)
300 static int qbus_reset_one(BusState
*bus
, void *opaque
)
302 BusClass
*bc
= BUS_GET_CLASS(bus
);
309 void qdev_reset_all(DeviceState
*dev
)
311 qdev_walk_children(dev
, NULL
, NULL
, qdev_reset_one
, qbus_reset_one
, NULL
);
314 void qdev_reset_all_fn(void *opaque
)
316 qdev_reset_all(DEVICE(opaque
));
319 void qbus_reset_all(BusState
*bus
)
321 qbus_walk_children(bus
, NULL
, NULL
, qdev_reset_one
, qbus_reset_one
, NULL
);
324 void qbus_reset_all_fn(void *opaque
)
326 BusState
*bus
= opaque
;
330 /* can be used as ->unplug() callback for the simple cases */
331 void qdev_simple_device_unplug_cb(HotplugHandler
*hotplug_dev
,
332 DeviceState
*dev
, Error
**errp
)
335 object_unparent(OBJECT(dev
));
340 * Device properties should be set before calling this function. IRQs
341 * and MMIO regions should be connected/mapped after calling this
343 * On failure, report an error with error_report() and terminate the
344 * program. This is okay during machine creation. Don't use for
345 * hotplug, because there callers need to recover from failure.
346 * Exception: if you know the device's init() callback can't fail,
347 * then qdev_init_nofail() can't fail either, and is therefore usable
348 * even then. But relying on the device implementation that way is
349 * somewhat unclean, and best avoided.
351 void qdev_init_nofail(DeviceState
*dev
)
355 assert(!dev
->realized
);
357 object_property_set_bool(OBJECT(dev
), true, "realized", &err
);
359 error_reportf_err(err
, "Initialization of device %s failed: ",
360 object_get_typename(OBJECT(dev
)));
365 void qdev_machine_creation_done(void)
368 * ok, initial machine setup is done, starting from now we can
369 * only create hotpluggable devices
374 bool qdev_machine_modified(void)
376 return qdev_hot_added
|| qdev_hot_removed
;
379 BusState
*qdev_get_parent_bus(DeviceState
*dev
)
381 return dev
->parent_bus
;
384 static NamedGPIOList
*qdev_get_named_gpio_list(DeviceState
*dev
,
389 QLIST_FOREACH(ngl
, &dev
->gpios
, node
) {
390 /* NULL is a valid and matchable name, otherwise do a normal
393 if ((!ngl
->name
&& !name
) ||
394 (name
&& ngl
->name
&& strcmp(name
, ngl
->name
) == 0)) {
399 ngl
= g_malloc0(sizeof(*ngl
));
400 ngl
->name
= g_strdup(name
);
401 QLIST_INSERT_HEAD(&dev
->gpios
, ngl
, node
);
405 void qdev_init_gpio_in_named(DeviceState
*dev
, qemu_irq_handler handler
,
406 const char *name
, int n
)
409 NamedGPIOList
*gpio_list
= qdev_get_named_gpio_list(dev
, name
);
411 assert(gpio_list
->num_out
== 0 || !name
);
412 gpio_list
->in
= qemu_extend_irqs(gpio_list
->in
, gpio_list
->num_in
, handler
,
416 name
= "unnamed-gpio-in";
418 for (i
= gpio_list
->num_in
; i
< gpio_list
->num_in
+ n
; i
++) {
419 gchar
*propname
= g_strdup_printf("%s[%u]", name
, i
);
421 object_property_add_child(OBJECT(dev
), propname
,
422 OBJECT(gpio_list
->in
[i
]), &error_abort
);
426 gpio_list
->num_in
+= n
;
429 void qdev_init_gpio_in(DeviceState
*dev
, qemu_irq_handler handler
, int n
)
431 qdev_init_gpio_in_named(dev
, handler
, NULL
, n
);
434 void qdev_init_gpio_out_named(DeviceState
*dev
, qemu_irq
*pins
,
435 const char *name
, int n
)
438 NamedGPIOList
*gpio_list
= qdev_get_named_gpio_list(dev
, name
);
440 assert(gpio_list
->num_in
== 0 || !name
);
443 name
= "unnamed-gpio-out";
445 memset(pins
, 0, sizeof(*pins
) * n
);
446 for (i
= 0; i
< n
; ++i
) {
447 gchar
*propname
= g_strdup_printf("%s[%u]", name
,
448 gpio_list
->num_out
+ i
);
450 object_property_add_link(OBJECT(dev
), propname
, TYPE_IRQ
,
452 object_property_allow_set_link
,
453 OBJ_PROP_LINK_UNREF_ON_RELEASE
,
457 gpio_list
->num_out
+= n
;
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 output, 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
)
569 Object
*child
= object_resolve_path_component(OBJECT(dev
), name
);
571 bus
= (BusState
*)object_dynamic_cast(child
, TYPE_BUS
);
576 QLIST_FOREACH(bus
, &dev
->child_bus
, sibling
) {
577 if (strcmp(name
, bus
->name
) == 0) {
584 int qdev_walk_children(DeviceState
*dev
,
585 qdev_walkerfn
*pre_devfn
, qbus_walkerfn
*pre_busfn
,
586 qdev_walkerfn
*post_devfn
, qbus_walkerfn
*post_busfn
,
593 err
= pre_devfn(dev
, opaque
);
599 QLIST_FOREACH(bus
, &dev
->child_bus
, sibling
) {
600 err
= qbus_walk_children(bus
, pre_devfn
, pre_busfn
,
601 post_devfn
, post_busfn
, opaque
);
608 err
= post_devfn(dev
, opaque
);
617 DeviceState
*qdev_find_recursive(BusState
*bus
, const char *id
)
623 QTAILQ_FOREACH(kid
, &bus
->children
, sibling
) {
624 DeviceState
*dev
= kid
->child
;
626 if (dev
->id
&& strcmp(dev
->id
, id
) == 0) {
630 QLIST_FOREACH(child
, &dev
->child_bus
, sibling
) {
631 ret
= qdev_find_recursive(child
, id
);
640 static char *bus_get_fw_dev_path(BusState
*bus
, DeviceState
*dev
)
642 BusClass
*bc
= BUS_GET_CLASS(bus
);
644 if (bc
->get_fw_dev_path
) {
645 return bc
->get_fw_dev_path(dev
);
651 static char *qdev_get_fw_dev_path_from_handler(BusState
*bus
, DeviceState
*dev
)
653 Object
*obj
= OBJECT(dev
);
656 while (!d
&& obj
->parent
) {
658 d
= fw_path_provider_try_get_dev_path(obj
, bus
, dev
);
663 char *qdev_get_own_fw_dev_path_from_handler(BusState
*bus
, DeviceState
*dev
)
665 Object
*obj
= OBJECT(dev
);
667 return fw_path_provider_try_get_dev_path(obj
, bus
, dev
);
670 static int qdev_get_fw_dev_path_helper(DeviceState
*dev
, char *p
, int size
)
674 if (dev
&& dev
->parent_bus
) {
676 l
= qdev_get_fw_dev_path_helper(dev
->parent_bus
->parent
, p
, size
);
677 d
= qdev_get_fw_dev_path_from_handler(dev
->parent_bus
, dev
);
679 d
= bus_get_fw_dev_path(dev
->parent_bus
, dev
);
682 l
+= snprintf(p
+ l
, size
- l
, "%s", d
);
688 l
+= snprintf(p
+ l
, size
- l
, "/");
693 char* qdev_get_fw_dev_path(DeviceState
*dev
)
698 l
= qdev_get_fw_dev_path_helper(dev
, path
, 128);
702 return g_strdup(path
);
705 char *qdev_get_dev_path(DeviceState
*dev
)
709 if (!dev
|| !dev
->parent_bus
) {
713 bc
= BUS_GET_CLASS(dev
->parent_bus
);
714 if (bc
->get_dev_path
) {
715 return bc
->get_dev_path(dev
);
722 * Legacy property handling
725 static void qdev_get_legacy_property(Object
*obj
, Visitor
*v
,
726 const char *name
, void *opaque
,
729 DeviceState
*dev
= DEVICE(obj
);
730 Property
*prop
= opaque
;
735 prop
->info
->print(dev
, prop
, buffer
, sizeof(buffer
));
736 visit_type_str(v
, name
, &ptr
, errp
);
740 * qdev_property_add_legacy:
741 * @dev: Device to add the property to.
742 * @prop: The qdev property definition.
743 * @errp: location to store error information.
745 * Add a legacy QOM property to @dev for qdev property @prop.
746 * On error, store error in @errp.
748 * Legacy properties are string versions of QOM properties. The format of
749 * the string depends on the property type. Legacy properties are only
750 * needed for "info qtree".
752 * Do not use this is new code! QOM Properties added through this interface
753 * will be given names in the "legacy" namespace.
755 static void qdev_property_add_legacy(DeviceState
*dev
, Property
*prop
,
760 /* Register pointer properties as legacy properties */
761 if (!prop
->info
->print
&& prop
->info
->get
) {
765 name
= g_strdup_printf("legacy-%s", prop
->name
);
766 object_property_add(OBJECT(dev
), name
, "str",
767 prop
->info
->print
? qdev_get_legacy_property
: prop
->info
->get
,
776 * qdev_property_add_static:
777 * @dev: Device to add the property to.
778 * @prop: The qdev property definition.
779 * @errp: location to store error information.
781 * Add a static QOM property to @dev for qdev property @prop.
782 * On error, store error in @errp. Static properties access data in a struct.
783 * The type of the QOM property is derived from prop->info.
785 void qdev_property_add_static(DeviceState
*dev
, Property
*prop
,
788 Error
*local_err
= NULL
;
789 Object
*obj
= OBJECT(dev
);
792 * TODO qdev_prop_ptr does not have getters or setters. It must
793 * go now that it can be replaced with links. The test should be
794 * removed along with it: all static properties are read/write.
796 if (!prop
->info
->get
&& !prop
->info
->set
) {
800 object_property_add(obj
, prop
->name
, prop
->info
->name
,
801 prop
->info
->get
, prop
->info
->set
,
806 error_propagate(errp
, local_err
);
810 object_property_set_description(obj
, prop
->name
,
811 prop
->info
->description
,
814 if (prop
->qtype
== QTYPE_NONE
) {
818 if (prop
->qtype
== QTYPE_QBOOL
) {
819 object_property_set_bool(obj
, prop
->defval
, prop
->name
, &error_abort
);
820 } else if (prop
->info
->enum_table
) {
821 object_property_set_str(obj
, prop
->info
->enum_table
[prop
->defval
],
822 prop
->name
, &error_abort
);
823 } else if (prop
->qtype
== QTYPE_QINT
) {
824 object_property_set_int(obj
, prop
->defval
, prop
->name
, &error_abort
);
828 /* @qdev_alias_all_properties - Add alias properties to the source object for
829 * all qdev properties on the target DeviceState.
831 void qdev_alias_all_properties(DeviceState
*target
, Object
*source
)
836 class = object_get_class(OBJECT(target
));
838 DeviceClass
*dc
= DEVICE_CLASS(class);
840 for (prop
= dc
->props
; prop
&& prop
->name
; prop
++) {
841 object_property_add_alias(source
, prop
->name
,
842 OBJECT(target
), prop
->name
,
845 class = object_class_get_parent(class);
846 } while (class != object_class_by_name(TYPE_DEVICE
));
849 static int qdev_add_hotpluggable_device(Object
*obj
, void *opaque
)
851 GSList
**list
= opaque
;
852 DeviceState
*dev
= (DeviceState
*)object_dynamic_cast(OBJECT(obj
),
859 if (dev
->realized
&& object_property_get_bool(obj
, "hotpluggable", NULL
)) {
860 *list
= g_slist_append(*list
, dev
);
866 GSList
*qdev_build_hotpluggable_device_list(Object
*peripheral
)
870 object_child_foreach(peripheral
, qdev_add_hotpluggable_device
, &list
);
875 static bool device_get_realized(Object
*obj
, Error
**errp
)
877 DeviceState
*dev
= DEVICE(obj
);
878 return dev
->realized
;
881 static void device_set_realized(Object
*obj
, bool value
, Error
**errp
)
883 DeviceState
*dev
= DEVICE(obj
);
884 DeviceClass
*dc
= DEVICE_GET_CLASS(dev
);
885 HotplugHandler
*hotplug_ctrl
;
887 Error
*local_err
= NULL
;
889 if (dev
->hotplugged
&& !dc
->hotpluggable
) {
890 error_setg(errp
, QERR_DEVICE_NO_HOTPLUG
, object_get_typename(obj
));
894 if (value
&& !dev
->realized
) {
896 static int unattached_count
;
897 gchar
*name
= g_strdup_printf("device[%d]", unattached_count
++);
899 object_property_add_child(container_get(qdev_get_machine(),
901 name
, obj
, &error_abort
);
906 dc
->realize(dev
, &local_err
);
909 if (local_err
!= NULL
) {
913 DEVICE_LISTENER_CALL(realize
, Forward
, dev
);
915 hotplug_ctrl
= qdev_get_hotplug_handler(dev
);
917 hotplug_handler_plug(hotplug_ctrl
, dev
, &local_err
);
920 if (local_err
!= NULL
) {
921 goto post_realize_fail
;
924 if (qdev_get_vmsd(dev
)) {
925 vmstate_register_with_alias_id(dev
, -1, qdev_get_vmsd(dev
), dev
,
926 dev
->instance_id_alias
,
927 dev
->alias_required_for_version
);
930 QLIST_FOREACH(bus
, &dev
->child_bus
, sibling
) {
931 object_property_set_bool(OBJECT(bus
), true, "realized",
933 if (local_err
!= NULL
) {
934 goto child_realize_fail
;
937 if (dev
->hotplugged
) {
940 dev
->pending_deleted_event
= false;
941 } else if (!value
&& dev
->realized
) {
942 Error
**local_errp
= NULL
;
943 QLIST_FOREACH(bus
, &dev
->child_bus
, sibling
) {
944 local_errp
= local_err
? NULL
: &local_err
;
945 object_property_set_bool(OBJECT(bus
), false, "realized",
948 if (qdev_get_vmsd(dev
)) {
949 vmstate_unregister(dev
, qdev_get_vmsd(dev
), dev
);
952 local_errp
= local_err
? NULL
: &local_err
;
953 dc
->unrealize(dev
, local_errp
);
955 dev
->pending_deleted_event
= true;
956 DEVICE_LISTENER_CALL(unrealize
, Reverse
, dev
);
959 if (local_err
!= NULL
) {
963 dev
->realized
= value
;
967 QLIST_FOREACH(bus
, &dev
->child_bus
, sibling
) {
968 object_property_set_bool(OBJECT(bus
), false, "realized",
972 if (qdev_get_vmsd(dev
)) {
973 vmstate_unregister(dev
, qdev_get_vmsd(dev
), dev
);
978 dc
->unrealize(dev
, NULL
);
982 error_propagate(errp
, local_err
);
985 static bool device_get_hotpluggable(Object
*obj
, Error
**errp
)
987 DeviceClass
*dc
= DEVICE_GET_CLASS(obj
);
988 DeviceState
*dev
= DEVICE(obj
);
990 return dc
->hotpluggable
&& (dev
->parent_bus
== NULL
||
991 qbus_is_hotpluggable(dev
->parent_bus
));
994 static bool device_get_hotplugged(Object
*obj
, Error
**err
)
996 DeviceState
*dev
= DEVICE(obj
);
998 return dev
->hotplugged
;
1001 static void device_set_hotplugged(Object
*obj
, bool value
, Error
**err
)
1003 DeviceState
*dev
= DEVICE(obj
);
1005 dev
->hotplugged
= value
;
1008 static void device_initfn(Object
*obj
)
1010 DeviceState
*dev
= DEVICE(obj
);
1015 dev
->hotplugged
= 1;
1016 qdev_hot_added
= true;
1019 dev
->instance_id_alias
= -1;
1020 dev
->realized
= false;
1022 object_property_add_bool(obj
, "realized",
1023 device_get_realized
, device_set_realized
, NULL
);
1024 object_property_add_bool(obj
, "hotpluggable",
1025 device_get_hotpluggable
, NULL
, NULL
);
1026 object_property_add_bool(obj
, "hotplugged",
1027 device_get_hotplugged
, device_set_hotplugged
,
1030 class = object_get_class(OBJECT(dev
));
1032 for (prop
= DEVICE_CLASS(class)->props
; prop
&& prop
->name
; prop
++) {
1033 qdev_property_add_legacy(dev
, prop
, &error_abort
);
1034 qdev_property_add_static(dev
, prop
, &error_abort
);
1036 class = object_class_get_parent(class);
1037 } while (class != object_class_by_name(TYPE_DEVICE
));
1039 object_property_add_link(OBJECT(dev
), "parent_bus", TYPE_BUS
,
1040 (Object
**)&dev
->parent_bus
, NULL
, 0,
1042 QLIST_INIT(&dev
->gpios
);
1045 static void device_post_init(Object
*obj
)
1047 qdev_prop_set_globals(DEVICE(obj
));
1050 /* Unlink device from bus and free the structure. */
1051 static void device_finalize(Object
*obj
)
1053 NamedGPIOList
*ngl
, *next
;
1055 DeviceState
*dev
= DEVICE(obj
);
1057 QLIST_FOREACH_SAFE(ngl
, &dev
->gpios
, node
, next
) {
1058 QLIST_REMOVE(ngl
, node
);
1059 qemu_free_irqs(ngl
->in
, ngl
->num_in
);
1062 /* ngl->out irqs are owned by the other end and should not be freed
1068 static void device_class_base_init(ObjectClass
*class, void *data
)
1070 DeviceClass
*klass
= DEVICE_CLASS(class);
1072 /* We explicitly look up properties in the superclasses,
1073 * so do not propagate them to the subclasses.
1075 klass
->props
= NULL
;
1078 static void device_unparent(Object
*obj
)
1080 DeviceState
*dev
= DEVICE(obj
);
1083 if (dev
->realized
) {
1084 object_property_set_bool(obj
, false, "realized", NULL
);
1086 while (dev
->num_child_bus
) {
1087 bus
= QLIST_FIRST(&dev
->child_bus
);
1088 object_unparent(OBJECT(bus
));
1090 if (dev
->parent_bus
) {
1091 bus_remove_child(dev
->parent_bus
, dev
);
1092 object_unref(OBJECT(dev
->parent_bus
));
1093 dev
->parent_bus
= NULL
;
1096 /* Only send event if the device had been completely realized */
1097 if (dev
->pending_deleted_event
) {
1098 gchar
*path
= object_get_canonical_path(OBJECT(dev
));
1100 qapi_event_send_device_deleted(!!dev
->id
, dev
->id
, path
, &error_abort
);
1104 qemu_opts_del(dev
->opts
);
1108 static void device_class_init(ObjectClass
*class, void *data
)
1110 DeviceClass
*dc
= DEVICE_CLASS(class);
1112 class->unparent
= device_unparent
;
1113 dc
->realize
= device_realize
;
1114 dc
->unrealize
= device_unrealize
;
1116 /* by default all devices were considered as hotpluggable,
1117 * so with intent to check it in generic qdev_unplug() /
1118 * device_set_realized() functions make every device
1119 * hotpluggable. Devices that shouldn't be hotpluggable,
1120 * should override it in their class_init()
1122 dc
->hotpluggable
= true;
1125 void device_reset(DeviceState
*dev
)
1127 DeviceClass
*klass
= DEVICE_GET_CLASS(dev
);
1134 Object
*qdev_get_machine(void)
1139 dev
= container_get(object_get_root(), "/machine");
1145 static const TypeInfo device_type_info
= {
1146 .name
= TYPE_DEVICE
,
1147 .parent
= TYPE_OBJECT
,
1148 .instance_size
= sizeof(DeviceState
),
1149 .instance_init
= device_initfn
,
1150 .instance_post_init
= device_post_init
,
1151 .instance_finalize
= device_finalize
,
1152 .class_base_init
= device_class_base_init
,
1153 .class_init
= device_class_init
,
1155 .class_size
= sizeof(DeviceClass
),
1158 static void qdev_register_types(void)
1160 type_register_static(&device_type_info
);
1163 type_init(qdev_register_types
)