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
34 static int qdev_hotplug
= 0;
36 /* This is a nasty hack to allow passing a NULL bus to qdev_create. */
37 static BusState
*main_system_bus
;
39 DeviceInfo
*device_info_list
;
41 static BusState
*qbus_find_recursive(BusState
*bus
, const char *name
,
43 static BusState
*qbus_find(const char *path
);
45 /* Register a new device type. */
46 void qdev_register(DeviceInfo
*info
)
48 assert(info
->size
>= sizeof(DeviceState
));
51 info
->next
= device_info_list
;
52 device_info_list
= info
;
55 static DeviceInfo
*qdev_find_info(BusInfo
*bus_info
, const char *name
)
59 /* first check device names */
60 for (info
= device_info_list
; info
!= NULL
; info
= info
->next
) {
61 if (bus_info
&& info
->bus_info
!= bus_info
)
63 if (strcmp(info
->name
, name
) != 0)
68 /* failing that check the aliases */
69 for (info
= device_info_list
; info
!= NULL
; info
= info
->next
) {
70 if (bus_info
&& info
->bus_info
!= bus_info
)
74 if (strcmp(info
->alias
, name
) != 0)
81 static DeviceState
*qdev_create_from_info(BusState
*bus
, DeviceInfo
*info
)
85 assert(bus
->info
== info
->bus_info
);
86 dev
= qemu_mallocz(info
->size
);
88 dev
->parent_bus
= bus
;
89 qdev_prop_set_defaults(dev
, dev
->info
->props
);
90 qdev_prop_set_defaults(dev
, dev
->parent_bus
->info
->props
);
91 qdev_prop_set_globals(dev
);
92 QLIST_INSERT_HEAD(&bus
->children
, dev
, sibling
);
94 assert(bus
->allow_hotplug
);
97 dev
->instance_id_alias
= -1;
98 dev
->state
= DEV_STATE_CREATED
;
102 /* Create a new device. This only initializes the device state structure
103 and allows properties to be set. qdev_init should be called to
104 initialize the actual device emulation. */
105 DeviceState
*qdev_create(BusState
*bus
, const char *name
)
110 if (!main_system_bus
) {
111 main_system_bus
= qbus_create(&system_bus_info
, NULL
, "main-system-bus");
113 bus
= main_system_bus
;
116 info
= qdev_find_info(bus
->info
, name
);
118 hw_error("Unknown device '%s' for bus '%s'\n", name
, bus
->info
->name
);
121 return qdev_create_from_info(bus
, info
);
124 static void qdev_print_devinfo(DeviceInfo
*info
)
126 error_printf("name \"%s\", bus %s",
127 info
->name
, info
->bus_info
->name
);
129 error_printf(", alias \"%s\"", info
->alias
);
132 error_printf(", desc \"%s\"", info
->desc
);
135 error_printf(", no-user");
140 static int set_property(const char *name
, const char *value
, void *opaque
)
142 DeviceState
*dev
= opaque
;
144 if (strcmp(name
, "driver") == 0)
146 if (strcmp(name
, "bus") == 0)
149 if (qdev_prop_parse(dev
, name
, value
) == -1) {
155 int qdev_device_help(QemuOpts
*opts
)
161 driver
= qemu_opt_get(opts
, "driver");
162 if (driver
&& !strcmp(driver
, "?")) {
163 for (info
= device_info_list
; info
!= NULL
; info
= info
->next
) {
165 continue; /* not available, don't show */
167 qdev_print_devinfo(info
);
172 if (!qemu_opt_get(opts
, "?")) {
176 info
= qdev_find_info(NULL
, driver
);
181 for (prop
= info
->props
; prop
&& prop
->name
; prop
++) {
183 * TODO Properties without a parser are just for dirty hacks.
184 * qdev_prop_ptr is the only such PropertyInfo. It's marked
185 * for removal. This conditional should be removed along with
188 if (!prop
->info
->parse
) {
189 continue; /* no way to set it, don't show */
191 error_printf("%s.%s=%s\n", info
->name
, prop
->name
, prop
->info
->name
);
196 DeviceState
*qdev_device_add(QemuOpts
*opts
)
198 const char *driver
, *path
, *id
;
203 driver
= qemu_opt_get(opts
, "driver");
205 qerror_report(QERR_MISSING_PARAMETER
, "driver");
210 info
= qdev_find_info(NULL
, driver
);
211 if (!info
|| info
->no_user
) {
212 qerror_report(QERR_INVALID_PARAMETER_VALUE
, "driver", "a driver name");
213 error_printf_unless_qmp("Try with argument '?' for a list.\n");
218 path
= qemu_opt_get(opts
, "bus");
220 bus
= qbus_find(path
);
224 if (bus
->info
!= info
->bus_info
) {
225 qerror_report(QERR_BAD_BUS_FOR_DEVICE
,
226 driver
, bus
->info
->name
);
230 bus
= qbus_find_recursive(main_system_bus
, NULL
, info
->bus_info
);
232 qerror_report(QERR_NO_BUS_FOR_DEVICE
,
233 info
->name
, info
->bus_info
->name
);
237 if (qdev_hotplug
&& !bus
->allow_hotplug
) {
238 qerror_report(QERR_BUS_NO_HOTPLUG
, bus
->name
);
242 /* create device, set properties */
243 qdev
= qdev_create_from_info(bus
, info
);
244 id
= qemu_opts_id(opts
);
248 if (qemu_opt_foreach(opts
, set_property
, qdev
, 1) != 0) {
252 if (qdev_init(qdev
) < 0) {
253 qerror_report(QERR_DEVICE_INIT_FAILED
, driver
);
260 static void qdev_reset(void *opaque
)
262 DeviceState
*dev
= opaque
;
263 if (dev
->info
->reset
)
264 dev
->info
->reset(dev
);
267 /* Initialize a device. Device properties should be set before calling
268 this function. IRQs and MMIO regions should be connected/mapped after
269 calling this function.
270 On failure, destroy the device and return negative value.
271 Return 0 on success. */
272 int qdev_init(DeviceState
*dev
)
276 assert(dev
->state
== DEV_STATE_CREATED
);
277 rc
= dev
->info
->init(dev
, dev
->info
);
282 qemu_register_reset(qdev_reset
, dev
);
283 if (dev
->info
->vmsd
) {
284 vmstate_register_with_alias_id(dev
, -1, dev
->info
->vmsd
, dev
,
285 dev
->instance_id_alias
,
286 dev
->alias_required_for_version
);
288 dev
->state
= DEV_STATE_INITIALIZED
;
292 void qdev_set_legacy_instance_id(DeviceState
*dev
, int alias_id
,
293 int required_for_version
)
295 assert(dev
->state
== DEV_STATE_CREATED
);
296 dev
->instance_id_alias
= alias_id
;
297 dev
->alias_required_for_version
= required_for_version
;
300 int qdev_unplug(DeviceState
*dev
)
302 if (!dev
->parent_bus
->allow_hotplug
) {
303 qerror_report(QERR_BUS_NO_HOTPLUG
, dev
->parent_bus
->name
);
306 assert(dev
->info
->unplug
!= NULL
);
308 return dev
->info
->unplug(dev
);
311 /* can be used as ->unplug() callback for the simple cases */
312 int qdev_simple_unplug_cb(DeviceState
*dev
)
319 /* Like qdev_init(), but terminate program via hw_error() instead of
320 returning an error value. This is okay during machine creation.
321 Don't use for hotplug, because there callers need to recover from
322 failure. Exception: if you know the device's init() callback can't
323 fail, then qdev_init_nofail() can't fail either, and is therefore
324 usable even then. But relying on the device implementation that
325 way is somewhat unclean, and best avoided. */
326 void qdev_init_nofail(DeviceState
*dev
)
328 DeviceInfo
*info
= dev
->info
;
330 if (qdev_init(dev
) < 0) {
331 error_report("Initialization of device %s failed\n", info
->name
);
336 /* Unlink device from bus and free the structure. */
337 void qdev_free(DeviceState
*dev
)
342 if (dev
->state
== DEV_STATE_INITIALIZED
) {
343 while (dev
->num_child_bus
) {
344 bus
= QLIST_FIRST(&dev
->child_bus
);
348 vmstate_unregister(dev
, dev
->info
->vmsd
, dev
);
350 dev
->info
->exit(dev
);
352 qemu_opts_del(dev
->opts
);
354 qemu_unregister_reset(qdev_reset
, dev
);
355 QLIST_REMOVE(dev
, sibling
);
356 for (prop
= dev
->info
->props
; prop
&& prop
->name
; prop
++) {
357 if (prop
->info
->free
) {
358 prop
->info
->free(dev
, prop
);
364 void qdev_machine_creation_done(void)
367 * ok, initial machine setup is done, starting from now we can
368 * only create hotpluggable devices
373 /* Get a character (serial) device interface. */
374 CharDriverState
*qdev_init_chardev(DeviceState
*dev
)
376 static int next_serial
;
378 /* FIXME: This function needs to go away: use chardev properties! */
379 return serial_hds
[next_serial
++];
382 BusState
*qdev_get_parent_bus(DeviceState
*dev
)
384 return dev
->parent_bus
;
387 void qdev_init_gpio_in(DeviceState
*dev
, qemu_irq_handler handler
, int n
)
389 assert(dev
->num_gpio_in
== 0);
390 dev
->num_gpio_in
= n
;
391 dev
->gpio_in
= qemu_allocate_irqs(handler
, dev
, n
);
394 void qdev_init_gpio_out(DeviceState
*dev
, qemu_irq
*pins
, int n
)
396 assert(dev
->num_gpio_out
== 0);
397 dev
->num_gpio_out
= n
;
398 dev
->gpio_out
= pins
;
401 qemu_irq
qdev_get_gpio_in(DeviceState
*dev
, int n
)
403 assert(n
>= 0 && n
< dev
->num_gpio_in
);
404 return dev
->gpio_in
[n
];
407 void qdev_connect_gpio_out(DeviceState
* dev
, int n
, qemu_irq pin
)
409 assert(n
>= 0 && n
< dev
->num_gpio_out
);
410 dev
->gpio_out
[n
] = pin
;
413 void qdev_set_nic_properties(DeviceState
*dev
, NICInfo
*nd
)
415 qdev_prop_set_macaddr(dev
, "mac", nd
->macaddr
);
417 qdev_prop_set_vlan(dev
, "vlan", nd
->vlan
);
419 qdev_prop_set_netdev(dev
, "netdev", nd
->netdev
);
420 if (nd
->nvectors
!= DEV_NVECTORS_UNSPECIFIED
&&
421 qdev_prop_exists(dev
, "vectors")) {
422 qdev_prop_set_uint32(dev
, "vectors", nd
->nvectors
);
426 static int next_block_unit
[IF_COUNT
];
428 /* Get a block device. This should only be used for single-drive devices
429 (e.g. SD/Floppy/MTD). Multi-disk devices (scsi/ide) should use the
431 BlockDriverState
*qdev_init_bdrv(DeviceState
*dev
, BlockInterfaceType type
)
433 int unit
= next_block_unit
[type
]++;
436 dinfo
= drive_get(type
, 0, unit
);
437 return dinfo
? dinfo
->bdrv
: NULL
;
440 BusState
*qdev_get_child_bus(DeviceState
*dev
, const char *name
)
444 QLIST_FOREACH(bus
, &dev
->child_bus
, sibling
) {
445 if (strcmp(name
, bus
->name
) == 0) {
452 int qbus_walk_children(BusState
*bus
, qdev_walkerfn
*devfn
,
453 qbus_walkerfn
*busfn
, void *opaque
)
459 err
= busfn(bus
, opaque
);
465 QLIST_FOREACH(dev
, &bus
->children
, sibling
) {
466 err
= qdev_walk_children(dev
, devfn
, busfn
, opaque
);
475 int qdev_walk_children(DeviceState
*dev
, qdev_walkerfn
*devfn
,
476 qbus_walkerfn
*busfn
, void *opaque
)
482 err
= devfn(dev
, opaque
);
488 QLIST_FOREACH(bus
, &dev
->child_bus
, sibling
) {
489 err
= qbus_walk_children(bus
, devfn
, busfn
, opaque
);
498 static BusState
*qbus_find_recursive(BusState
*bus
, const char *name
,
502 BusState
*child
, *ret
;
505 if (name
&& (strcmp(bus
->name
, name
) != 0)) {
508 if (info
&& (bus
->info
!= info
)) {
515 QLIST_FOREACH(dev
, &bus
->children
, sibling
) {
516 QLIST_FOREACH(child
, &dev
->child_bus
, sibling
) {
517 ret
= qbus_find_recursive(child
, name
, info
);
526 static DeviceState
*qdev_find_recursive(BusState
*bus
, const char *id
)
528 DeviceState
*dev
, *ret
;
531 QLIST_FOREACH(dev
, &bus
->children
, sibling
) {
532 if (dev
->id
&& strcmp(dev
->id
, id
) == 0)
534 QLIST_FOREACH(child
, &dev
->child_bus
, sibling
) {
535 ret
= qdev_find_recursive(child
, id
);
544 static void qbus_list_bus(DeviceState
*dev
)
547 const char *sep
= " ";
549 error_printf("child busses at \"%s\":",
550 dev
->id
? dev
->id
: dev
->info
->name
);
551 QLIST_FOREACH(child
, &dev
->child_bus
, sibling
) {
552 error_printf("%s\"%s\"", sep
, child
->name
);
558 static void qbus_list_dev(BusState
*bus
)
561 const char *sep
= " ";
563 error_printf("devices at \"%s\":", bus
->name
);
564 QLIST_FOREACH(dev
, &bus
->children
, sibling
) {
565 error_printf("%s\"%s\"", sep
, dev
->info
->name
);
567 error_printf("/\"%s\"", dev
->id
);
573 static BusState
*qbus_find_bus(DeviceState
*dev
, char *elem
)
577 QLIST_FOREACH(child
, &dev
->child_bus
, sibling
) {
578 if (strcmp(child
->name
, elem
) == 0) {
585 static DeviceState
*qbus_find_dev(BusState
*bus
, char *elem
)
590 * try to match in order:
591 * (1) instance id, if present
593 * (3) driver alias, if present
595 QLIST_FOREACH(dev
, &bus
->children
, sibling
) {
596 if (dev
->id
&& strcmp(dev
->id
, elem
) == 0) {
600 QLIST_FOREACH(dev
, &bus
->children
, sibling
) {
601 if (strcmp(dev
->info
->name
, elem
) == 0) {
605 QLIST_FOREACH(dev
, &bus
->children
, sibling
) {
606 if (dev
->info
->alias
&& strcmp(dev
->info
->alias
, elem
) == 0) {
613 static BusState
*qbus_find(const char *path
)
620 /* find start element */
621 if (path
[0] == '/') {
622 bus
= main_system_bus
;
625 if (sscanf(path
, "%127[^/]%n", elem
, &len
) != 1) {
629 bus
= qbus_find_recursive(main_system_bus
, elem
, NULL
);
631 qerror_report(QERR_BUS_NOT_FOUND
, elem
);
638 assert(path
[pos
] == '/' || !path
[pos
]);
639 while (path
[pos
] == '/') {
642 if (path
[pos
] == '\0') {
647 if (sscanf(path
+pos
, "%127[^/]%n", elem
, &len
) != 1) {
652 dev
= qbus_find_dev(bus
, elem
);
654 qerror_report(QERR_DEVICE_NOT_FOUND
, elem
);
655 if (!monitor_cur_is_qmp()) {
661 assert(path
[pos
] == '/' || !path
[pos
]);
662 while (path
[pos
] == '/') {
665 if (path
[pos
] == '\0') {
666 /* last specified element is a device. If it has exactly
667 * one child bus accept it nevertheless */
668 switch (dev
->num_child_bus
) {
670 qerror_report(QERR_DEVICE_NO_BUS
, elem
);
673 return QLIST_FIRST(&dev
->child_bus
);
675 qerror_report(QERR_DEVICE_MULTIPLE_BUSSES
, elem
);
676 if (!monitor_cur_is_qmp()) {
684 if (sscanf(path
+pos
, "%127[^/]%n", elem
, &len
) != 1) {
689 bus
= qbus_find_bus(dev
, elem
);
691 qerror_report(QERR_BUS_NOT_FOUND
, elem
);
692 if (!monitor_cur_is_qmp()) {
700 void qbus_create_inplace(BusState
*bus
, BusInfo
*info
,
701 DeviceState
*parent
, const char *name
)
707 bus
->parent
= parent
;
710 /* use supplied name */
711 bus
->name
= qemu_strdup(name
);
712 } else if (parent
&& parent
->id
) {
713 /* parent device has id -> use it for bus name */
714 len
= strlen(parent
->id
) + 16;
715 buf
= qemu_malloc(len
);
716 snprintf(buf
, len
, "%s.%d", parent
->id
, parent
->num_child_bus
);
719 /* no id -> use lowercase bus type for bus name */
720 len
= strlen(info
->name
) + 16;
721 buf
= qemu_malloc(len
);
722 len
= snprintf(buf
, len
, "%s.%d", info
->name
,
723 parent
? parent
->num_child_bus
: 0);
724 for (i
= 0; i
< len
; i
++)
725 buf
[i
] = qemu_tolower(buf
[i
]);
729 QLIST_INIT(&bus
->children
);
731 QLIST_INSERT_HEAD(&parent
->child_bus
, bus
, sibling
);
732 parent
->num_child_bus
++;
737 BusState
*qbus_create(BusInfo
*info
, DeviceState
*parent
, const char *name
)
741 bus
= qemu_mallocz(info
->size
);
742 bus
->qdev_allocated
= 1;
743 qbus_create_inplace(bus
, info
, parent
, name
);
747 void qbus_free(BusState
*bus
)
751 while ((dev
= QLIST_FIRST(&bus
->children
)) != NULL
) {
755 QLIST_REMOVE(bus
, sibling
);
756 bus
->parent
->num_child_bus
--;
758 qemu_free((void*)bus
->name
);
759 if (bus
->qdev_allocated
) {
764 #define qdev_printf(fmt, ...) monitor_printf(mon, "%*s" fmt, indent, "", ## __VA_ARGS__)
765 static void qbus_print(Monitor
*mon
, BusState
*bus
, int indent
);
767 static void qdev_print_props(Monitor
*mon
, DeviceState
*dev
, Property
*props
,
768 const char *prefix
, int indent
)
774 while (props
->name
) {
776 * TODO Properties without a print method are just for dirty
777 * hacks. qdev_prop_ptr is the only such PropertyInfo. It's
778 * marked for removal. The test props->info->print should be
779 * removed along with it.
781 if (props
->info
->print
) {
782 props
->info
->print(dev
, props
, buf
, sizeof(buf
));
783 qdev_printf("%s-prop: %s = %s\n", prefix
, props
->name
, buf
);
789 static void qdev_print(Monitor
*mon
, DeviceState
*dev
, int indent
)
792 qdev_printf("dev: %s, id \"%s\"\n", dev
->info
->name
,
793 dev
->id
? dev
->id
: "");
795 if (dev
->num_gpio_in
) {
796 qdev_printf("gpio-in %d\n", dev
->num_gpio_in
);
798 if (dev
->num_gpio_out
) {
799 qdev_printf("gpio-out %d\n", dev
->num_gpio_out
);
801 qdev_print_props(mon
, dev
, dev
->info
->props
, "dev", indent
);
802 qdev_print_props(mon
, dev
, dev
->parent_bus
->info
->props
, "bus", indent
);
803 if (dev
->parent_bus
->info
->print_dev
)
804 dev
->parent_bus
->info
->print_dev(mon
, dev
, indent
);
805 QLIST_FOREACH(child
, &dev
->child_bus
, sibling
) {
806 qbus_print(mon
, child
, indent
);
810 static void qbus_print(Monitor
*mon
, BusState
*bus
, int indent
)
812 struct DeviceState
*dev
;
814 qdev_printf("bus: %s\n", bus
->name
);
816 qdev_printf("type %s\n", bus
->info
->name
);
817 QLIST_FOREACH(dev
, &bus
->children
, sibling
) {
818 qdev_print(mon
, dev
, indent
);
823 void do_info_qtree(Monitor
*mon
)
826 qbus_print(mon
, main_system_bus
, 0);
829 void do_info_qdm(Monitor
*mon
)
833 for (info
= device_info_list
; info
!= NULL
; info
= info
->next
) {
834 qdev_print_devinfo(info
);
838 int do_device_add(Monitor
*mon
, const QDict
*qdict
, QObject
**ret_data
)
842 opts
= qemu_opts_from_qdict(qemu_find_opts("device"), qdict
);
846 if (!monitor_cur_is_qmp() && qdev_device_help(opts
)) {
850 if (!qdev_device_add(opts
)) {
857 int do_device_del(Monitor
*mon
, const QDict
*qdict
, QObject
**ret_data
)
859 const char *id
= qdict_get_str(qdict
, "id");
862 dev
= qdev_find_recursive(main_system_bus
, id
);
864 qerror_report(QERR_DEVICE_NOT_FOUND
, id
);
867 return qdev_unplug(dev
);