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 "sysemu/sysemu.h"
30 #include "qapi/error.h"
31 #include "qapi/qmp/qerror.h"
32 #include "qapi/visitor.h"
33 #include "qapi/qmp/qjson.h"
34 #include "monitor/monitor.h"
35 #include "hw/hotplug.h"
38 static bool qdev_hot_added
= false;
39 static bool qdev_hot_removed
= false;
41 const VMStateDescription
*qdev_get_vmsd(DeviceState
*dev
)
43 DeviceClass
*dc
= DEVICE_GET_CLASS(dev
);
47 const char *qdev_fw_name(DeviceState
*dev
)
49 DeviceClass
*dc
= DEVICE_GET_CLASS(dev
);
55 return object_get_typename(OBJECT(dev
));
58 static void qdev_property_add_legacy(DeviceState
*dev
, Property
*prop
,
61 static void bus_remove_child(BusState
*bus
, DeviceState
*child
)
65 QTAILQ_FOREACH(kid
, &bus
->children
, sibling
) {
66 if (kid
->child
== child
) {
69 snprintf(name
, sizeof(name
), "child[%d]", kid
->index
);
70 QTAILQ_REMOVE(&bus
->children
, kid
, sibling
);
72 /* This gives back ownership of kid->child back to us. */
73 object_property_del(OBJECT(bus
), name
, NULL
);
74 object_unref(OBJECT(kid
->child
));
81 static void bus_add_child(BusState
*bus
, DeviceState
*child
)
84 BusChild
*kid
= g_malloc0(sizeof(*kid
));
87 assert(bus
->allow_hotplug
);
90 kid
->index
= bus
->max_index
++;
92 object_ref(OBJECT(kid
->child
));
94 QTAILQ_INSERT_HEAD(&bus
->children
, kid
, sibling
);
96 /* This transfers ownership of kid->child to the property. */
97 snprintf(name
, sizeof(name
), "child[%d]", kid
->index
);
98 object_property_add_link(OBJECT(bus
), name
,
99 object_get_typename(OBJECT(child
)),
100 (Object
**)&kid
->child
, 0, NULL
);
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 structure
111 and allows properties to be set. qdev_init should be called to
112 initialize the actual device emulation. */
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 bus
= sysbus_get_default();
147 qdev_set_parent_bus(dev
, bus
);
148 object_unref(OBJECT(dev
));
152 /* Initialize a device. Device properties should be set before calling
153 this function. IRQs and MMIO regions should be connected/mapped after
154 calling this function.
155 On failure, destroy the device and return negative value.
156 Return 0 on success. */
157 int qdev_init(DeviceState
*dev
)
159 Error
*local_err
= NULL
;
161 assert(!dev
->realized
);
163 object_property_set_bool(OBJECT(dev
), true, "realized", &local_err
);
164 if (local_err
!= NULL
) {
165 qerror_report_err(local_err
);
166 error_free(local_err
);
167 object_unparent(OBJECT(dev
));
173 static void device_realize(DeviceState
*dev
, Error
**err
)
175 DeviceClass
*dc
= DEVICE_GET_CLASS(dev
);
178 int rc
= dc
->init(dev
);
180 error_setg(err
, "Device initialization failed.");
186 static void device_unrealize(DeviceState
*dev
, Error
**errp
)
188 DeviceClass
*dc
= DEVICE_GET_CLASS(dev
);
191 int rc
= dc
->exit(dev
);
193 error_setg(errp
, "Device exit failed.");
199 void qdev_set_legacy_instance_id(DeviceState
*dev
, int alias_id
,
200 int required_for_version
)
202 assert(!dev
->realized
);
203 dev
->instance_id_alias
= alias_id
;
204 dev
->alias_required_for_version
= required_for_version
;
207 void qdev_unplug(DeviceState
*dev
, Error
**errp
)
209 DeviceClass
*dc
= DEVICE_GET_CLASS(dev
);
211 if (dev
->parent_bus
&& !dev
->parent_bus
->allow_hotplug
) {
212 error_set(errp
, QERR_BUS_NO_HOTPLUG
, dev
->parent_bus
->name
);
216 if (!dc
->hotpluggable
) {
217 error_set(errp
, QERR_DEVICE_NO_HOTPLUG
,
218 object_get_typename(OBJECT(dev
)));
222 qdev_hot_removed
= true;
224 if (dev
->parent_bus
&& dev
->parent_bus
->hotplug_handler
) {
225 hotplug_handler_unplug(dev
->parent_bus
->hotplug_handler
, dev
, errp
);
227 assert(dc
->unplug
!= NULL
);
228 if (dc
->unplug(dev
) < 0) { /* legacy handler */
229 error_set(errp
, QERR_UNDEFINED_ERROR
);
234 static int qdev_reset_one(DeviceState
*dev
, void *opaque
)
241 static int qbus_reset_one(BusState
*bus
, void *opaque
)
243 BusClass
*bc
= BUS_GET_CLASS(bus
);
250 void qdev_reset_all(DeviceState
*dev
)
252 qdev_walk_children(dev
, NULL
, NULL
, qdev_reset_one
, qbus_reset_one
, NULL
);
255 void qbus_reset_all(BusState
*bus
)
257 qbus_walk_children(bus
, NULL
, NULL
, qdev_reset_one
, qbus_reset_one
, NULL
);
260 void qbus_reset_all_fn(void *opaque
)
262 BusState
*bus
= opaque
;
266 /* can be used as ->unplug() callback for the simple cases */
267 int qdev_simple_unplug_cb(DeviceState
*dev
)
270 object_unparent(OBJECT(dev
));
275 /* Like qdev_init(), but terminate program via error_report() instead of
276 returning an error value. This is okay during machine creation.
277 Don't use for hotplug, because there callers need to recover from
278 failure. Exception: if you know the device's init() callback can't
279 fail, then qdev_init_nofail() can't fail either, and is therefore
280 usable even then. But relying on the device implementation that
281 way is somewhat unclean, and best avoided. */
282 void qdev_init_nofail(DeviceState
*dev
)
284 const char *typename
= object_get_typename(OBJECT(dev
));
286 if (qdev_init(dev
) < 0) {
287 error_report("Initialization of device %s failed", typename
);
292 void qdev_machine_creation_done(void)
295 * ok, initial machine setup is done, starting from now we can
296 * only create hotpluggable devices
301 bool qdev_machine_modified(void)
303 return qdev_hot_added
|| qdev_hot_removed
;
306 BusState
*qdev_get_parent_bus(DeviceState
*dev
)
308 return dev
->parent_bus
;
311 void qdev_init_gpio_in(DeviceState
*dev
, qemu_irq_handler handler
, int n
)
313 dev
->gpio_in
= qemu_extend_irqs(dev
->gpio_in
, dev
->num_gpio_in
, handler
,
315 dev
->num_gpio_in
+= n
;
318 void qdev_init_gpio_out(DeviceState
*dev
, qemu_irq
*pins
, int n
)
320 assert(dev
->num_gpio_out
== 0);
321 dev
->num_gpio_out
= n
;
322 dev
->gpio_out
= pins
;
325 qemu_irq
qdev_get_gpio_in(DeviceState
*dev
, int n
)
327 assert(n
>= 0 && n
< dev
->num_gpio_in
);
328 return dev
->gpio_in
[n
];
331 void qdev_connect_gpio_out(DeviceState
* dev
, int n
, qemu_irq pin
)
333 assert(n
>= 0 && n
< dev
->num_gpio_out
);
334 dev
->gpio_out
[n
] = pin
;
337 BusState
*qdev_get_child_bus(DeviceState
*dev
, const char *name
)
341 QLIST_FOREACH(bus
, &dev
->child_bus
, sibling
) {
342 if (strcmp(name
, bus
->name
) == 0) {
349 int qbus_walk_children(BusState
*bus
,
350 qdev_walkerfn
*pre_devfn
, qbus_walkerfn
*pre_busfn
,
351 qdev_walkerfn
*post_devfn
, qbus_walkerfn
*post_busfn
,
358 err
= pre_busfn(bus
, opaque
);
364 QTAILQ_FOREACH(kid
, &bus
->children
, sibling
) {
365 err
= qdev_walk_children(kid
->child
,
366 pre_devfn
, pre_busfn
,
367 post_devfn
, post_busfn
, opaque
);
374 err
= post_busfn(bus
, opaque
);
383 int qdev_walk_children(DeviceState
*dev
,
384 qdev_walkerfn
*pre_devfn
, qbus_walkerfn
*pre_busfn
,
385 qdev_walkerfn
*post_devfn
, qbus_walkerfn
*post_busfn
,
392 err
= pre_devfn(dev
, opaque
);
398 QLIST_FOREACH(bus
, &dev
->child_bus
, sibling
) {
399 err
= qbus_walk_children(bus
, pre_devfn
, pre_busfn
,
400 post_devfn
, post_busfn
, opaque
);
407 err
= post_devfn(dev
, opaque
);
416 DeviceState
*qdev_find_recursive(BusState
*bus
, const char *id
)
422 QTAILQ_FOREACH(kid
, &bus
->children
, sibling
) {
423 DeviceState
*dev
= kid
->child
;
425 if (dev
->id
&& strcmp(dev
->id
, id
) == 0) {
429 QLIST_FOREACH(child
, &dev
->child_bus
, sibling
) {
430 ret
= qdev_find_recursive(child
, id
);
439 static void qbus_realize(BusState
*bus
, DeviceState
*parent
, const char *name
)
441 const char *typename
= object_get_typename(OBJECT(bus
));
446 bus
->parent
= parent
;
449 bus
->name
= g_strdup(name
);
450 } else if (bus
->parent
&& bus
->parent
->id
) {
451 /* parent device has id -> use it plus parent-bus-id for bus name */
452 bus_id
= bus
->parent
->num_child_bus
;
454 len
= strlen(bus
->parent
->id
) + 16;
456 snprintf(buf
, len
, "%s.%d", bus
->parent
->id
, bus_id
);
459 /* no id -> use lowercase bus type plus global bus-id for bus name */
460 bc
= BUS_GET_CLASS(bus
);
461 bus_id
= bc
->automatic_ids
++;
463 len
= strlen(typename
) + 16;
465 len
= snprintf(buf
, len
, "%s.%d", typename
, bus_id
);
466 for (i
= 0; i
< len
; i
++) {
467 buf
[i
] = qemu_tolower(buf
[i
]);
473 QLIST_INSERT_HEAD(&bus
->parent
->child_bus
, bus
, sibling
);
474 bus
->parent
->num_child_bus
++;
475 object_property_add_child(OBJECT(bus
->parent
), bus
->name
, OBJECT(bus
), NULL
);
476 object_unref(OBJECT(bus
));
477 } else if (bus
!= sysbus_get_default()) {
478 /* TODO: once all bus devices are qdevified,
479 only reset handler for main_system_bus should be registered here. */
480 qemu_register_reset(qbus_reset_all_fn
, bus
);
484 static void bus_unparent(Object
*obj
)
486 BusState
*bus
= BUS(obj
);
489 while ((kid
= QTAILQ_FIRST(&bus
->children
)) != NULL
) {
490 DeviceState
*dev
= kid
->child
;
491 object_unparent(OBJECT(dev
));
494 QLIST_REMOVE(bus
, sibling
);
495 bus
->parent
->num_child_bus
--;
498 assert(bus
!= sysbus_get_default()); /* main_system_bus is never freed */
499 qemu_unregister_reset(qbus_reset_all_fn
, bus
);
503 static bool bus_get_realized(Object
*obj
, Error
**err
)
505 BusState
*bus
= BUS(obj
);
507 return bus
->realized
;
510 static void bus_set_realized(Object
*obj
, bool value
, Error
**err
)
512 BusState
*bus
= BUS(obj
);
513 BusClass
*bc
= BUS_GET_CLASS(bus
);
514 Error
*local_err
= NULL
;
516 if (value
&& !bus
->realized
) {
518 bc
->realize(bus
, &local_err
);
520 if (local_err
!= NULL
) {
525 } else if (!value
&& bus
->realized
) {
527 bc
->unrealize(bus
, &local_err
);
529 if (local_err
!= NULL
) {
535 bus
->realized
= value
;
539 error_propagate(err
, local_err
);
542 void qbus_create_inplace(void *bus
, size_t size
, const char *typename
,
543 DeviceState
*parent
, const char *name
)
545 object_initialize(bus
, size
, typename
);
546 qbus_realize(bus
, parent
, name
);
549 BusState
*qbus_create(const char *typename
, DeviceState
*parent
, const char *name
)
553 bus
= BUS(object_new(typename
));
554 qbus_realize(bus
, parent
, name
);
559 static char *bus_get_fw_dev_path(BusState
*bus
, DeviceState
*dev
)
561 BusClass
*bc
= BUS_GET_CLASS(bus
);
563 if (bc
->get_fw_dev_path
) {
564 return bc
->get_fw_dev_path(dev
);
570 static int qdev_get_fw_dev_path_helper(DeviceState
*dev
, char *p
, int size
)
574 if (dev
&& dev
->parent_bus
) {
576 l
= qdev_get_fw_dev_path_helper(dev
->parent_bus
->parent
, p
, size
);
577 d
= bus_get_fw_dev_path(dev
->parent_bus
, dev
);
579 l
+= snprintf(p
+ l
, size
- l
, "%s", d
);
585 l
+= snprintf(p
+ l
, size
- l
, "/");
590 char* qdev_get_fw_dev_path(DeviceState
*dev
)
595 l
= qdev_get_fw_dev_path_helper(dev
, path
, 128);
599 return g_strdup(path
);
602 char *qdev_get_dev_path(DeviceState
*dev
)
606 if (!dev
|| !dev
->parent_bus
) {
610 bc
= BUS_GET_CLASS(dev
->parent_bus
);
611 if (bc
->get_dev_path
) {
612 return bc
->get_dev_path(dev
);
619 * Legacy property handling
622 static void qdev_get_legacy_property(Object
*obj
, Visitor
*v
, void *opaque
,
623 const char *name
, Error
**errp
)
625 DeviceState
*dev
= DEVICE(obj
);
626 Property
*prop
= opaque
;
631 prop
->info
->print(dev
, prop
, buffer
, sizeof(buffer
));
632 visit_type_str(v
, &ptr
, name
, errp
);
636 * @qdev_add_legacy_property - adds a legacy property
638 * Do not use this is new code! Properties added through this interface will
639 * be given names and types in the "legacy" namespace.
641 * Legacy properties are string versions of other OOM properties. The format
642 * of the string depends on the property type.
644 void qdev_property_add_legacy(DeviceState
*dev
, Property
*prop
,
649 /* Register pointer properties as legacy properties */
650 if (!prop
->info
->print
&& prop
->info
->get
) {
654 name
= g_strdup_printf("legacy-%s", prop
->name
);
655 object_property_add(OBJECT(dev
), name
, "str",
656 prop
->info
->print
? qdev_get_legacy_property
: prop
->info
->get
,
665 * @qdev_property_add_static - add a @Property to a device.
667 * Static properties access data in a struct. The actual type of the
668 * property and the field depends on the property type.
670 void qdev_property_add_static(DeviceState
*dev
, Property
*prop
,
673 Error
*local_err
= NULL
;
674 Object
*obj
= OBJECT(dev
);
677 * TODO qdev_prop_ptr does not have getters or setters. It must
678 * go now that it can be replaced with links. The test should be
679 * removed along with it: all static properties are read/write.
681 if (!prop
->info
->get
&& !prop
->info
->set
) {
685 object_property_add(obj
, prop
->name
, prop
->info
->name
,
686 prop
->info
->get
, prop
->info
->set
,
691 error_propagate(errp
, local_err
);
694 if (prop
->qtype
== QTYPE_NONE
) {
698 if (prop
->qtype
== QTYPE_QBOOL
) {
699 object_property_set_bool(obj
, prop
->defval
, prop
->name
, &error_abort
);
700 } else if (prop
->info
->enum_table
) {
701 object_property_set_str(obj
, prop
->info
->enum_table
[prop
->defval
],
702 prop
->name
, &error_abort
);
703 } else if (prop
->qtype
== QTYPE_QINT
) {
704 object_property_set_int(obj
, prop
->defval
, prop
->name
, &error_abort
);
708 static bool device_get_realized(Object
*obj
, Error
**err
)
710 DeviceState
*dev
= DEVICE(obj
);
711 return dev
->realized
;
714 static void device_set_realized(Object
*obj
, bool value
, Error
**err
)
716 DeviceState
*dev
= DEVICE(obj
);
717 DeviceClass
*dc
= DEVICE_GET_CLASS(dev
);
719 Error
*local_err
= NULL
;
721 if (dev
->hotplugged
&& !dc
->hotpluggable
) {
722 error_set(err
, QERR_DEVICE_NO_HOTPLUG
, object_get_typename(obj
));
726 if (value
&& !dev
->realized
) {
727 if (!obj
->parent
&& local_err
== NULL
) {
728 static int unattached_count
;
729 gchar
*name
= g_strdup_printf("device[%d]", unattached_count
++);
731 object_property_add_child(container_get(qdev_get_machine(),
733 name
, obj
, &local_err
);
738 dc
->realize(dev
, &local_err
);
741 if (dev
->parent_bus
&& dev
->parent_bus
->hotplug_handler
&&
743 hotplug_handler_plug(dev
->parent_bus
->hotplug_handler
,
747 if (qdev_get_vmsd(dev
) && local_err
== NULL
) {
748 vmstate_register_with_alias_id(dev
, -1, qdev_get_vmsd(dev
), dev
,
749 dev
->instance_id_alias
,
750 dev
->alias_required_for_version
);
752 if (local_err
== NULL
) {
753 QLIST_FOREACH(bus
, &dev
->child_bus
, sibling
) {
754 object_property_set_bool(OBJECT(bus
), true, "realized",
756 if (local_err
!= NULL
) {
761 if (dev
->hotplugged
&& local_err
== NULL
) {
764 } else if (!value
&& dev
->realized
) {
765 QLIST_FOREACH(bus
, &dev
->child_bus
, sibling
) {
766 object_property_set_bool(OBJECT(bus
), false, "realized",
768 if (local_err
!= NULL
) {
772 if (qdev_get_vmsd(dev
) && local_err
== NULL
) {
773 vmstate_unregister(dev
, qdev_get_vmsd(dev
), dev
);
775 if (dc
->unrealize
&& local_err
== NULL
) {
776 dc
->unrealize(dev
, &local_err
);
780 if (local_err
!= NULL
) {
781 error_propagate(err
, local_err
);
785 dev
->realized
= value
;
788 static bool device_get_hotpluggable(Object
*obj
, Error
**err
)
790 DeviceClass
*dc
= DEVICE_GET_CLASS(obj
);
791 DeviceState
*dev
= DEVICE(obj
);
793 return dc
->hotpluggable
&& (dev
->parent_bus
== NULL
||
794 dev
->parent_bus
->allow_hotplug
);
797 static void device_initfn(Object
*obj
)
799 DeviceState
*dev
= DEVICE(obj
);
805 qdev_hot_added
= true;
808 dev
->instance_id_alias
= -1;
809 dev
->realized
= false;
811 object_property_add_bool(obj
, "realized",
812 device_get_realized
, device_set_realized
, NULL
);
813 object_property_add_bool(obj
, "hotpluggable",
814 device_get_hotpluggable
, NULL
, NULL
);
816 class = object_get_class(OBJECT(dev
));
818 for (prop
= DEVICE_CLASS(class)->props
; prop
&& prop
->name
; prop
++) {
819 qdev_property_add_legacy(dev
, prop
, &error_abort
);
820 qdev_property_add_static(dev
, prop
, &error_abort
);
822 class = object_class_get_parent(class);
823 } while (class != object_class_by_name(TYPE_DEVICE
));
825 object_property_add_link(OBJECT(dev
), "parent_bus", TYPE_BUS
,
826 (Object
**)&dev
->parent_bus
, 0,
830 static void device_post_init(Object
*obj
)
832 qdev_prop_set_globals(DEVICE(obj
), &error_abort
);
835 /* Unlink device from bus and free the structure. */
836 static void device_finalize(Object
*obj
)
838 DeviceState
*dev
= DEVICE(obj
);
840 qemu_opts_del(dev
->opts
);
844 static void device_class_base_init(ObjectClass
*class, void *data
)
846 DeviceClass
*klass
= DEVICE_CLASS(class);
848 /* We explicitly look up properties in the superclasses,
849 * so do not propagate them to the subclasses.
854 static void device_unparent(Object
*obj
)
856 DeviceState
*dev
= DEVICE(obj
);
859 bool have_realized
= dev
->realized
;
862 object_property_set_bool(obj
, false, "realized", NULL
);
864 while (dev
->num_child_bus
) {
865 bus
= QLIST_FIRST(&dev
->child_bus
);
866 object_unparent(OBJECT(bus
));
868 if (dev
->parent_bus
) {
869 bus_remove_child(dev
->parent_bus
, dev
);
870 object_unref(OBJECT(dev
->parent_bus
));
871 dev
->parent_bus
= NULL
;
874 /* Only send event if the device had been completely realized */
876 gchar
*path
= object_get_canonical_path(OBJECT(dev
));
879 event_data
= qobject_from_jsonf("{ 'device': %s, 'path': %s }",
882 event_data
= qobject_from_jsonf("{ 'path': %s }", path
);
884 monitor_protocol_event(QEVENT_DEVICE_DELETED
, event_data
);
885 qobject_decref(event_data
);
890 static void device_class_init(ObjectClass
*class, void *data
)
892 DeviceClass
*dc
= DEVICE_CLASS(class);
894 class->unparent
= device_unparent
;
895 dc
->realize
= device_realize
;
896 dc
->unrealize
= device_unrealize
;
898 /* by default all devices were considered as hotpluggable,
899 * so with intent to check it in generic qdev_unplug() /
900 * device_set_realized() functions make every device
901 * hotpluggable. Devices that shouldn't be hotpluggable,
902 * should override it in their class_init()
904 dc
->hotpluggable
= true;
907 void device_reset(DeviceState
*dev
)
909 DeviceClass
*klass
= DEVICE_GET_CLASS(dev
);
916 Object
*qdev_get_machine(void)
921 dev
= container_get(object_get_root(), "/machine");
927 static const TypeInfo device_type_info
= {
929 .parent
= TYPE_OBJECT
,
930 .instance_size
= sizeof(DeviceState
),
931 .instance_init
= device_initfn
,
932 .instance_post_init
= device_post_init
,
933 .instance_finalize
= device_finalize
,
934 .class_base_init
= device_class_base_init
,
935 .class_init
= device_class_init
,
937 .class_size
= sizeof(DeviceClass
),
940 static void qbus_initfn(Object
*obj
)
942 BusState
*bus
= BUS(obj
);
944 QTAILQ_INIT(&bus
->children
);
945 object_property_add_link(obj
, QDEV_HOTPLUG_HANDLER_PROPERTY
,
946 TYPE_HOTPLUG_HANDLER
,
947 (Object
**)&bus
->hotplug_handler
,
948 OBJ_PROP_LINK_UNREF_ON_RELEASE
,
950 object_property_add_bool(obj
, "realized",
951 bus_get_realized
, bus_set_realized
, NULL
);
954 static char *default_bus_get_fw_dev_path(DeviceState
*dev
)
956 return g_strdup(object_get_typename(OBJECT(dev
)));
959 static void bus_class_init(ObjectClass
*class, void *data
)
961 BusClass
*bc
= BUS_CLASS(class);
963 class->unparent
= bus_unparent
;
964 bc
->get_fw_dev_path
= default_bus_get_fw_dev_path
;
967 static void qbus_finalize(Object
*obj
)
969 BusState
*bus
= BUS(obj
);
971 g_free((char *)bus
->name
);
974 static const TypeInfo bus_info
= {
976 .parent
= TYPE_OBJECT
,
977 .instance_size
= sizeof(BusState
),
979 .class_size
= sizeof(BusClass
),
980 .instance_init
= qbus_initfn
,
981 .instance_finalize
= qbus_finalize
,
982 .class_init
= bus_class_init
,
985 static void qdev_register_types(void)
987 type_register_static(&bus_info
);
988 type_register_static(&device_type_info
);
991 type_init(qdev_register_types
)