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 /* Create a new device. This only initializes the device state structure
82 and allows properties to be set. qdev_init should be called to
83 initialize the actual device emulation. */
84 DeviceState
*qdev_create(BusState
*bus
, const char *name
)
90 if (!main_system_bus
) {
91 main_system_bus
= qbus_create(&system_bus_info
, NULL
, "main-system-bus");
93 bus
= main_system_bus
;
96 info
= qdev_find_info(bus
->info
, name
);
98 hw_error("Unknown device '%s' for bus '%s'\n", name
, bus
->info
->name
);
101 dev
= qemu_mallocz(info
->size
);
103 dev
->parent_bus
= bus
;
104 qdev_prop_set_defaults(dev
, dev
->info
->props
);
105 qdev_prop_set_defaults(dev
, dev
->parent_bus
->info
->props
);
106 qdev_prop_set_globals(dev
);
107 QLIST_INSERT_HEAD(&bus
->children
, dev
, sibling
);
109 assert(bus
->allow_hotplug
);
112 dev
->state
= DEV_STATE_CREATED
;
116 static int qdev_print_devinfo(DeviceInfo
*info
, char *dest
, int len
)
121 ret
= snprintf(dest
+pos
, len
-pos
, "name \"%s\", bus %s",
122 info
->name
, info
->bus_info
->name
);
123 pos
+= MIN(len
-pos
,ret
);
125 ret
= snprintf(dest
+pos
, len
-pos
, ", alias \"%s\"", info
->alias
);
126 pos
+= MIN(len
-pos
,ret
);
129 ret
= snprintf(dest
+pos
, len
-pos
, ", desc \"%s\"", info
->desc
);
130 pos
+= MIN(len
-pos
,ret
);
133 ret
= snprintf(dest
+pos
, len
-pos
, ", no-user");
134 pos
+= MIN(len
-pos
,ret
);
139 static int set_property(const char *name
, const char *value
, void *opaque
)
141 DeviceState
*dev
= opaque
;
143 if (strcmp(name
, "driver") == 0)
145 if (strcmp(name
, "bus") == 0)
148 if (qdev_prop_parse(dev
, name
, value
) == -1) {
149 qemu_error("can't set property \"%s\" to \"%s\" for \"%s\"\n",
150 name
, value
, dev
->info
->name
);
156 DeviceState
*qdev_device_add(QemuOpts
*opts
)
158 const char *driver
, *path
, *id
;
163 driver
= qemu_opt_get(opts
, "driver");
165 qemu_error("-device: no driver specified\n");
168 if (strcmp(driver
, "?") == 0) {
170 for (info
= device_info_list
; info
!= NULL
; info
= info
->next
) {
171 qdev_print_devinfo(info
, msg
, sizeof(msg
));
172 qemu_error("%s\n", msg
);
178 info
= qdev_find_info(NULL
, driver
);
180 qemu_error_new(QERR_DEVICE_NOT_FOUND
, driver
);
184 qemu_error("device \"%s\" can't be added via command line\n",
190 path
= qemu_opt_get(opts
, "bus");
192 bus
= qbus_find(path
);
194 bus
= qbus_find_recursive(main_system_bus
, NULL
, info
->bus_info
);
197 qemu_error("Did not find %s bus for %s\n",
198 path
? path
: info
->bus_info
->name
, info
->name
);
201 if (qdev_hotplug
&& !bus
->allow_hotplug
) {
202 qemu_error("Bus %s does not support hotplugging\n",
207 /* create device, set properties */
208 qdev
= qdev_create(bus
, driver
);
209 id
= qemu_opts_id(opts
);
213 if (qemu_opt_foreach(opts
, set_property
, qdev
, 1) != 0) {
217 if (qdev_init(qdev
) < 0) {
218 qemu_error("Error initializing device %s\n", driver
);
225 static void qdev_reset(void *opaque
)
227 DeviceState
*dev
= opaque
;
228 if (dev
->info
->reset
)
229 dev
->info
->reset(dev
);
232 /* Initialize a device. Device properties should be set before calling
233 this function. IRQs and MMIO regions should be connected/mapped after
234 calling this function.
235 On failure, destroy the device and return negative value.
236 Return 0 on success. */
237 int qdev_init(DeviceState
*dev
)
241 assert(dev
->state
== DEV_STATE_CREATED
);
242 rc
= dev
->info
->init(dev
, dev
->info
);
247 qemu_register_reset(qdev_reset
, dev
);
249 vmstate_register(-1, dev
->info
->vmsd
, dev
);
250 dev
->state
= DEV_STATE_INITIALIZED
;
254 int qdev_unplug(DeviceState
*dev
)
256 if (!dev
->parent_bus
->allow_hotplug
) {
257 qemu_error("Bus %s does not support hotplugging\n",
258 dev
->parent_bus
->name
);
261 assert(dev
->info
->unplug
!= NULL
);
263 return dev
->info
->unplug(dev
);
266 /* can be used as ->unplug() callback for the simple cases */
267 int qdev_simple_unplug_cb(DeviceState
*dev
)
274 /* Like qdev_init(), but terminate program via hw_error() instead of
275 returning an error value. This is okay during machine creation.
276 Don't use for hotplug, because there callers need to recover from
277 failure. Exception: if you know the device's init() callback can't
278 fail, then qdev_init_nofail() can't fail either, and is therefore
279 usable even then. But relying on the device implementation that
280 way is somewhat unclean, and best avoided. */
281 void qdev_init_nofail(DeviceState
*dev
)
283 DeviceInfo
*info
= dev
->info
;
285 if (qdev_init(dev
) < 0)
286 hw_error("Initialization of device %s failed\n", info
->name
);
289 /* Unlink device from bus and free the structure. */
290 void qdev_free(DeviceState
*dev
)
294 if (dev
->state
== DEV_STATE_INITIALIZED
) {
295 while (dev
->num_child_bus
) {
296 bus
= QLIST_FIRST(&dev
->child_bus
);
300 vmstate_unregister(dev
->info
->vmsd
, dev
);
302 dev
->info
->exit(dev
);
304 qemu_opts_del(dev
->opts
);
306 qemu_unregister_reset(qdev_reset
, dev
);
307 QLIST_REMOVE(dev
, sibling
);
311 void qdev_machine_creation_done(void)
314 * ok, initial machine setup is done, starting from now we can
315 * only create hotpluggable devices
320 /* Get a character (serial) device interface. */
321 CharDriverState
*qdev_init_chardev(DeviceState
*dev
)
323 static int next_serial
;
325 /* FIXME: This function needs to go away: use chardev properties! */
326 return serial_hds
[next_serial
++];
329 BusState
*qdev_get_parent_bus(DeviceState
*dev
)
331 return dev
->parent_bus
;
334 void qdev_init_gpio_in(DeviceState
*dev
, qemu_irq_handler handler
, int n
)
336 assert(dev
->num_gpio_in
== 0);
337 dev
->num_gpio_in
= n
;
338 dev
->gpio_in
= qemu_allocate_irqs(handler
, dev
, n
);
341 void qdev_init_gpio_out(DeviceState
*dev
, qemu_irq
*pins
, int n
)
343 assert(dev
->num_gpio_out
== 0);
344 dev
->num_gpio_out
= n
;
345 dev
->gpio_out
= pins
;
348 qemu_irq
qdev_get_gpio_in(DeviceState
*dev
, int n
)
350 assert(n
>= 0 && n
< dev
->num_gpio_in
);
351 return dev
->gpio_in
[n
];
354 void qdev_connect_gpio_out(DeviceState
* dev
, int n
, qemu_irq pin
)
356 assert(n
>= 0 && n
< dev
->num_gpio_out
);
357 dev
->gpio_out
[n
] = pin
;
360 void qdev_set_nic_properties(DeviceState
*dev
, NICInfo
*nd
)
362 qdev_prop_set_macaddr(dev
, "mac", nd
->macaddr
);
364 qdev_prop_set_vlan(dev
, "vlan", nd
->vlan
);
366 qdev_prop_set_netdev(dev
, "netdev", nd
->netdev
);
367 if (nd
->nvectors
!= NIC_NVECTORS_UNSPECIFIED
&&
368 qdev_prop_exists(dev
, "vectors")) {
369 qdev_prop_set_uint32(dev
, "vectors", nd
->nvectors
);
373 static int next_block_unit
[IF_COUNT
];
375 /* Get a block device. This should only be used for single-drive devices
376 (e.g. SD/Floppy/MTD). Multi-disk devices (scsi/ide) should use the
378 BlockDriverState
*qdev_init_bdrv(DeviceState
*dev
, BlockInterfaceType type
)
380 int unit
= next_block_unit
[type
]++;
383 dinfo
= drive_get(type
, 0, unit
);
384 return dinfo
? dinfo
->bdrv
: NULL
;
387 BusState
*qdev_get_child_bus(DeviceState
*dev
, const char *name
)
391 QLIST_FOREACH(bus
, &dev
->child_bus
, sibling
) {
392 if (strcmp(name
, bus
->name
) == 0) {
399 static BusState
*qbus_find_recursive(BusState
*bus
, const char *name
,
403 BusState
*child
, *ret
;
406 if (name
&& (strcmp(bus
->name
, name
) != 0)) {
409 if (info
&& (bus
->info
!= info
)) {
416 QLIST_FOREACH(dev
, &bus
->children
, sibling
) {
417 QLIST_FOREACH(child
, &dev
->child_bus
, sibling
) {
418 ret
= qbus_find_recursive(child
, name
, info
);
427 static DeviceState
*qdev_find_recursive(BusState
*bus
, const char *id
)
429 DeviceState
*dev
, *ret
;
432 QLIST_FOREACH(dev
, &bus
->children
, sibling
) {
433 if (dev
->id
&& strcmp(dev
->id
, id
) == 0)
435 QLIST_FOREACH(child
, &dev
->child_bus
, sibling
) {
436 ret
= qdev_find_recursive(child
, id
);
445 static void qbus_list_bus(DeviceState
*dev
, char *dest
, int len
)
448 const char *sep
= " ";
451 pos
+= snprintf(dest
+pos
, len
-pos
,"child busses at \"%s\":",
452 dev
->id
? dev
->id
: dev
->info
->name
);
453 QLIST_FOREACH(child
, &dev
->child_bus
, sibling
) {
454 pos
+= snprintf(dest
+pos
, len
-pos
, "%s\"%s\"", sep
, child
->name
);
459 static void qbus_list_dev(BusState
*bus
, char *dest
, int len
)
462 const char *sep
= " ";
465 pos
+= snprintf(dest
+pos
, len
-pos
, "devices at \"%s\":",
467 QLIST_FOREACH(dev
, &bus
->children
, sibling
) {
468 pos
+= snprintf(dest
+pos
, len
-pos
, "%s\"%s\"",
469 sep
, dev
->info
->name
);
471 pos
+= snprintf(dest
+pos
, len
-pos
, "/\"%s\"", dev
->id
);
476 static BusState
*qbus_find_bus(DeviceState
*dev
, char *elem
)
480 QLIST_FOREACH(child
, &dev
->child_bus
, sibling
) {
481 if (strcmp(child
->name
, elem
) == 0) {
488 static DeviceState
*qbus_find_dev(BusState
*bus
, char *elem
)
493 * try to match in order:
494 * (1) instance id, if present
496 * (3) driver alias, if present
498 QLIST_FOREACH(dev
, &bus
->children
, sibling
) {
499 if (dev
->id
&& strcmp(dev
->id
, elem
) == 0) {
503 QLIST_FOREACH(dev
, &bus
->children
, sibling
) {
504 if (strcmp(dev
->info
->name
, elem
) == 0) {
508 QLIST_FOREACH(dev
, &bus
->children
, sibling
) {
509 if (dev
->info
->alias
&& strcmp(dev
->info
->alias
, elem
) == 0) {
516 static BusState
*qbus_find(const char *path
)
520 char elem
[128], msg
[256];
523 /* find start element */
524 if (path
[0] == '/') {
525 bus
= main_system_bus
;
528 if (sscanf(path
, "%127[^/]%n", elem
, &len
) != 1) {
529 qemu_error("path parse error (\"%s\")\n", path
);
532 bus
= qbus_find_recursive(main_system_bus
, elem
, NULL
);
534 qemu_error("bus \"%s\" not found\n", elem
);
541 if (path
[pos
] == '\0') {
547 if (sscanf(path
+pos
, "/%127[^/]%n", elem
, &len
) != 1) {
548 qemu_error("path parse error (\"%s\" pos %d)\n", path
, pos
);
552 dev
= qbus_find_dev(bus
, elem
);
554 qbus_list_dev(bus
, msg
, sizeof(msg
));
555 qemu_error("device \"%s\" not found\n%s\n", elem
, msg
);
558 if (path
[pos
] == '\0') {
559 /* last specified element is a device. If it has exactly
560 * one child bus accept it nevertheless */
561 switch (dev
->num_child_bus
) {
563 qemu_error("device has no child bus (%s)\n", path
);
566 return QLIST_FIRST(&dev
->child_bus
);
568 qbus_list_bus(dev
, msg
, sizeof(msg
));
569 qemu_error("device has multiple child busses (%s)\n%s\n",
576 if (sscanf(path
+pos
, "/%127[^/]%n", elem
, &len
) != 1) {
577 qemu_error("path parse error (\"%s\" pos %d)\n", path
, pos
);
581 bus
= qbus_find_bus(dev
, elem
);
583 qbus_list_bus(dev
, msg
, sizeof(msg
));
584 qemu_error("child bus \"%s\" not found\n%s\n", elem
, msg
);
590 void qbus_create_inplace(BusState
*bus
, BusInfo
*info
,
591 DeviceState
*parent
, const char *name
)
597 bus
->parent
= parent
;
600 /* use supplied name */
601 bus
->name
= qemu_strdup(name
);
602 } else if (parent
&& parent
->id
) {
603 /* parent device has id -> use it for bus name */
604 len
= strlen(parent
->id
) + 16;
605 buf
= qemu_malloc(len
);
606 snprintf(buf
, len
, "%s.%d", parent
->id
, parent
->num_child_bus
);
609 /* no id -> use lowercase bus type for bus name */
610 len
= strlen(info
->name
) + 16;
611 buf
= qemu_malloc(len
);
612 len
= snprintf(buf
, len
, "%s.%d", info
->name
,
613 parent
? parent
->num_child_bus
: 0);
614 for (i
= 0; i
< len
; i
++)
615 buf
[i
] = qemu_tolower(buf
[i
]);
619 QLIST_INIT(&bus
->children
);
621 QLIST_INSERT_HEAD(&parent
->child_bus
, bus
, sibling
);
622 parent
->num_child_bus
++;
627 BusState
*qbus_create(BusInfo
*info
, DeviceState
*parent
, const char *name
)
631 bus
= qemu_mallocz(info
->size
);
632 bus
->qdev_allocated
= 1;
633 qbus_create_inplace(bus
, info
, parent
, name
);
637 void qbus_free(BusState
*bus
)
641 while ((dev
= QLIST_FIRST(&bus
->children
)) != NULL
) {
645 QLIST_REMOVE(bus
, sibling
);
646 bus
->parent
->num_child_bus
--;
648 if (bus
->qdev_allocated
) {
653 #define qdev_printf(fmt, ...) monitor_printf(mon, "%*s" fmt, indent, "", ## __VA_ARGS__)
654 static void qbus_print(Monitor
*mon
, BusState
*bus
, int indent
);
656 static void qdev_print_props(Monitor
*mon
, DeviceState
*dev
, Property
*props
,
657 const char *prefix
, int indent
)
663 while (props
->name
) {
664 if (props
->info
->print
) {
665 props
->info
->print(dev
, props
, buf
, sizeof(buf
));
666 qdev_printf("%s-prop: %s = %s\n", prefix
, props
->name
, buf
);
672 static void qdev_print(Monitor
*mon
, DeviceState
*dev
, int indent
)
675 qdev_printf("dev: %s, id \"%s\"\n", dev
->info
->name
,
676 dev
->id
? dev
->id
: "");
678 if (dev
->num_gpio_in
) {
679 qdev_printf("gpio-in %d\n", dev
->num_gpio_in
);
681 if (dev
->num_gpio_out
) {
682 qdev_printf("gpio-out %d\n", dev
->num_gpio_out
);
684 qdev_print_props(mon
, dev
, dev
->info
->props
, "dev", indent
);
685 qdev_print_props(mon
, dev
, dev
->parent_bus
->info
->props
, "bus", indent
);
686 if (dev
->parent_bus
->info
->print_dev
)
687 dev
->parent_bus
->info
->print_dev(mon
, dev
, indent
);
688 QLIST_FOREACH(child
, &dev
->child_bus
, sibling
) {
689 qbus_print(mon
, child
, indent
);
693 static void qbus_print(Monitor
*mon
, BusState
*bus
, int indent
)
695 struct DeviceState
*dev
;
697 qdev_printf("bus: %s\n", bus
->name
);
699 qdev_printf("type %s\n", bus
->info
->name
);
700 QLIST_FOREACH(dev
, &bus
->children
, sibling
) {
701 qdev_print(mon
, dev
, indent
);
706 void do_info_qtree(Monitor
*mon
)
709 qbus_print(mon
, main_system_bus
, 0);
712 void do_info_qdm(Monitor
*mon
)
717 for (info
= device_info_list
; info
!= NULL
; info
= info
->next
) {
718 qdev_print_devinfo(info
, msg
, sizeof(msg
));
719 monitor_printf(mon
, "%s\n", msg
);
723 void do_device_add(Monitor
*mon
, const QDict
*qdict
)
727 opts
= qemu_opts_parse(&qemu_device_opts
,
728 qdict_get_str(qdict
, "config"), "driver");
730 qdev_device_add(opts
);
733 void do_device_del(Monitor
*mon
, const QDict
*qdict
)
735 const char *id
= qdict_get_str(qdict
, "id");
738 dev
= qdev_find_recursive(main_system_bus
, id
);
740 qemu_error("Device '%s' not found\n", id
);