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 structure
130 and allows properties to be set. qdev_init should be called to
131 initialize the actual device emulation. */
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 /* Initialize a device. Device properties should be set before calling
172 this function. IRQs and MMIO regions should be connected/mapped after
173 calling this function.
174 On failure, destroy the device and return negative value.
175 Return 0 on success. */
176 int qdev_init(DeviceState
*dev
)
178 Error
*local_err
= NULL
;
180 assert(!dev
->realized
);
182 object_property_set_bool(OBJECT(dev
), true, "realized", &local_err
);
183 if (local_err
!= NULL
) {
184 qerror_report_err(local_err
);
185 error_free(local_err
);
186 object_unparent(OBJECT(dev
));
192 static void device_realize(DeviceState
*dev
, Error
**errp
)
194 DeviceClass
*dc
= DEVICE_GET_CLASS(dev
);
197 int rc
= dc
->init(dev
);
199 error_setg(errp
, "Device initialization failed.");
205 static void device_unrealize(DeviceState
*dev
, Error
**errp
)
207 DeviceClass
*dc
= DEVICE_GET_CLASS(dev
);
210 int rc
= dc
->exit(dev
);
212 error_setg(errp
, "Device exit failed.");
218 void qdev_set_legacy_instance_id(DeviceState
*dev
, int alias_id
,
219 int required_for_version
)
221 assert(!dev
->realized
);
222 dev
->instance_id_alias
= alias_id
;
223 dev
->alias_required_for_version
= required_for_version
;
226 static HotplugHandler
*qdev_get_hotplug_handler(DeviceState
*dev
)
228 HotplugHandler
*hotplug_ctrl
= NULL
;
230 if (dev
->parent_bus
&& dev
->parent_bus
->hotplug_handler
) {
231 hotplug_ctrl
= dev
->parent_bus
->hotplug_handler
;
232 } else if (object_dynamic_cast(qdev_get_machine(), TYPE_MACHINE
)) {
233 MachineState
*machine
= MACHINE(qdev_get_machine());
234 MachineClass
*mc
= MACHINE_GET_CLASS(machine
);
236 if (mc
->get_hotplug_handler
) {
237 hotplug_ctrl
= mc
->get_hotplug_handler(machine
, dev
);
243 void qdev_unplug(DeviceState
*dev
, Error
**errp
)
245 DeviceClass
*dc
= DEVICE_GET_CLASS(dev
);
246 HotplugHandler
*hotplug_ctrl
;
247 HotplugHandlerClass
*hdc
;
249 if (dev
->parent_bus
&& !qbus_is_hotpluggable(dev
->parent_bus
)) {
250 error_set(errp
, QERR_BUS_NO_HOTPLUG
, dev
->parent_bus
->name
);
254 if (!dc
->hotpluggable
) {
255 error_set(errp
, QERR_DEVICE_NO_HOTPLUG
,
256 object_get_typename(OBJECT(dev
)));
260 qdev_hot_removed
= true;
262 hotplug_ctrl
= qdev_get_hotplug_handler(dev
);
263 /* hotpluggable device MUST have HotplugHandler, if it doesn't
264 * then something is very wrong with it */
265 g_assert(hotplug_ctrl
);
267 /* If device supports async unplug just request it to be done,
268 * otherwise just remove it synchronously */
269 hdc
= HOTPLUG_HANDLER_GET_CLASS(hotplug_ctrl
);
270 if (hdc
->unplug_request
) {
271 hotplug_handler_unplug_request(hotplug_ctrl
, dev
, errp
);
273 hotplug_handler_unplug(hotplug_ctrl
, dev
, errp
);
277 static int qdev_reset_one(DeviceState
*dev
, void *opaque
)
284 static int qbus_reset_one(BusState
*bus
, void *opaque
)
286 BusClass
*bc
= BUS_GET_CLASS(bus
);
293 void qdev_reset_all(DeviceState
*dev
)
295 qdev_walk_children(dev
, NULL
, NULL
, qdev_reset_one
, qbus_reset_one
, NULL
);
298 void qbus_reset_all(BusState
*bus
)
300 qbus_walk_children(bus
, NULL
, NULL
, qdev_reset_one
, qbus_reset_one
, NULL
);
303 void qbus_reset_all_fn(void *opaque
)
305 BusState
*bus
= opaque
;
309 /* can be used as ->unplug() callback for the simple cases */
310 void qdev_simple_device_unplug_cb(HotplugHandler
*hotplug_dev
,
311 DeviceState
*dev
, Error
**errp
)
314 object_unparent(OBJECT(dev
));
317 /* Like qdev_init(), but terminate program via error_report() instead of
318 returning an error value. This is okay during machine creation.
319 Don't use for hotplug, because there callers need to recover from
320 failure. Exception: if you know the device's init() callback can't
321 fail, then qdev_init_nofail() can't fail either, and is therefore
322 usable even then. But relying on the device implementation that
323 way is somewhat unclean, and best avoided. */
324 void qdev_init_nofail(DeviceState
*dev
)
326 const char *typename
= object_get_typename(OBJECT(dev
));
328 if (qdev_init(dev
) < 0) {
329 error_report("Initialization of device %s failed", typename
);
334 void qdev_machine_creation_done(void)
337 * ok, initial machine setup is done, starting from now we can
338 * only create hotpluggable devices
343 bool qdev_machine_modified(void)
345 return qdev_hot_added
|| qdev_hot_removed
;
348 BusState
*qdev_get_parent_bus(DeviceState
*dev
)
350 return dev
->parent_bus
;
353 static NamedGPIOList
*qdev_get_named_gpio_list(DeviceState
*dev
,
358 QLIST_FOREACH(ngl
, &dev
->gpios
, node
) {
359 /* NULL is a valid and matchable name, otherwise do a normal
362 if ((!ngl
->name
&& !name
) ||
363 (name
&& ngl
->name
&& strcmp(name
, ngl
->name
) == 0)) {
368 ngl
= g_malloc0(sizeof(*ngl
));
369 ngl
->name
= g_strdup(name
);
370 QLIST_INSERT_HEAD(&dev
->gpios
, ngl
, node
);
374 void qdev_init_gpio_in_named(DeviceState
*dev
, qemu_irq_handler handler
,
375 const char *name
, int n
)
378 NamedGPIOList
*gpio_list
= qdev_get_named_gpio_list(dev
, name
);
379 char *propname
= g_strdup_printf("%s[*]", name
? name
: "unnamed-gpio-in");
381 assert(gpio_list
->num_out
== 0 || !name
);
382 gpio_list
->in
= qemu_extend_irqs(gpio_list
->in
, gpio_list
->num_in
, handler
,
385 for (i
= gpio_list
->num_in
; i
< gpio_list
->num_in
+ n
; i
++) {
386 object_property_add_child(OBJECT(dev
), propname
,
387 OBJECT(gpio_list
->in
[i
]), &error_abort
);
391 gpio_list
->num_in
+= n
;
394 void qdev_init_gpio_in(DeviceState
*dev
, qemu_irq_handler handler
, int n
)
396 qdev_init_gpio_in_named(dev
, handler
, NULL
, n
);
399 void qdev_init_gpio_out_named(DeviceState
*dev
, qemu_irq
*pins
,
400 const char *name
, int n
)
403 NamedGPIOList
*gpio_list
= qdev_get_named_gpio_list(dev
, name
);
404 char *propname
= g_strdup_printf("%s[*]", name
? name
: "unnamed-gpio-out");
406 assert(gpio_list
->num_in
== 0 || !name
);
407 gpio_list
->num_out
+= n
;
409 for (i
= 0; i
< n
; ++i
) {
410 memset(&pins
[i
], 0, sizeof(*pins
));
411 object_property_add_link(OBJECT(dev
), propname
, TYPE_IRQ
,
413 object_property_allow_set_link
,
414 OBJ_PROP_LINK_UNREF_ON_RELEASE
,
420 void qdev_init_gpio_out(DeviceState
*dev
, qemu_irq
*pins
, int n
)
422 qdev_init_gpio_out_named(dev
, pins
, NULL
, n
);
425 qemu_irq
qdev_get_gpio_in_named(DeviceState
*dev
, const char *name
, int n
)
427 NamedGPIOList
*gpio_list
= qdev_get_named_gpio_list(dev
, name
);
429 assert(n
>= 0 && n
< gpio_list
->num_in
);
430 return gpio_list
->in
[n
];
433 qemu_irq
qdev_get_gpio_in(DeviceState
*dev
, int n
)
435 return qdev_get_gpio_in_named(dev
, NULL
, n
);
438 void qdev_connect_gpio_out_named(DeviceState
*dev
, const char *name
, int n
,
441 char *propname
= g_strdup_printf("%s[%d]",
442 name
? name
: "unnamed-gpio-out", n
);
444 /* We need a name for object_property_set_link to work. If the
445 * object has a parent, object_property_add_child will come back
446 * with an error without doing anything. If it has none, it will
447 * never fail. So we can just call it with a NULL Error pointer.
449 object_property_add_child(qdev_get_machine(), "non-qdev-gpio[*]",
452 object_property_set_link(OBJECT(dev
), OBJECT(pin
), propname
, &error_abort
);
456 /* disconnect a GPIO ouput, returning the disconnected input (if any) */
458 static qemu_irq
qdev_disconnect_gpio_out_named(DeviceState
*dev
,
459 const char *name
, int n
)
461 char *propname
= g_strdup_printf("%s[%d]",
462 name
? name
: "unnamed-gpio-out", n
);
464 qemu_irq ret
= (qemu_irq
)object_property_get_link(OBJECT(dev
), propname
,
467 object_property_set_link(OBJECT(dev
), NULL
, propname
, NULL
);
473 qemu_irq
qdev_intercept_gpio_out(DeviceState
*dev
, qemu_irq icpt
,
474 const char *name
, int n
)
476 qemu_irq disconnected
= qdev_disconnect_gpio_out_named(dev
, name
, n
);
477 qdev_connect_gpio_out_named(dev
, name
, n
, icpt
);
481 void qdev_connect_gpio_out(DeviceState
* dev
, int n
, qemu_irq pin
)
483 qdev_connect_gpio_out_named(dev
, NULL
, n
, pin
);
486 void qdev_pass_gpios(DeviceState
*dev
, DeviceState
*container
,
490 NamedGPIOList
*ngl
= qdev_get_named_gpio_list(dev
, name
);
492 for (i
= 0; i
< ngl
->num_in
; i
++) {
493 const char *nm
= ngl
->name
? ngl
->name
: "unnamed-gpio-in";
494 char *propname
= g_strdup_printf("%s[%d]", nm
, i
);
496 object_property_add_alias(OBJECT(container
), propname
,
497 OBJECT(dev
), propname
,
500 for (i
= 0; i
< ngl
->num_out
; i
++) {
501 const char *nm
= ngl
->name
? ngl
->name
: "unnamed-gpio-out";
502 char *propname
= g_strdup_printf("%s[%d]", nm
, i
);
504 object_property_add_alias(OBJECT(container
), propname
,
505 OBJECT(dev
), propname
,
508 QLIST_REMOVE(ngl
, node
);
509 QLIST_INSERT_HEAD(&container
->gpios
, ngl
, node
);
512 BusState
*qdev_get_child_bus(DeviceState
*dev
, const char *name
)
516 QLIST_FOREACH(bus
, &dev
->child_bus
, sibling
) {
517 if (strcmp(name
, bus
->name
) == 0) {
524 int qbus_walk_children(BusState
*bus
,
525 qdev_walkerfn
*pre_devfn
, qbus_walkerfn
*pre_busfn
,
526 qdev_walkerfn
*post_devfn
, qbus_walkerfn
*post_busfn
,
533 err
= pre_busfn(bus
, opaque
);
539 QTAILQ_FOREACH(kid
, &bus
->children
, sibling
) {
540 err
= qdev_walk_children(kid
->child
,
541 pre_devfn
, pre_busfn
,
542 post_devfn
, post_busfn
, opaque
);
549 err
= post_busfn(bus
, opaque
);
558 int qdev_walk_children(DeviceState
*dev
,
559 qdev_walkerfn
*pre_devfn
, qbus_walkerfn
*pre_busfn
,
560 qdev_walkerfn
*post_devfn
, qbus_walkerfn
*post_busfn
,
567 err
= pre_devfn(dev
, opaque
);
573 QLIST_FOREACH(bus
, &dev
->child_bus
, sibling
) {
574 err
= qbus_walk_children(bus
, pre_devfn
, pre_busfn
,
575 post_devfn
, post_busfn
, opaque
);
582 err
= post_devfn(dev
, opaque
);
591 DeviceState
*qdev_find_recursive(BusState
*bus
, const char *id
)
597 QTAILQ_FOREACH(kid
, &bus
->children
, sibling
) {
598 DeviceState
*dev
= kid
->child
;
600 if (dev
->id
&& strcmp(dev
->id
, id
) == 0) {
604 QLIST_FOREACH(child
, &dev
->child_bus
, sibling
) {
605 ret
= qdev_find_recursive(child
, id
);
614 static void qbus_realize(BusState
*bus
, DeviceState
*parent
, const char *name
)
616 const char *typename
= object_get_typename(OBJECT(bus
));
621 bus
->parent
= parent
;
624 bus
->name
= g_strdup(name
);
625 } else if (bus
->parent
&& bus
->parent
->id
) {
626 /* parent device has id -> use it plus parent-bus-id for bus name */
627 bus_id
= bus
->parent
->num_child_bus
;
629 len
= strlen(bus
->parent
->id
) + 16;
631 snprintf(buf
, len
, "%s.%d", bus
->parent
->id
, bus_id
);
634 /* no id -> use lowercase bus type plus global bus-id for bus name */
635 bc
= BUS_GET_CLASS(bus
);
636 bus_id
= bc
->automatic_ids
++;
638 len
= strlen(typename
) + 16;
640 len
= snprintf(buf
, len
, "%s.%d", typename
, bus_id
);
641 for (i
= 0; i
< len
; i
++) {
642 buf
[i
] = qemu_tolower(buf
[i
]);
648 QLIST_INSERT_HEAD(&bus
->parent
->child_bus
, bus
, sibling
);
649 bus
->parent
->num_child_bus
++;
650 object_property_add_child(OBJECT(bus
->parent
), bus
->name
, OBJECT(bus
), NULL
);
651 object_unref(OBJECT(bus
));
652 } else if (bus
!= sysbus_get_default()) {
653 /* TODO: once all bus devices are qdevified,
654 only reset handler for main_system_bus should be registered here. */
655 qemu_register_reset(qbus_reset_all_fn
, bus
);
659 static void bus_unparent(Object
*obj
)
661 BusState
*bus
= BUS(obj
);
664 while ((kid
= QTAILQ_FIRST(&bus
->children
)) != NULL
) {
665 DeviceState
*dev
= kid
->child
;
666 object_unparent(OBJECT(dev
));
669 QLIST_REMOVE(bus
, sibling
);
670 bus
->parent
->num_child_bus
--;
673 assert(bus
!= sysbus_get_default()); /* main_system_bus is never freed */
674 qemu_unregister_reset(qbus_reset_all_fn
, bus
);
678 static bool bus_get_realized(Object
*obj
, Error
**errp
)
680 BusState
*bus
= BUS(obj
);
682 return bus
->realized
;
685 static void bus_set_realized(Object
*obj
, bool value
, Error
**errp
)
687 BusState
*bus
= BUS(obj
);
688 BusClass
*bc
= BUS_GET_CLASS(bus
);
690 Error
*local_err
= NULL
;
692 if (value
&& !bus
->realized
) {
694 bc
->realize(bus
, &local_err
);
697 /* TODO: recursive realization */
698 } else if (!value
&& bus
->realized
) {
699 QTAILQ_FOREACH(kid
, &bus
->children
, sibling
) {
700 DeviceState
*dev
= kid
->child
;
701 object_property_set_bool(OBJECT(dev
), false, "realized",
703 if (local_err
!= NULL
) {
707 if (bc
->unrealize
&& local_err
== NULL
) {
708 bc
->unrealize(bus
, &local_err
);
712 if (local_err
!= NULL
) {
713 error_propagate(errp
, local_err
);
717 bus
->realized
= value
;
720 void qbus_create_inplace(void *bus
, size_t size
, const char *typename
,
721 DeviceState
*parent
, const char *name
)
723 object_initialize(bus
, size
, typename
);
724 qbus_realize(bus
, parent
, name
);
727 BusState
*qbus_create(const char *typename
, DeviceState
*parent
, const char *name
)
731 bus
= BUS(object_new(typename
));
732 qbus_realize(bus
, parent
, name
);
737 static char *bus_get_fw_dev_path(BusState
*bus
, DeviceState
*dev
)
739 BusClass
*bc
= BUS_GET_CLASS(bus
);
741 if (bc
->get_fw_dev_path
) {
742 return bc
->get_fw_dev_path(dev
);
748 static char *qdev_get_fw_dev_path_from_handler(BusState
*bus
, DeviceState
*dev
)
750 Object
*obj
= OBJECT(dev
);
753 while (!d
&& obj
->parent
) {
755 d
= fw_path_provider_try_get_dev_path(obj
, bus
, dev
);
760 static int qdev_get_fw_dev_path_helper(DeviceState
*dev
, char *p
, int size
)
764 if (dev
&& dev
->parent_bus
) {
766 l
= qdev_get_fw_dev_path_helper(dev
->parent_bus
->parent
, p
, size
);
767 d
= qdev_get_fw_dev_path_from_handler(dev
->parent_bus
, dev
);
769 d
= bus_get_fw_dev_path(dev
->parent_bus
, dev
);
772 l
+= snprintf(p
+ l
, size
- l
, "%s", d
);
778 l
+= snprintf(p
+ l
, size
- l
, "/");
783 char* qdev_get_fw_dev_path(DeviceState
*dev
)
788 l
= qdev_get_fw_dev_path_helper(dev
, path
, 128);
792 return g_strdup(path
);
795 char *qdev_get_dev_path(DeviceState
*dev
)
799 if (!dev
|| !dev
->parent_bus
) {
803 bc
= BUS_GET_CLASS(dev
->parent_bus
);
804 if (bc
->get_dev_path
) {
805 return bc
->get_dev_path(dev
);
812 * Legacy property handling
815 static void qdev_get_legacy_property(Object
*obj
, Visitor
*v
, void *opaque
,
816 const char *name
, Error
**errp
)
818 DeviceState
*dev
= DEVICE(obj
);
819 Property
*prop
= opaque
;
824 prop
->info
->print(dev
, prop
, buffer
, sizeof(buffer
));
825 visit_type_str(v
, &ptr
, name
, errp
);
829 * @qdev_add_legacy_property - adds a legacy property
831 * Do not use this is new code! Properties added through this interface will
832 * be given names and types in the "legacy" namespace.
834 * Legacy properties are string versions of other OOM properties. The format
835 * of the string depends on the property type.
837 static void qdev_property_add_legacy(DeviceState
*dev
, Property
*prop
,
842 /* Register pointer properties as legacy properties */
843 if (!prop
->info
->print
&& prop
->info
->get
) {
847 name
= g_strdup_printf("legacy-%s", prop
->name
);
848 object_property_add(OBJECT(dev
), name
, "str",
849 prop
->info
->print
? qdev_get_legacy_property
: prop
->info
->get
,
858 * @qdev_property_add_static - add a @Property to a device.
860 * Static properties access data in a struct. The actual type of the
861 * property and the field depends on the property type.
863 void qdev_property_add_static(DeviceState
*dev
, Property
*prop
,
866 Error
*local_err
= NULL
;
867 Object
*obj
= OBJECT(dev
);
870 * TODO qdev_prop_ptr does not have getters or setters. It must
871 * go now that it can be replaced with links. The test should be
872 * removed along with it: all static properties are read/write.
874 if (!prop
->info
->get
&& !prop
->info
->set
) {
878 object_property_add(obj
, prop
->name
, prop
->info
->name
,
879 prop
->info
->get
, prop
->info
->set
,
884 error_propagate(errp
, local_err
);
888 object_property_set_description(obj
, prop
->name
,
889 prop
->info
->description
,
892 if (prop
->qtype
== QTYPE_NONE
) {
896 if (prop
->qtype
== QTYPE_QBOOL
) {
897 object_property_set_bool(obj
, prop
->defval
, prop
->name
, &error_abort
);
898 } else if (prop
->info
->enum_table
) {
899 object_property_set_str(obj
, prop
->info
->enum_table
[prop
->defval
],
900 prop
->name
, &error_abort
);
901 } else if (prop
->qtype
== QTYPE_QINT
) {
902 object_property_set_int(obj
, prop
->defval
, prop
->name
, &error_abort
);
906 /* @qdev_alias_all_properties - Add alias properties to the source object for
907 * all qdev properties on the target DeviceState.
909 void qdev_alias_all_properties(DeviceState
*target
, Object
*source
)
914 class = object_get_class(OBJECT(target
));
916 DeviceClass
*dc
= DEVICE_CLASS(class);
918 for (prop
= dc
->props
; prop
&& prop
->name
; prop
++) {
919 object_property_add_alias(source
, prop
->name
,
920 OBJECT(target
), prop
->name
,
923 class = object_class_get_parent(class);
924 } while (class != object_class_by_name(TYPE_DEVICE
));
927 int qdev_build_hotpluggable_device_list(Object
*obj
, void *opaque
)
929 GSList
**list
= opaque
;
930 DeviceState
*dev
= DEVICE(obj
);
932 if (dev
->realized
&& object_property_get_bool(obj
, "hotpluggable", NULL
)) {
933 *list
= g_slist_append(*list
, dev
);
936 object_child_foreach(obj
, qdev_build_hotpluggable_device_list
, opaque
);
940 static bool device_get_realized(Object
*obj
, Error
**errp
)
942 DeviceState
*dev
= DEVICE(obj
);
943 return dev
->realized
;
946 static void device_set_realized(Object
*obj
, bool value
, Error
**errp
)
948 DeviceState
*dev
= DEVICE(obj
);
949 DeviceClass
*dc
= DEVICE_GET_CLASS(dev
);
950 HotplugHandler
*hotplug_ctrl
;
952 Error
*local_err
= NULL
;
954 if (dev
->hotplugged
&& !dc
->hotpluggable
) {
955 error_set(errp
, QERR_DEVICE_NO_HOTPLUG
, object_get_typename(obj
));
959 if (value
&& !dev
->realized
) {
961 static int unattached_count
;
962 gchar
*name
= g_strdup_printf("device[%d]", unattached_count
++);
964 object_property_add_child(container_get(qdev_get_machine(),
966 name
, obj
, &error_abort
);
971 dc
->realize(dev
, &local_err
);
974 if (local_err
!= NULL
) {
978 hotplug_ctrl
= qdev_get_hotplug_handler(dev
);
980 hotplug_handler_plug(hotplug_ctrl
, dev
, &local_err
);
983 if (local_err
!= NULL
) {
984 goto post_realize_fail
;
987 if (qdev_get_vmsd(dev
)) {
988 vmstate_register_with_alias_id(dev
, -1, qdev_get_vmsd(dev
), dev
,
989 dev
->instance_id_alias
,
990 dev
->alias_required_for_version
);
993 QLIST_FOREACH(bus
, &dev
->child_bus
, sibling
) {
994 object_property_set_bool(OBJECT(bus
), true, "realized",
996 if (local_err
!= NULL
) {
997 goto child_realize_fail
;
1000 if (dev
->hotplugged
) {
1003 dev
->pending_deleted_event
= false;
1004 } else if (!value
&& dev
->realized
) {
1005 Error
**local_errp
= NULL
;
1006 QLIST_FOREACH(bus
, &dev
->child_bus
, sibling
) {
1007 local_errp
= local_err
? NULL
: &local_err
;
1008 object_property_set_bool(OBJECT(bus
), false, "realized",
1011 if (qdev_get_vmsd(dev
)) {
1012 vmstate_unregister(dev
, qdev_get_vmsd(dev
), dev
);
1014 if (dc
->unrealize
) {
1015 local_errp
= local_err
? NULL
: &local_err
;
1016 dc
->unrealize(dev
, local_errp
);
1018 dev
->pending_deleted_event
= true;
1021 if (local_err
!= NULL
) {
1025 dev
->realized
= value
;
1029 QLIST_FOREACH(bus
, &dev
->child_bus
, sibling
) {
1030 object_property_set_bool(OBJECT(bus
), false, "realized",
1034 if (qdev_get_vmsd(dev
)) {
1035 vmstate_unregister(dev
, qdev_get_vmsd(dev
), dev
);
1039 if (dc
->unrealize
) {
1040 dc
->unrealize(dev
, NULL
);
1044 error_propagate(errp
, local_err
);
1048 static bool device_get_hotpluggable(Object
*obj
, Error
**errp
)
1050 DeviceClass
*dc
= DEVICE_GET_CLASS(obj
);
1051 DeviceState
*dev
= DEVICE(obj
);
1053 return dc
->hotpluggable
&& (dev
->parent_bus
== NULL
||
1054 qbus_is_hotpluggable(dev
->parent_bus
));
1057 static bool device_get_hotplugged(Object
*obj
, Error
**err
)
1059 DeviceState
*dev
= DEVICE(obj
);
1061 return dev
->hotplugged
;
1064 static void device_set_hotplugged(Object
*obj
, bool value
, Error
**err
)
1066 DeviceState
*dev
= DEVICE(obj
);
1068 dev
->hotplugged
= value
;
1071 static void device_initfn(Object
*obj
)
1073 DeviceState
*dev
= DEVICE(obj
);
1078 dev
->hotplugged
= 1;
1079 qdev_hot_added
= true;
1082 dev
->instance_id_alias
= -1;
1083 dev
->realized
= false;
1085 object_property_add_bool(obj
, "realized",
1086 device_get_realized
, device_set_realized
, NULL
);
1087 object_property_add_bool(obj
, "hotpluggable",
1088 device_get_hotpluggable
, NULL
, NULL
);
1089 object_property_add_bool(obj
, "hotplugged",
1090 device_get_hotplugged
, device_set_hotplugged
,
1093 class = object_get_class(OBJECT(dev
));
1095 for (prop
= DEVICE_CLASS(class)->props
; prop
&& prop
->name
; prop
++) {
1096 qdev_property_add_legacy(dev
, prop
, &error_abort
);
1097 qdev_property_add_static(dev
, prop
, &error_abort
);
1099 class = object_class_get_parent(class);
1100 } while (class != object_class_by_name(TYPE_DEVICE
));
1102 object_property_add_link(OBJECT(dev
), "parent_bus", TYPE_BUS
,
1103 (Object
**)&dev
->parent_bus
, NULL
, 0,
1105 QLIST_INIT(&dev
->gpios
);
1108 static void device_post_init(Object
*obj
)
1111 qdev_prop_set_globals(DEVICE(obj
), &err
);
1113 qerror_report_err(err
);
1119 /* Unlink device from bus and free the structure. */
1120 static void device_finalize(Object
*obj
)
1122 NamedGPIOList
*ngl
, *next
;
1124 DeviceState
*dev
= DEVICE(obj
);
1126 qemu_opts_del(dev
->opts
);
1129 QLIST_FOREACH_SAFE(ngl
, &dev
->gpios
, node
, next
) {
1130 QLIST_REMOVE(ngl
, node
);
1131 qemu_free_irqs(ngl
->in
, ngl
->num_in
);
1134 /* ngl->out irqs are owned by the other end and should not be freed
1140 static void device_class_base_init(ObjectClass
*class, void *data
)
1142 DeviceClass
*klass
= DEVICE_CLASS(class);
1144 /* We explicitly look up properties in the superclasses,
1145 * so do not propagate them to the subclasses.
1147 klass
->props
= NULL
;
1150 static void device_unparent(Object
*obj
)
1152 DeviceState
*dev
= DEVICE(obj
);
1155 if (dev
->realized
) {
1156 object_property_set_bool(obj
, false, "realized", NULL
);
1158 while (dev
->num_child_bus
) {
1159 bus
= QLIST_FIRST(&dev
->child_bus
);
1160 object_unparent(OBJECT(bus
));
1162 if (dev
->parent_bus
) {
1163 bus_remove_child(dev
->parent_bus
, dev
);
1164 object_unref(OBJECT(dev
->parent_bus
));
1165 dev
->parent_bus
= NULL
;
1168 /* Only send event if the device had been completely realized */
1169 if (dev
->pending_deleted_event
) {
1170 gchar
*path
= object_get_canonical_path(OBJECT(dev
));
1172 qapi_event_send_device_deleted(!!dev
->id
, dev
->id
, path
, &error_abort
);
1177 static void device_class_init(ObjectClass
*class, void *data
)
1179 DeviceClass
*dc
= DEVICE_CLASS(class);
1181 class->unparent
= device_unparent
;
1182 dc
->realize
= device_realize
;
1183 dc
->unrealize
= device_unrealize
;
1185 /* by default all devices were considered as hotpluggable,
1186 * so with intent to check it in generic qdev_unplug() /
1187 * device_set_realized() functions make every device
1188 * hotpluggable. Devices that shouldn't be hotpluggable,
1189 * should override it in their class_init()
1191 dc
->hotpluggable
= true;
1194 void device_reset(DeviceState
*dev
)
1196 DeviceClass
*klass
= DEVICE_GET_CLASS(dev
);
1203 Object
*qdev_get_machine(void)
1208 dev
= container_get(object_get_root(), "/machine");
1214 static const TypeInfo device_type_info
= {
1215 .name
= TYPE_DEVICE
,
1216 .parent
= TYPE_OBJECT
,
1217 .instance_size
= sizeof(DeviceState
),
1218 .instance_init
= device_initfn
,
1219 .instance_post_init
= device_post_init
,
1220 .instance_finalize
= device_finalize
,
1221 .class_base_init
= device_class_base_init
,
1222 .class_init
= device_class_init
,
1224 .class_size
= sizeof(DeviceClass
),
1227 static void qbus_initfn(Object
*obj
)
1229 BusState
*bus
= BUS(obj
);
1231 QTAILQ_INIT(&bus
->children
);
1232 object_property_add_link(obj
, QDEV_HOTPLUG_HANDLER_PROPERTY
,
1233 TYPE_HOTPLUG_HANDLER
,
1234 (Object
**)&bus
->hotplug_handler
,
1235 object_property_allow_set_link
,
1236 OBJ_PROP_LINK_UNREF_ON_RELEASE
,
1238 object_property_add_bool(obj
, "realized",
1239 bus_get_realized
, bus_set_realized
, NULL
);
1242 static char *default_bus_get_fw_dev_path(DeviceState
*dev
)
1244 return g_strdup(object_get_typename(OBJECT(dev
)));
1247 static void bus_class_init(ObjectClass
*class, void *data
)
1249 BusClass
*bc
= BUS_CLASS(class);
1251 class->unparent
= bus_unparent
;
1252 bc
->get_fw_dev_path
= default_bus_get_fw_dev_path
;
1255 static void qbus_finalize(Object
*obj
)
1257 BusState
*bus
= BUS(obj
);
1259 g_free((char *)bus
->name
);
1262 static const TypeInfo bus_info
= {
1264 .parent
= TYPE_OBJECT
,
1265 .instance_size
= sizeof(BusState
),
1267 .class_size
= sizeof(BusClass
),
1268 .instance_init
= qbus_initfn
,
1269 .instance_finalize
= qbus_finalize
,
1270 .class_init
= bus_class_init
,
1273 static void qdev_register_types(void)
1275 type_register_static(&bus_info
);
1276 type_register_static(&device_type_info
);
1279 type_init(qdev_register_types
)