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 "monitor/monitor.h"
36 #include "hw/hotplug.h"
37 #include "hw/boards.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
));
89 assert(bus
->allow_hotplug
);
92 kid
->index
= bus
->max_index
++;
94 object_ref(OBJECT(kid
->child
));
96 QTAILQ_INSERT_HEAD(&bus
->children
, kid
, sibling
);
98 /* This transfers ownership of kid->child to the property. */
99 snprintf(name
, sizeof(name
), "child[%d]", kid
->index
);
100 object_property_add_link(OBJECT(bus
), name
,
101 object_get_typename(OBJECT(child
)),
102 (Object
**)&kid
->child
,
103 NULL
, /* read-only property */
104 0, /* return ownership on prop deletion */
108 void qdev_set_parent_bus(DeviceState
*dev
, BusState
*bus
)
110 dev
->parent_bus
= bus
;
111 object_ref(OBJECT(bus
));
112 bus_add_child(bus
, dev
);
115 /* Create a new device. This only initializes the device state structure
116 and allows properties to be set. qdev_init should be called to
117 initialize the actual device emulation. */
118 DeviceState
*qdev_create(BusState
*bus
, const char *name
)
122 dev
= qdev_try_create(bus
, name
);
125 error_report("Unknown device '%s' for bus '%s'", name
,
126 object_get_typename(OBJECT(bus
)));
128 error_report("Unknown device '%s' for default sysbus", name
);
136 DeviceState
*qdev_try_create(BusState
*bus
, const char *type
)
140 if (object_class_by_name(type
) == NULL
) {
143 dev
= DEVICE(object_new(type
));
149 bus
= sysbus_get_default();
152 qdev_set_parent_bus(dev
, bus
);
153 object_unref(OBJECT(dev
));
157 /* Initialize a device. Device properties should be set before calling
158 this function. IRQs and MMIO regions should be connected/mapped after
159 calling this function.
160 On failure, destroy the device and return negative value.
161 Return 0 on success. */
162 int qdev_init(DeviceState
*dev
)
164 Error
*local_err
= NULL
;
166 assert(!dev
->realized
);
168 object_property_set_bool(OBJECT(dev
), true, "realized", &local_err
);
169 if (local_err
!= NULL
) {
170 qerror_report_err(local_err
);
171 error_free(local_err
);
172 object_unparent(OBJECT(dev
));
178 static void device_realize(DeviceState
*dev
, Error
**errp
)
180 DeviceClass
*dc
= DEVICE_GET_CLASS(dev
);
183 int rc
= dc
->init(dev
);
185 error_setg(errp
, "Device initialization failed.");
191 static void device_unrealize(DeviceState
*dev
, Error
**errp
)
193 DeviceClass
*dc
= DEVICE_GET_CLASS(dev
);
196 int rc
= dc
->exit(dev
);
198 error_setg(errp
, "Device exit failed.");
204 void qdev_set_legacy_instance_id(DeviceState
*dev
, int alias_id
,
205 int required_for_version
)
207 assert(!dev
->realized
);
208 dev
->instance_id_alias
= alias_id
;
209 dev
->alias_required_for_version
= required_for_version
;
212 void qdev_unplug(DeviceState
*dev
, Error
**errp
)
214 DeviceClass
*dc
= DEVICE_GET_CLASS(dev
);
216 if (dev
->parent_bus
&& !dev
->parent_bus
->allow_hotplug
) {
217 error_set(errp
, QERR_BUS_NO_HOTPLUG
, dev
->parent_bus
->name
);
221 if (!dc
->hotpluggable
) {
222 error_set(errp
, QERR_DEVICE_NO_HOTPLUG
,
223 object_get_typename(OBJECT(dev
)));
227 qdev_hot_removed
= true;
229 if (dev
->parent_bus
&& dev
->parent_bus
->hotplug_handler
) {
230 hotplug_handler_unplug(dev
->parent_bus
->hotplug_handler
, dev
, errp
);
232 assert(dc
->unplug
!= NULL
);
233 if (dc
->unplug(dev
) < 0) { /* legacy handler */
234 error_set(errp
, QERR_UNDEFINED_ERROR
);
239 static int qdev_reset_one(DeviceState
*dev
, void *opaque
)
246 static int qbus_reset_one(BusState
*bus
, void *opaque
)
248 BusClass
*bc
= BUS_GET_CLASS(bus
);
255 void qdev_reset_all(DeviceState
*dev
)
257 qdev_walk_children(dev
, NULL
, NULL
, qdev_reset_one
, qbus_reset_one
, NULL
);
260 void qbus_reset_all(BusState
*bus
)
262 qbus_walk_children(bus
, NULL
, NULL
, qdev_reset_one
, qbus_reset_one
, NULL
);
265 void qbus_reset_all_fn(void *opaque
)
267 BusState
*bus
= opaque
;
271 /* can be used as ->unplug() callback for the simple cases */
272 int qdev_simple_unplug_cb(DeviceState
*dev
)
275 object_unparent(OBJECT(dev
));
280 /* Like qdev_init(), but terminate program via error_report() instead of
281 returning an error value. This is okay during machine creation.
282 Don't use for hotplug, because there callers need to recover from
283 failure. Exception: if you know the device's init() callback can't
284 fail, then qdev_init_nofail() can't fail either, and is therefore
285 usable even then. But relying on the device implementation that
286 way is somewhat unclean, and best avoided. */
287 void qdev_init_nofail(DeviceState
*dev
)
289 const char *typename
= object_get_typename(OBJECT(dev
));
291 if (qdev_init(dev
) < 0) {
292 error_report("Initialization of device %s failed", typename
);
297 void qdev_machine_creation_done(void)
300 * ok, initial machine setup is done, starting from now we can
301 * only create hotpluggable devices
306 bool qdev_machine_modified(void)
308 return qdev_hot_added
|| qdev_hot_removed
;
311 BusState
*qdev_get_parent_bus(DeviceState
*dev
)
313 return dev
->parent_bus
;
316 static NamedGPIOList
*qdev_get_named_gpio_list(DeviceState
*dev
,
321 QLIST_FOREACH(ngl
, &dev
->gpios
, node
) {
322 /* NULL is a valid and matchable name, otherwise do a normal
325 if ((!ngl
->name
&& !name
) ||
326 (name
&& ngl
->name
&& strcmp(name
, ngl
->name
) == 0)) {
331 ngl
= g_malloc0(sizeof(*ngl
));
332 ngl
->name
= g_strdup(name
);
333 QLIST_INSERT_HEAD(&dev
->gpios
, ngl
, node
);
337 void qdev_init_gpio_in_named(DeviceState
*dev
, qemu_irq_handler handler
,
338 const char *name
, int n
)
340 NamedGPIOList
*gpio_list
= qdev_get_named_gpio_list(dev
, name
);
342 gpio_list
->in
= qemu_extend_irqs(gpio_list
->in
, gpio_list
->num_in
, handler
,
344 gpio_list
->num_in
+= n
;
347 void qdev_init_gpio_in(DeviceState
*dev
, qemu_irq_handler handler
, int n
)
349 qdev_init_gpio_in_named(dev
, handler
, NULL
, n
);
352 void qdev_init_gpio_out_named(DeviceState
*dev
, qemu_irq
*pins
,
353 const char *name
, int n
)
355 NamedGPIOList
*gpio_list
= qdev_get_named_gpio_list(dev
, name
);
357 assert(gpio_list
->num_out
== 0);
358 gpio_list
->num_out
= n
;
359 gpio_list
->out
= pins
;
362 void qdev_init_gpio_out(DeviceState
*dev
, qemu_irq
*pins
, int n
)
364 qdev_init_gpio_out_named(dev
, pins
, NULL
, n
);
367 qemu_irq
qdev_get_gpio_in_named(DeviceState
*dev
, const char *name
, int n
)
369 NamedGPIOList
*gpio_list
= qdev_get_named_gpio_list(dev
, name
);
371 assert(n
>= 0 && n
< gpio_list
->num_in
);
372 return gpio_list
->in
[n
];
375 qemu_irq
qdev_get_gpio_in(DeviceState
*dev
, int n
)
377 return qdev_get_gpio_in_named(dev
, NULL
, n
);
380 void qdev_connect_gpio_out_named(DeviceState
*dev
, const char *name
, int n
,
383 NamedGPIOList
*gpio_list
= qdev_get_named_gpio_list(dev
, name
);
385 assert(n
>= 0 && n
< gpio_list
->num_out
);
386 gpio_list
->out
[n
] = pin
;
389 void qdev_connect_gpio_out(DeviceState
* dev
, int n
, qemu_irq pin
)
391 qdev_connect_gpio_out_named(dev
, NULL
, n
, pin
);
394 BusState
*qdev_get_child_bus(DeviceState
*dev
, const char *name
)
398 QLIST_FOREACH(bus
, &dev
->child_bus
, sibling
) {
399 if (strcmp(name
, bus
->name
) == 0) {
406 int qbus_walk_children(BusState
*bus
,
407 qdev_walkerfn
*pre_devfn
, qbus_walkerfn
*pre_busfn
,
408 qdev_walkerfn
*post_devfn
, qbus_walkerfn
*post_busfn
,
415 err
= pre_busfn(bus
, opaque
);
421 QTAILQ_FOREACH(kid
, &bus
->children
, sibling
) {
422 err
= qdev_walk_children(kid
->child
,
423 pre_devfn
, pre_busfn
,
424 post_devfn
, post_busfn
, opaque
);
431 err
= post_busfn(bus
, opaque
);
440 int qdev_walk_children(DeviceState
*dev
,
441 qdev_walkerfn
*pre_devfn
, qbus_walkerfn
*pre_busfn
,
442 qdev_walkerfn
*post_devfn
, qbus_walkerfn
*post_busfn
,
449 err
= pre_devfn(dev
, opaque
);
455 QLIST_FOREACH(bus
, &dev
->child_bus
, sibling
) {
456 err
= qbus_walk_children(bus
, pre_devfn
, pre_busfn
,
457 post_devfn
, post_busfn
, opaque
);
464 err
= post_devfn(dev
, opaque
);
473 DeviceState
*qdev_find_recursive(BusState
*bus
, const char *id
)
479 QTAILQ_FOREACH(kid
, &bus
->children
, sibling
) {
480 DeviceState
*dev
= kid
->child
;
482 if (dev
->id
&& strcmp(dev
->id
, id
) == 0) {
486 QLIST_FOREACH(child
, &dev
->child_bus
, sibling
) {
487 ret
= qdev_find_recursive(child
, id
);
496 static void qbus_realize(BusState
*bus
, DeviceState
*parent
, const char *name
)
498 const char *typename
= object_get_typename(OBJECT(bus
));
503 bus
->parent
= parent
;
506 bus
->name
= g_strdup(name
);
507 } else if (bus
->parent
&& bus
->parent
->id
) {
508 /* parent device has id -> use it plus parent-bus-id for bus name */
509 bus_id
= bus
->parent
->num_child_bus
;
511 len
= strlen(bus
->parent
->id
) + 16;
513 snprintf(buf
, len
, "%s.%d", bus
->parent
->id
, bus_id
);
516 /* no id -> use lowercase bus type plus global bus-id for bus name */
517 bc
= BUS_GET_CLASS(bus
);
518 bus_id
= bc
->automatic_ids
++;
520 len
= strlen(typename
) + 16;
522 len
= snprintf(buf
, len
, "%s.%d", typename
, bus_id
);
523 for (i
= 0; i
< len
; i
++) {
524 buf
[i
] = qemu_tolower(buf
[i
]);
530 QLIST_INSERT_HEAD(&bus
->parent
->child_bus
, bus
, sibling
);
531 bus
->parent
->num_child_bus
++;
532 object_property_add_child(OBJECT(bus
->parent
), bus
->name
, OBJECT(bus
), NULL
);
533 object_unref(OBJECT(bus
));
534 } else if (bus
!= sysbus_get_default()) {
535 /* TODO: once all bus devices are qdevified,
536 only reset handler for main_system_bus should be registered here. */
537 qemu_register_reset(qbus_reset_all_fn
, bus
);
541 static void bus_unparent(Object
*obj
)
543 BusState
*bus
= BUS(obj
);
546 while ((kid
= QTAILQ_FIRST(&bus
->children
)) != NULL
) {
547 DeviceState
*dev
= kid
->child
;
548 object_unparent(OBJECT(dev
));
551 QLIST_REMOVE(bus
, sibling
);
552 bus
->parent
->num_child_bus
--;
555 assert(bus
!= sysbus_get_default()); /* main_system_bus is never freed */
556 qemu_unregister_reset(qbus_reset_all_fn
, bus
);
560 static bool bus_get_realized(Object
*obj
, Error
**errp
)
562 BusState
*bus
= BUS(obj
);
564 return bus
->realized
;
567 static void bus_set_realized(Object
*obj
, bool value
, Error
**errp
)
569 BusState
*bus
= BUS(obj
);
570 BusClass
*bc
= BUS_GET_CLASS(bus
);
571 Error
*local_err
= NULL
;
573 if (value
&& !bus
->realized
) {
575 bc
->realize(bus
, &local_err
);
577 if (local_err
!= NULL
) {
582 } else if (!value
&& bus
->realized
) {
584 bc
->unrealize(bus
, &local_err
);
586 if (local_err
!= NULL
) {
592 bus
->realized
= value
;
596 error_propagate(errp
, local_err
);
599 void qbus_create_inplace(void *bus
, size_t size
, const char *typename
,
600 DeviceState
*parent
, const char *name
)
602 object_initialize(bus
, size
, typename
);
603 qbus_realize(bus
, parent
, name
);
606 BusState
*qbus_create(const char *typename
, DeviceState
*parent
, const char *name
)
610 bus
= BUS(object_new(typename
));
611 qbus_realize(bus
, parent
, name
);
616 static char *bus_get_fw_dev_path(BusState
*bus
, DeviceState
*dev
)
618 BusClass
*bc
= BUS_GET_CLASS(bus
);
620 if (bc
->get_fw_dev_path
) {
621 return bc
->get_fw_dev_path(dev
);
627 static char *qdev_get_fw_dev_path_from_handler(BusState
*bus
, DeviceState
*dev
)
629 Object
*obj
= OBJECT(dev
);
632 while (!d
&& obj
->parent
) {
634 d
= fw_path_provider_try_get_dev_path(obj
, bus
, dev
);
639 static int qdev_get_fw_dev_path_helper(DeviceState
*dev
, char *p
, int size
)
643 if (dev
&& dev
->parent_bus
) {
645 l
= qdev_get_fw_dev_path_helper(dev
->parent_bus
->parent
, p
, size
);
646 d
= qdev_get_fw_dev_path_from_handler(dev
->parent_bus
, dev
);
648 d
= bus_get_fw_dev_path(dev
->parent_bus
, dev
);
651 l
+= snprintf(p
+ l
, size
- l
, "%s", d
);
657 l
+= snprintf(p
+ l
, size
- l
, "/");
662 char* qdev_get_fw_dev_path(DeviceState
*dev
)
667 l
= qdev_get_fw_dev_path_helper(dev
, path
, 128);
671 return g_strdup(path
);
674 char *qdev_get_dev_path(DeviceState
*dev
)
678 if (!dev
|| !dev
->parent_bus
) {
682 bc
= BUS_GET_CLASS(dev
->parent_bus
);
683 if (bc
->get_dev_path
) {
684 return bc
->get_dev_path(dev
);
691 * Legacy property handling
694 static void qdev_get_legacy_property(Object
*obj
, Visitor
*v
, void *opaque
,
695 const char *name
, Error
**errp
)
697 DeviceState
*dev
= DEVICE(obj
);
698 Property
*prop
= opaque
;
703 prop
->info
->print(dev
, prop
, buffer
, sizeof(buffer
));
704 visit_type_str(v
, &ptr
, name
, errp
);
708 * @qdev_add_legacy_property - adds a legacy property
710 * Do not use this is new code! Properties added through this interface will
711 * be given names and types in the "legacy" namespace.
713 * Legacy properties are string versions of other OOM properties. The format
714 * of the string depends on the property type.
716 static void qdev_property_add_legacy(DeviceState
*dev
, Property
*prop
,
721 /* Register pointer properties as legacy properties */
722 if (!prop
->info
->print
&& prop
->info
->get
) {
726 name
= g_strdup_printf("legacy-%s", prop
->name
);
727 object_property_add(OBJECT(dev
), name
, "str",
728 prop
->info
->print
? qdev_get_legacy_property
: prop
->info
->get
,
737 * @qdev_property_add_static - add a @Property to a device.
739 * Static properties access data in a struct. The actual type of the
740 * property and the field depends on the property type.
742 void qdev_property_add_static(DeviceState
*dev
, Property
*prop
,
745 Error
*local_err
= NULL
;
746 Object
*obj
= OBJECT(dev
);
749 * TODO qdev_prop_ptr does not have getters or setters. It must
750 * go now that it can be replaced with links. The test should be
751 * removed along with it: all static properties are read/write.
753 if (!prop
->info
->get
&& !prop
->info
->set
) {
757 object_property_add(obj
, prop
->name
, prop
->info
->name
,
758 prop
->info
->get
, prop
->info
->set
,
763 error_propagate(errp
, local_err
);
766 if (prop
->qtype
== QTYPE_NONE
) {
770 if (prop
->qtype
== QTYPE_QBOOL
) {
771 object_property_set_bool(obj
, prop
->defval
, prop
->name
, &error_abort
);
772 } else if (prop
->info
->enum_table
) {
773 object_property_set_str(obj
, prop
->info
->enum_table
[prop
->defval
],
774 prop
->name
, &error_abort
);
775 } else if (prop
->qtype
== QTYPE_QINT
) {
776 object_property_set_int(obj
, prop
->defval
, prop
->name
, &error_abort
);
780 static bool device_get_realized(Object
*obj
, Error
**errp
)
782 DeviceState
*dev
= DEVICE(obj
);
783 return dev
->realized
;
786 static void device_set_realized(Object
*obj
, bool value
, Error
**errp
)
788 DeviceState
*dev
= DEVICE(obj
);
789 DeviceClass
*dc
= DEVICE_GET_CLASS(dev
);
791 Error
*local_err
= NULL
;
793 if (dev
->hotplugged
&& !dc
->hotpluggable
) {
794 error_set(errp
, QERR_DEVICE_NO_HOTPLUG
, object_get_typename(obj
));
798 if (value
&& !dev
->realized
) {
799 if (!obj
->parent
&& local_err
== NULL
) {
800 static int unattached_count
;
801 gchar
*name
= g_strdup_printf("device[%d]", unattached_count
++);
803 object_property_add_child(container_get(qdev_get_machine(),
805 name
, obj
, &local_err
);
810 dc
->realize(dev
, &local_err
);
813 if (dev
->parent_bus
&& dev
->parent_bus
->hotplug_handler
&&
815 hotplug_handler_plug(dev
->parent_bus
->hotplug_handler
,
817 } else if (local_err
== NULL
&&
818 object_dynamic_cast(qdev_get_machine(), TYPE_MACHINE
)) {
819 HotplugHandler
*hotplug_ctrl
;
820 MachineState
*machine
= MACHINE(qdev_get_machine());
821 MachineClass
*mc
= MACHINE_GET_CLASS(machine
);
823 if (mc
->get_hotplug_handler
) {
824 hotplug_ctrl
= mc
->get_hotplug_handler(machine
, dev
);
826 hotplug_handler_plug(hotplug_ctrl
, dev
, &local_err
);
831 if (qdev_get_vmsd(dev
) && local_err
== NULL
) {
832 vmstate_register_with_alias_id(dev
, -1, qdev_get_vmsd(dev
), dev
,
833 dev
->instance_id_alias
,
834 dev
->alias_required_for_version
);
836 if (local_err
== NULL
) {
837 QLIST_FOREACH(bus
, &dev
->child_bus
, sibling
) {
838 object_property_set_bool(OBJECT(bus
), true, "realized",
840 if (local_err
!= NULL
) {
845 if (dev
->hotplugged
&& local_err
== NULL
) {
848 } else if (!value
&& dev
->realized
) {
849 QLIST_FOREACH(bus
, &dev
->child_bus
, sibling
) {
850 object_property_set_bool(OBJECT(bus
), false, "realized",
852 if (local_err
!= NULL
) {
856 if (qdev_get_vmsd(dev
) && local_err
== NULL
) {
857 vmstate_unregister(dev
, qdev_get_vmsd(dev
), dev
);
859 if (dc
->unrealize
&& local_err
== NULL
) {
860 dc
->unrealize(dev
, &local_err
);
864 if (local_err
!= NULL
) {
865 error_propagate(errp
, local_err
);
869 dev
->realized
= value
;
872 static bool device_get_hotpluggable(Object
*obj
, Error
**errp
)
874 DeviceClass
*dc
= DEVICE_GET_CLASS(obj
);
875 DeviceState
*dev
= DEVICE(obj
);
877 return dc
->hotpluggable
&& (dev
->parent_bus
== NULL
||
878 dev
->parent_bus
->allow_hotplug
);
881 static bool device_get_hotplugged(Object
*obj
, Error
**err
)
883 DeviceState
*dev
= DEVICE(obj
);
885 return dev
->hotplugged
;
888 static void device_set_hotplugged(Object
*obj
, bool value
, Error
**err
)
890 DeviceState
*dev
= DEVICE(obj
);
892 dev
->hotplugged
= value
;
895 static void device_initfn(Object
*obj
)
897 DeviceState
*dev
= DEVICE(obj
);
903 qdev_hot_added
= true;
906 dev
->instance_id_alias
= -1;
907 dev
->realized
= false;
909 object_property_add_bool(obj
, "realized",
910 device_get_realized
, device_set_realized
, NULL
);
911 object_property_add_bool(obj
, "hotpluggable",
912 device_get_hotpluggable
, NULL
, NULL
);
913 object_property_add_bool(obj
, "hotplugged",
914 device_get_hotplugged
, device_set_hotplugged
,
917 class = object_get_class(OBJECT(dev
));
919 for (prop
= DEVICE_CLASS(class)->props
; prop
&& prop
->name
; prop
++) {
920 qdev_property_add_legacy(dev
, prop
, &error_abort
);
921 qdev_property_add_static(dev
, prop
, &error_abort
);
923 class = object_class_get_parent(class);
924 } while (class != object_class_by_name(TYPE_DEVICE
));
926 object_property_add_link(OBJECT(dev
), "parent_bus", TYPE_BUS
,
927 (Object
**)&dev
->parent_bus
, NULL
, 0,
929 QLIST_INIT(&dev
->gpios
);
932 static void device_post_init(Object
*obj
)
934 qdev_prop_set_globals(DEVICE(obj
), &error_abort
);
937 /* Unlink device from bus and free the structure. */
938 static void device_finalize(Object
*obj
)
940 NamedGPIOList
*ngl
, *next
;
942 DeviceState
*dev
= DEVICE(obj
);
944 qemu_opts_del(dev
->opts
);
947 QLIST_FOREACH_SAFE(ngl
, &dev
->gpios
, node
, next
) {
948 QLIST_REMOVE(ngl
, node
);
949 qemu_free_irqs(ngl
->in
);
952 /* ngl->out irqs are owned by the other end and should not be freed
958 static void device_class_base_init(ObjectClass
*class, void *data
)
960 DeviceClass
*klass
= DEVICE_CLASS(class);
962 /* We explicitly look up properties in the superclasses,
963 * so do not propagate them to the subclasses.
968 static void device_unparent(Object
*obj
)
970 DeviceState
*dev
= DEVICE(obj
);
973 bool have_realized
= dev
->realized
;
976 object_property_set_bool(obj
, false, "realized", NULL
);
978 while (dev
->num_child_bus
) {
979 bus
= QLIST_FIRST(&dev
->child_bus
);
980 object_unparent(OBJECT(bus
));
982 if (dev
->parent_bus
) {
983 bus_remove_child(dev
->parent_bus
, dev
);
984 object_unref(OBJECT(dev
->parent_bus
));
985 dev
->parent_bus
= NULL
;
988 /* Only send event if the device had been completely realized */
990 gchar
*path
= object_get_canonical_path(OBJECT(dev
));
993 event_data
= qobject_from_jsonf("{ 'device': %s, 'path': %s }",
996 event_data
= qobject_from_jsonf("{ 'path': %s }", path
);
998 monitor_protocol_event(QEVENT_DEVICE_DELETED
, event_data
);
999 qobject_decref(event_data
);
1004 static void device_class_init(ObjectClass
*class, void *data
)
1006 DeviceClass
*dc
= DEVICE_CLASS(class);
1008 class->unparent
= device_unparent
;
1009 dc
->realize
= device_realize
;
1010 dc
->unrealize
= device_unrealize
;
1012 /* by default all devices were considered as hotpluggable,
1013 * so with intent to check it in generic qdev_unplug() /
1014 * device_set_realized() functions make every device
1015 * hotpluggable. Devices that shouldn't be hotpluggable,
1016 * should override it in their class_init()
1018 dc
->hotpluggable
= true;
1021 void device_reset(DeviceState
*dev
)
1023 DeviceClass
*klass
= DEVICE_GET_CLASS(dev
);
1030 Object
*qdev_get_machine(void)
1035 dev
= container_get(object_get_root(), "/machine");
1041 static const TypeInfo device_type_info
= {
1042 .name
= TYPE_DEVICE
,
1043 .parent
= TYPE_OBJECT
,
1044 .instance_size
= sizeof(DeviceState
),
1045 .instance_init
= device_initfn
,
1046 .instance_post_init
= device_post_init
,
1047 .instance_finalize
= device_finalize
,
1048 .class_base_init
= device_class_base_init
,
1049 .class_init
= device_class_init
,
1051 .class_size
= sizeof(DeviceClass
),
1054 static void qbus_initfn(Object
*obj
)
1056 BusState
*bus
= BUS(obj
);
1058 QTAILQ_INIT(&bus
->children
);
1059 object_property_add_link(obj
, QDEV_HOTPLUG_HANDLER_PROPERTY
,
1060 TYPE_HOTPLUG_HANDLER
,
1061 (Object
**)&bus
->hotplug_handler
,
1062 object_property_allow_set_link
,
1063 OBJ_PROP_LINK_UNREF_ON_RELEASE
,
1065 object_property_add_bool(obj
, "realized",
1066 bus_get_realized
, bus_set_realized
, NULL
);
1069 static char *default_bus_get_fw_dev_path(DeviceState
*dev
)
1071 return g_strdup(object_get_typename(OBJECT(dev
)));
1074 static void bus_class_init(ObjectClass
*class, void *data
)
1076 BusClass
*bc
= BUS_CLASS(class);
1078 class->unparent
= bus_unparent
;
1079 bc
->get_fw_dev_path
= default_bus_get_fw_dev_path
;
1082 static void qbus_finalize(Object
*obj
)
1084 BusState
*bus
= BUS(obj
);
1086 g_free((char *)bus
->name
);
1089 static const TypeInfo bus_info
= {
1091 .parent
= TYPE_OBJECT
,
1092 .instance_size
= sizeof(BusState
),
1094 .class_size
= sizeof(BusClass
),
1095 .instance_init
= qbus_initfn
,
1096 .instance_finalize
= qbus_finalize
,
1097 .class_init
= bus_class_init
,
1100 static void qdev_register_types(void)
1102 type_register_static(&bus_info
);
1103 type_register_static(&device_type_info
);
1106 type_init(qdev_register_types
)