blob: c64357603dbbc17262fad7c2303d7a9972232e59 [file] [log] [blame]
Paul Brookaae94602009-05-14 22:35:06 +01001/*
2 * Dynamic device configuration and creation.
3 *
4 * Copyright (c) 2009 CodeSourcery
5 *
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.
10 *
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.
15 *
16 * You should have received a copy of the GNU Lesser General Public
Blue Swirl8167ee82009-07-16 20:47:01 +000017 * License along with this library; if not, see <http://www.gnu.org/licenses/>.
Paul Brookaae94602009-05-14 22:35:06 +010018 */
19
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
26 this API directly. */
27
Paul Brook9d07d752009-05-14 22:35:07 +010028#include "net.h"
Paul Brookaae94602009-05-14 22:35:06 +010029#include "qdev.h"
30#include "sysemu.h"
Gerd Hoffmanncae49562009-06-05 15:53:17 +010031#include "monitor.h"
Luiz Capitulino3ced9f72009-11-18 23:05:33 -020032#include "qerror.h"
Paul Brookaae94602009-05-14 22:35:06 +010033
Gerd Hoffmann3418bd22009-09-25 21:42:41 +020034static int qdev_hotplug = 0;
35
Gerd Hoffmanncdaed7c2009-10-06 21:17:52 +020036/* This is a nasty hack to allow passing a NULL bus to qdev_create. */
Blue Swirlb9aaf7f2009-06-09 18:38:51 +000037static BusState *main_system_bus;
Paul Brook4d6ae672009-05-14 22:35:06 +010038
Gerd Hoffmann0958b4c2009-10-26 15:56:45 +010039DeviceInfo *device_info_list;
Paul Brookaae94602009-05-14 22:35:06 +010040
Gerd Hoffmann8ffb1bc2009-07-15 13:59:25 +020041static BusState *qbus_find_recursive(BusState *bus, const char *name,
42 const BusInfo *info);
43static BusState *qbus_find(const char *path);
44
Paul Brookaae94602009-05-14 22:35:06 +010045/* Register a new device type. */
Gerd Hoffmann074f2ff2009-06-10 09:41:42 +020046void qdev_register(DeviceInfo *info)
Paul Brookaae94602009-05-14 22:35:06 +010047{
Gerd Hoffmann074f2ff2009-06-10 09:41:42 +020048 assert(info->size >= sizeof(DeviceState));
Gerd Hoffmann042f84d2009-06-30 14:12:09 +020049 assert(!info->next);
Paul Brookaae94602009-05-14 22:35:06 +010050
Gerd Hoffmann042f84d2009-06-30 14:12:09 +020051 info->next = device_info_list;
52 device_info_list = info;
Paul Brookaae94602009-05-14 22:35:06 +010053}
54
Gerd Hoffmann81ebb982009-07-15 13:43:32 +020055static DeviceInfo *qdev_find_info(BusInfo *bus_info, const char *name)
56{
57 DeviceInfo *info;
58
Gerd Hoffmann3320e562009-07-15 13:43:33 +020059 /* first check device names */
Gerd Hoffmann81ebb982009-07-15 13:43:32 +020060 for (info = device_info_list; info != NULL; info = info->next) {
61 if (bus_info && info->bus_info != bus_info)
62 continue;
63 if (strcmp(info->name, name) != 0)
64 continue;
65 return info;
66 }
Gerd Hoffmann3320e562009-07-15 13:43:33 +020067
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)
71 continue;
72 if (!info->alias)
73 continue;
74 if (strcmp(info->alias, name) != 0)
75 continue;
76 return info;
77 }
Gerd Hoffmann81ebb982009-07-15 13:43:32 +020078 return NULL;
79}
80
Paul Brookaae94602009-05-14 22:35:06 +010081/* 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. */
Paul Brook02e2da42009-05-23 00:05:19 +010084DeviceState *qdev_create(BusState *bus, const char *name)
Paul Brookaae94602009-05-14 22:35:06 +010085{
Gerd Hoffmann042f84d2009-06-30 14:12:09 +020086 DeviceInfo *info;
Paul Brookaae94602009-05-14 22:35:06 +010087 DeviceState *dev;
88
Gerd Hoffmann10c4c982009-06-30 14:12:08 +020089 if (!bus) {
90 if (!main_system_bus) {
91 main_system_bus = qbus_create(&system_bus_info, NULL, "main-system-bus");
Paul Brookaae94602009-05-14 22:35:06 +010092 }
Gerd Hoffmann10c4c982009-06-30 14:12:08 +020093 bus = main_system_bus;
94 }
95
Gerd Hoffmann81ebb982009-07-15 13:43:32 +020096 info = qdev_find_info(bus->info, name);
Gerd Hoffmann042f84d2009-06-30 14:12:09 +020097 if (!info) {
Gerd Hoffmann10c4c982009-06-30 14:12:08 +020098 hw_error("Unknown device '%s' for bus '%s'\n", name, bus->info->name);
Paul Brookaae94602009-05-14 22:35:06 +010099 }
100
Gerd Hoffmann042f84d2009-06-30 14:12:09 +0200101 dev = qemu_mallocz(info->size);
102 dev->info = info;
Paul Brook02e2da42009-05-23 00:05:19 +0100103 dev->parent_bus = bus;
Gerd Hoffmannee6847d2009-07-15 13:43:31 +0200104 qdev_prop_set_defaults(dev, dev->info->props);
105 qdev_prop_set_defaults(dev, dev->parent_bus->info->props);
Gerd Hoffmann458fb672009-12-08 13:11:33 +0100106 qdev_prop_set_globals(dev);
Blue Swirl72cf2d42009-09-12 07:36:22 +0000107 QLIST_INSERT_HEAD(&bus->children, dev, sibling);
Gerd Hoffmann3418bd22009-09-25 21:42:41 +0200108 if (qdev_hotplug) {
109 assert(bus->allow_hotplug);
110 dev->hotplugged = 1;
111 }
Gerd Hoffmann131ec1b2009-09-25 21:42:34 +0200112 dev->state = DEV_STATE_CREATED;
Paul Brookaae94602009-05-14 22:35:06 +0100113 return dev;
114}
115
Gerd Hoffmann1b524b02009-07-29 13:12:23 +0200116static int qdev_print_devinfo(DeviceInfo *info, char *dest, int len)
117{
118 int pos = 0;
Gerd Hoffmann22f2e342009-08-03 11:26:48 +0200119 int ret;
Gerd Hoffmann1b524b02009-07-29 13:12:23 +0200120
Gerd Hoffmann22f2e342009-08-03 11:26:48 +0200121 ret = snprintf(dest+pos, len-pos, "name \"%s\", bus %s",
122 info->name, info->bus_info->name);
123 pos += MIN(len-pos,ret);
124 if (info->alias) {
125 ret = snprintf(dest+pos, len-pos, ", alias \"%s\"", info->alias);
126 pos += MIN(len-pos,ret);
127 }
128 if (info->desc) {
129 ret = snprintf(dest+pos, len-pos, ", desc \"%s\"", info->desc);
130 pos += MIN(len-pos,ret);
131 }
132 if (info->no_user) {
133 ret = snprintf(dest+pos, len-pos, ", no-user");
134 pos += MIN(len-pos,ret);
135 }
Gerd Hoffmann1b524b02009-07-29 13:12:23 +0200136 return pos;
137}
138
Gerd Hoffmannf31d07d2009-07-31 12:25:37 +0200139static int set_property(const char *name, const char *value, void *opaque)
Gerd Hoffmann8ffb1bc2009-07-15 13:59:25 +0200140{
Gerd Hoffmannf31d07d2009-07-31 12:25:37 +0200141 DeviceState *dev = opaque;
142
143 if (strcmp(name, "driver") == 0)
144 return 0;
145 if (strcmp(name, "bus") == 0)
146 return 0;
147
Mark McLoughlin3df04ac2009-09-23 11:24:05 +0100148 if (qdev_prop_parse(dev, name, value) == -1) {
Gerd Hoffmann286c2322009-08-14 10:36:08 +0200149 qemu_error("can't set property \"%s\" to \"%s\" for \"%s\"\n",
150 name, value, dev->info->name);
Gerd Hoffmannf31d07d2009-07-31 12:25:37 +0200151 return -1;
152 }
153 return 0;
154}
155
156DeviceState *qdev_device_add(QemuOpts *opts)
157{
158 const char *driver, *path, *id;
Gerd Hoffmann8ffb1bc2009-07-15 13:59:25 +0200159 DeviceInfo *info;
160 DeviceState *qdev;
161 BusState *bus;
Gerd Hoffmann8ffb1bc2009-07-15 13:59:25 +0200162
Gerd Hoffmannf31d07d2009-07-31 12:25:37 +0200163 driver = qemu_opt_get(opts, "driver");
164 if (!driver) {
Gerd Hoffmann286c2322009-08-14 10:36:08 +0200165 qemu_error("-device: no driver specified\n");
Gerd Hoffmann8ffb1bc2009-07-15 13:59:25 +0200166 return NULL;
167 }
168 if (strcmp(driver, "?") == 0) {
Gerd Hoffmann1b524b02009-07-29 13:12:23 +0200169 char msg[256];
Gerd Hoffmann8ffb1bc2009-07-15 13:59:25 +0200170 for (info = device_info_list; info != NULL; info = info->next) {
Gerd Hoffmann1b524b02009-07-29 13:12:23 +0200171 qdev_print_devinfo(info, msg, sizeof(msg));
Gerd Hoffmann286c2322009-08-14 10:36:08 +0200172 qemu_error("%s\n", msg);
Gerd Hoffmann8ffb1bc2009-07-15 13:59:25 +0200173 }
174 return NULL;
175 }
Gerd Hoffmannf31d07d2009-07-31 12:25:37 +0200176
177 /* find driver */
Gerd Hoffmann8ffb1bc2009-07-15 13:59:25 +0200178 info = qdev_find_info(NULL, driver);
179 if (!info) {
Luiz Capitulino3ced9f72009-11-18 23:05:33 -0200180 qemu_error_new(QERR_DEVICE_NOT_FOUND, driver);
Gerd Hoffmann8ffb1bc2009-07-15 13:59:25 +0200181 return NULL;
182 }
183 if (info->no_user) {
Gerd Hoffmann286c2322009-08-14 10:36:08 +0200184 qemu_error("device \"%s\" can't be added via command line\n",
185 info->name);
Gerd Hoffmann8ffb1bc2009-07-15 13:59:25 +0200186 return NULL;
187 }
188
Gerd Hoffmannf31d07d2009-07-31 12:25:37 +0200189 /* find bus */
190 path = qemu_opt_get(opts, "bus");
191 if (path != NULL) {
Gerd Hoffmann8ffb1bc2009-07-15 13:59:25 +0200192 bus = qbus_find(path);
Gerd Hoffmann8ffb1bc2009-07-15 13:59:25 +0200193 } else {
194 bus = qbus_find_recursive(main_system_bus, NULL, info->bus_info);
Gerd Hoffmann8ffb1bc2009-07-15 13:59:25 +0200195 }
Gerd Hoffmann75570082009-08-31 14:23:58 +0200196 if (!bus) {
197 qemu_error("Did not find %s bus for %s\n",
198 path ? path : info->bus_info->name, info->name);
Gerd Hoffmannf31d07d2009-07-31 12:25:37 +0200199 return NULL;
Gerd Hoffmann75570082009-08-31 14:23:58 +0200200 }
Gerd Hoffmann3418bd22009-09-25 21:42:41 +0200201 if (qdev_hotplug && !bus->allow_hotplug) {
202 qemu_error("Bus %s does not support hotplugging\n",
203 bus->name);
204 return NULL;
205 }
Gerd Hoffmann8ffb1bc2009-07-15 13:59:25 +0200206
Gerd Hoffmannf31d07d2009-07-31 12:25:37 +0200207 /* create device, set properties */
208 qdev = qdev_create(bus, driver);
209 id = qemu_opts_id(opts);
210 if (id) {
211 qdev->id = id;
Gerd Hoffmann8ffb1bc2009-07-15 13:59:25 +0200212 }
Gerd Hoffmannf31d07d2009-07-31 12:25:37 +0200213 if (qemu_opt_foreach(opts, set_property, qdev, 1) != 0) {
214 qdev_free(qdev);
215 return NULL;
216 }
Markus Armbruster5c17ca22009-10-07 01:16:01 +0200217 if (qdev_init(qdev) < 0) {
Amit Shahc8cd1fc2009-09-29 15:51:03 +0530218 qemu_error("Error initializing device %s\n", driver);
Gerd Hoffmann81a322d2009-08-14 10:36:05 +0200219 return NULL;
220 }
Gerd Hoffmannef80b462009-09-25 21:42:49 +0200221 qdev->opts = opts;
Gerd Hoffmann8ffb1bc2009-07-15 13:59:25 +0200222 return qdev;
223}
224
Michael S. Tsirkin7f23f812009-09-16 13:40:27 +0300225static void qdev_reset(void *opaque)
226{
227 DeviceState *dev = opaque;
228 if (dev->info->reset)
229 dev->info->reset(dev);
230}
231
Paul Brookaae94602009-05-14 22:35:06 +0100232/* Initialize a device. Device properties should be set before calling
233 this function. IRQs and MMIO regions should be connected/mapped after
Markus Armbruster18cfeb52009-10-07 01:15:56 +0200234 calling this function.
235 On failure, destroy the device and return negative value.
236 Return 0 on success. */
Gerd Hoffmann81a322d2009-08-14 10:36:05 +0200237int qdev_init(DeviceState *dev)
Paul Brookaae94602009-05-14 22:35:06 +0100238{
Gerd Hoffmann959f7332009-09-01 09:56:12 +0200239 int rc;
240
Gerd Hoffmann131ec1b2009-09-25 21:42:34 +0200241 assert(dev->state == DEV_STATE_CREATED);
Gerd Hoffmann959f7332009-09-01 09:56:12 +0200242 rc = dev->info->init(dev, dev->info);
Markus Armbruster18cfeb52009-10-07 01:15:56 +0200243 if (rc < 0) {
244 qdev_free(dev);
Gerd Hoffmann959f7332009-09-01 09:56:12 +0200245 return rc;
Markus Armbruster18cfeb52009-10-07 01:15:56 +0200246 }
Michael S. Tsirkin7f23f812009-09-16 13:40:27 +0300247 qemu_register_reset(qdev_reset, dev);
Gerd Hoffmann391a0792009-09-01 09:56:14 +0200248 if (dev->info->vmsd)
249 vmstate_register(-1, dev->info->vmsd, dev);
Gerd Hoffmann131ec1b2009-09-25 21:42:34 +0200250 dev->state = DEV_STATE_INITIALIZED;
Gerd Hoffmann959f7332009-09-01 09:56:12 +0200251 return 0;
Paul Brook02e2da42009-05-23 00:05:19 +0100252}
253
Gerd Hoffmann3418bd22009-09-25 21:42:41 +0200254int qdev_unplug(DeviceState *dev)
255{
256 if (!dev->parent_bus->allow_hotplug) {
257 qemu_error("Bus %s does not support hotplugging\n",
258 dev->parent_bus->name);
259 return -1;
260 }
Amit Shah593831d2009-11-02 14:56:41 +0530261 assert(dev->info->unplug != NULL);
262
Gerd Hoffmann3418bd22009-09-25 21:42:41 +0200263 return dev->info->unplug(dev);
264}
265
266/* can be used as ->unplug() callback for the simple cases */
267int qdev_simple_unplug_cb(DeviceState *dev)
268{
269 /* just zap it */
270 qdev_free(dev);
271 return 0;
272}
273
Markus Armbrustere23a1b32009-10-07 01:15:58 +0200274/* 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. */
281void qdev_init_nofail(DeviceState *dev)
282{
283 DeviceInfo *info = dev->info;
284
285 if (qdev_init(dev) < 0)
286 hw_error("Initialization of device %s failed\n", info->name);
287}
288
Paul Brook02e2da42009-05-23 00:05:19 +0100289/* Unlink device from bus and free the structure. */
290void qdev_free(DeviceState *dev)
291{
Gerd Hoffmann131ec1b2009-09-25 21:42:34 +0200292 BusState *bus;
293
294 if (dev->state == DEV_STATE_INITIALIZED) {
295 while (dev->num_child_bus) {
296 bus = QLIST_FIRST(&dev->child_bus);
297 qbus_free(bus);
298 }
Gerd Hoffmann131ec1b2009-09-25 21:42:34 +0200299 if (dev->info->vmsd)
300 vmstate_unregister(dev->info->vmsd, dev);
Gerd Hoffmannd29275f2009-09-25 21:42:35 +0200301 if (dev->info->exit)
302 dev->info->exit(dev);
Gerd Hoffmannef80b462009-09-25 21:42:49 +0200303 if (dev->opts)
304 qemu_opts_del(dev->opts);
Gerd Hoffmann131ec1b2009-09-25 21:42:34 +0200305 }
Michael S. Tsirkin7f23f812009-09-16 13:40:27 +0300306 qemu_unregister_reset(qdev_reset, dev);
Blue Swirl72cf2d42009-09-12 07:36:22 +0000307 QLIST_REMOVE(dev, sibling);
Gerd Hoffmannccb63de2009-07-15 13:43:34 +0200308 qemu_free(dev);
Paul Brookaae94602009-05-14 22:35:06 +0100309}
310
Gerd Hoffmann3418bd22009-09-25 21:42:41 +0200311void qdev_machine_creation_done(void)
312{
313 /*
314 * ok, initial machine setup is done, starting from now we can
315 * only create hotpluggable devices
316 */
317 qdev_hotplug = 1;
318}
319
Paul Brookaae94602009-05-14 22:35:06 +0100320/* Get a character (serial) device interface. */
321CharDriverState *qdev_init_chardev(DeviceState *dev)
322{
323 static int next_serial;
Amit Shah98b19252010-01-20 00:36:52 +0530324
325 /* FIXME: This function needs to go away: use chardev properties! */
326 return serial_hds[next_serial++];
Paul Brookaae94602009-05-14 22:35:06 +0100327}
328
Paul Brook02e2da42009-05-23 00:05:19 +0100329BusState *qdev_get_parent_bus(DeviceState *dev)
Paul Brookaae94602009-05-14 22:35:06 +0100330{
Paul Brook02e2da42009-05-23 00:05:19 +0100331 return dev->parent_bus;
Paul Brookaae94602009-05-14 22:35:06 +0100332}
333
Paul Brookaae94602009-05-14 22:35:06 +0100334void qdev_init_gpio_in(DeviceState *dev, qemu_irq_handler handler, int n)
335{
336 assert(dev->num_gpio_in == 0);
337 dev->num_gpio_in = n;
338 dev->gpio_in = qemu_allocate_irqs(handler, dev, n);
339}
340
341void qdev_init_gpio_out(DeviceState *dev, qemu_irq *pins, int n)
342{
343 assert(dev->num_gpio_out == 0);
344 dev->num_gpio_out = n;
345 dev->gpio_out = pins;
346}
347
348qemu_irq qdev_get_gpio_in(DeviceState *dev, int n)
349{
350 assert(n >= 0 && n < dev->num_gpio_in);
351 return dev->gpio_in[n];
352}
353
354void qdev_connect_gpio_out(DeviceState * dev, int n, qemu_irq pin)
355{
356 assert(n >= 0 && n < dev->num_gpio_out);
357 dev->gpio_out[n] = pin;
358}
359
Gerd Hoffmanned16ab52009-10-21 15:25:26 +0200360void qdev_set_nic_properties(DeviceState *dev, NICInfo *nd)
361{
362 qdev_prop_set_macaddr(dev, "mac", nd->macaddr);
363 if (nd->vlan)
364 qdev_prop_set_vlan(dev, "vlan", nd->vlan);
365 if (nd->netdev)
366 qdev_prop_set_netdev(dev, "netdev", nd->netdev);
Gerd Hoffmann97b15622009-10-21 15:25:35 +0200367 if (nd->nvectors != NIC_NVECTORS_UNSPECIFIED &&
368 qdev_prop_exists(dev, "vectors")) {
369 qdev_prop_set_uint32(dev, "vectors", nd->nvectors);
370 }
Gerd Hoffmanned16ab52009-10-21 15:25:26 +0200371}
372
Paul Brookaae94602009-05-14 22:35:06 +0100373static int next_block_unit[IF_COUNT];
374
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
377 appropriate bus. */
378BlockDriverState *qdev_init_bdrv(DeviceState *dev, BlockInterfaceType type)
379{
380 int unit = next_block_unit[type]++;
Gerd Hoffmann751c6a12009-07-22 16:42:57 +0200381 DriveInfo *dinfo;
Paul Brookaae94602009-05-14 22:35:06 +0100382
Gerd Hoffmann751c6a12009-07-22 16:42:57 +0200383 dinfo = drive_get(type, 0, unit);
384 return dinfo ? dinfo->bdrv : NULL;
Paul Brookaae94602009-05-14 22:35:06 +0100385}
Paul Brook4d6ae672009-05-14 22:35:06 +0100386
Paul Brook02e2da42009-05-23 00:05:19 +0100387BusState *qdev_get_child_bus(DeviceState *dev, const char *name)
Paul Brook4d6ae672009-05-14 22:35:06 +0100388{
Paul Brook02e2da42009-05-23 00:05:19 +0100389 BusState *bus;
Paul Brook4d6ae672009-05-14 22:35:06 +0100390
Blue Swirl72cf2d42009-09-12 07:36:22 +0000391 QLIST_FOREACH(bus, &dev->child_bus, sibling) {
Paul Brook4d6ae672009-05-14 22:35:06 +0100392 if (strcmp(name, bus->name) == 0) {
Paul Brook02e2da42009-05-23 00:05:19 +0100393 return bus;
Paul Brook4d6ae672009-05-14 22:35:06 +0100394 }
395 }
396 return NULL;
397}
398
Gerd Hoffmann8ffb1bc2009-07-15 13:59:25 +0200399static BusState *qbus_find_recursive(BusState *bus, const char *name,
400 const BusInfo *info)
401{
402 DeviceState *dev;
403 BusState *child, *ret;
404 int match = 1;
405
406 if (name && (strcmp(bus->name, name) != 0)) {
407 match = 0;
408 }
409 if (info && (bus->info != info)) {
410 match = 0;
411 }
412 if (match) {
413 return bus;
414 }
415
Blue Swirl72cf2d42009-09-12 07:36:22 +0000416 QLIST_FOREACH(dev, &bus->children, sibling) {
417 QLIST_FOREACH(child, &dev->child_bus, sibling) {
Gerd Hoffmann8ffb1bc2009-07-15 13:59:25 +0200418 ret = qbus_find_recursive(child, name, info);
419 if (ret) {
420 return ret;
421 }
422 }
423 }
424 return NULL;
425}
426
Gerd Hoffmann3418bd22009-09-25 21:42:41 +0200427static DeviceState *qdev_find_recursive(BusState *bus, const char *id)
428{
429 DeviceState *dev, *ret;
430 BusState *child;
431
432 QLIST_FOREACH(dev, &bus->children, sibling) {
433 if (dev->id && strcmp(dev->id, id) == 0)
434 return dev;
435 QLIST_FOREACH(child, &dev->child_bus, sibling) {
436 ret = qdev_find_recursive(child, id);
437 if (ret) {
438 return ret;
439 }
440 }
441 }
442 return NULL;
443}
444
Gerd Hoffmann8ffb1bc2009-07-15 13:59:25 +0200445static void qbus_list_bus(DeviceState *dev, char *dest, int len)
446{
447 BusState *child;
448 const char *sep = " ";
449 int pos = 0;
450
451 pos += snprintf(dest+pos, len-pos,"child busses at \"%s\":",
452 dev->id ? dev->id : dev->info->name);
Blue Swirl72cf2d42009-09-12 07:36:22 +0000453 QLIST_FOREACH(child, &dev->child_bus, sibling) {
Gerd Hoffmann8ffb1bc2009-07-15 13:59:25 +0200454 pos += snprintf(dest+pos, len-pos, "%s\"%s\"", sep, child->name);
455 sep = ", ";
456 }
457}
458
459static void qbus_list_dev(BusState *bus, char *dest, int len)
460{
461 DeviceState *dev;
462 const char *sep = " ";
463 int pos = 0;
464
465 pos += snprintf(dest+pos, len-pos, "devices at \"%s\":",
466 bus->name);
Blue Swirl72cf2d42009-09-12 07:36:22 +0000467 QLIST_FOREACH(dev, &bus->children, sibling) {
Gerd Hoffmann8ffb1bc2009-07-15 13:59:25 +0200468 pos += snprintf(dest+pos, len-pos, "%s\"%s\"",
469 sep, dev->info->name);
470 if (dev->id)
471 pos += snprintf(dest+pos, len-pos, "/\"%s\"", dev->id);
472 sep = ", ";
473 }
474}
475
476static BusState *qbus_find_bus(DeviceState *dev, char *elem)
477{
478 BusState *child;
479
Blue Swirl72cf2d42009-09-12 07:36:22 +0000480 QLIST_FOREACH(child, &dev->child_bus, sibling) {
Gerd Hoffmann8ffb1bc2009-07-15 13:59:25 +0200481 if (strcmp(child->name, elem) == 0) {
482 return child;
483 }
484 }
485 return NULL;
486}
487
488static DeviceState *qbus_find_dev(BusState *bus, char *elem)
489{
490 DeviceState *dev;
491
492 /*
493 * try to match in order:
494 * (1) instance id, if present
495 * (2) driver name
496 * (3) driver alias, if present
497 */
Blue Swirl72cf2d42009-09-12 07:36:22 +0000498 QLIST_FOREACH(dev, &bus->children, sibling) {
Gerd Hoffmann8ffb1bc2009-07-15 13:59:25 +0200499 if (dev->id && strcmp(dev->id, elem) == 0) {
500 return dev;
501 }
502 }
Blue Swirl72cf2d42009-09-12 07:36:22 +0000503 QLIST_FOREACH(dev, &bus->children, sibling) {
Gerd Hoffmann8ffb1bc2009-07-15 13:59:25 +0200504 if (strcmp(dev->info->name, elem) == 0) {
505 return dev;
506 }
507 }
Blue Swirl72cf2d42009-09-12 07:36:22 +0000508 QLIST_FOREACH(dev, &bus->children, sibling) {
Gerd Hoffmann8ffb1bc2009-07-15 13:59:25 +0200509 if (dev->info->alias && strcmp(dev->info->alias, elem) == 0) {
510 return dev;
511 }
512 }
513 return NULL;
514}
515
516static BusState *qbus_find(const char *path)
517{
518 DeviceState *dev;
519 BusState *bus;
520 char elem[128], msg[256];
521 int pos, len;
522
523 /* find start element */
524 if (path[0] == '/') {
525 bus = main_system_bus;
526 pos = 0;
527 } else {
528 if (sscanf(path, "%127[^/]%n", elem, &len) != 1) {
Gerd Hoffmann286c2322009-08-14 10:36:08 +0200529 qemu_error("path parse error (\"%s\")\n", path);
Gerd Hoffmann8ffb1bc2009-07-15 13:59:25 +0200530 return NULL;
531 }
532 bus = qbus_find_recursive(main_system_bus, elem, NULL);
533 if (!bus) {
Gerd Hoffmann286c2322009-08-14 10:36:08 +0200534 qemu_error("bus \"%s\" not found\n", elem);
Gerd Hoffmann8ffb1bc2009-07-15 13:59:25 +0200535 return NULL;
536 }
537 pos = len;
538 }
539
540 for (;;) {
541 if (path[pos] == '\0') {
542 /* we are done */
543 return bus;
544 }
545
546 /* find device */
547 if (sscanf(path+pos, "/%127[^/]%n", elem, &len) != 1) {
Gerd Hoffmann286c2322009-08-14 10:36:08 +0200548 qemu_error("path parse error (\"%s\" pos %d)\n", path, pos);
Gerd Hoffmann8ffb1bc2009-07-15 13:59:25 +0200549 return NULL;
550 }
551 pos += len;
552 dev = qbus_find_dev(bus, elem);
553 if (!dev) {
554 qbus_list_dev(bus, msg, sizeof(msg));
Gerd Hoffmann286c2322009-08-14 10:36:08 +0200555 qemu_error("device \"%s\" not found\n%s\n", elem, msg);
Gerd Hoffmann8ffb1bc2009-07-15 13:59:25 +0200556 return NULL;
557 }
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) {
562 case 0:
Gerd Hoffmann286c2322009-08-14 10:36:08 +0200563 qemu_error("device has no child bus (%s)\n", path);
Gerd Hoffmann8ffb1bc2009-07-15 13:59:25 +0200564 return NULL;
565 case 1:
Blue Swirl72cf2d42009-09-12 07:36:22 +0000566 return QLIST_FIRST(&dev->child_bus);
Gerd Hoffmann8ffb1bc2009-07-15 13:59:25 +0200567 default:
568 qbus_list_bus(dev, msg, sizeof(msg));
Gerd Hoffmann286c2322009-08-14 10:36:08 +0200569 qemu_error("device has multiple child busses (%s)\n%s\n",
570 path, msg);
Gerd Hoffmann8ffb1bc2009-07-15 13:59:25 +0200571 return NULL;
572 }
573 }
574
575 /* find bus */
576 if (sscanf(path+pos, "/%127[^/]%n", elem, &len) != 1) {
Gerd Hoffmann286c2322009-08-14 10:36:08 +0200577 qemu_error("path parse error (\"%s\" pos %d)\n", path, pos);
Gerd Hoffmann8ffb1bc2009-07-15 13:59:25 +0200578 return NULL;
579 }
580 pos += len;
581 bus = qbus_find_bus(dev, elem);
582 if (!bus) {
583 qbus_list_bus(dev, msg, sizeof(msg));
Gerd Hoffmann286c2322009-08-14 10:36:08 +0200584 qemu_error("child bus \"%s\" not found\n%s\n", elem, msg);
Gerd Hoffmann8ffb1bc2009-07-15 13:59:25 +0200585 return NULL;
586 }
587 }
588}
589
Gerd Hoffmanncd739fb2009-09-16 22:25:27 +0200590void qbus_create_inplace(BusState *bus, BusInfo *info,
591 DeviceState *parent, const char *name)
Paul Brook02e2da42009-05-23 00:05:19 +0100592{
Gerd Hoffmannd271de92009-07-15 13:59:24 +0200593 char *buf;
594 int i,len;
Paul Brook02e2da42009-05-23 00:05:19 +0100595
Gerd Hoffmann10c4c982009-06-30 14:12:08 +0200596 bus->info = info;
Paul Brook02e2da42009-05-23 00:05:19 +0100597 bus->parent = parent;
Gerd Hoffmannd271de92009-07-15 13:59:24 +0200598
599 if (name) {
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);
607 bus->name = buf;
608 } else {
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++)
Christoph Eggerbb87ece2009-07-30 15:28:45 +0200615 buf[i] = qemu_tolower(buf[i]);
Gerd Hoffmannd271de92009-07-15 13:59:24 +0200616 bus->name = buf;
617 }
618
Blue Swirl72cf2d42009-09-12 07:36:22 +0000619 QLIST_INIT(&bus->children);
Paul Brook02e2da42009-05-23 00:05:19 +0100620 if (parent) {
Blue Swirl72cf2d42009-09-12 07:36:22 +0000621 QLIST_INSERT_HEAD(&parent->child_bus, bus, sibling);
Gerd Hoffmannd271de92009-07-15 13:59:24 +0200622 parent->num_child_bus++;
Paul Brook02e2da42009-05-23 00:05:19 +0100623 }
Gerd Hoffmanncd739fb2009-09-16 22:25:27 +0200624
625}
626
627BusState *qbus_create(BusInfo *info, DeviceState *parent, const char *name)
628{
629 BusState *bus;
630
631 bus = qemu_mallocz(info->size);
632 bus->qdev_allocated = 1;
633 qbus_create_inplace(bus, info, parent, name);
Paul Brook02e2da42009-05-23 00:05:19 +0100634 return bus;
635}
Gerd Hoffmanncae49562009-06-05 15:53:17 +0100636
Gerd Hoffmann131ec1b2009-09-25 21:42:34 +0200637void qbus_free(BusState *bus)
638{
639 DeviceState *dev;
640
641 while ((dev = QLIST_FIRST(&bus->children)) != NULL) {
642 qdev_free(dev);
643 }
644 if (bus->parent) {
645 QLIST_REMOVE(bus, sibling);
646 bus->parent->num_child_bus--;
647 }
648 if (bus->qdev_allocated) {
649 qemu_free(bus);
650 }
651}
652
Gerd Hoffmanncae49562009-06-05 15:53:17 +0100653#define qdev_printf(fmt, ...) monitor_printf(mon, "%*s" fmt, indent, "", ## __VA_ARGS__)
654static void qbus_print(Monitor *mon, BusState *bus, int indent);
655
Gerd Hoffmannee6847d2009-07-15 13:43:31 +0200656static void qdev_print_props(Monitor *mon, DeviceState *dev, Property *props,
657 const char *prefix, int indent)
658{
659 char buf[64];
660
661 if (!props)
662 return;
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);
667 }
668 props++;
669 }
670}
671
Gerd Hoffmanncae49562009-06-05 15:53:17 +0100672static void qdev_print(Monitor *mon, DeviceState *dev, int indent)
673{
Gerd Hoffmanncae49562009-06-05 15:53:17 +0100674 BusState *child;
Gerd Hoffmannccb63de2009-07-15 13:43:34 +0200675 qdev_printf("dev: %s, id \"%s\"\n", dev->info->name,
676 dev->id ? dev->id : "");
Gerd Hoffmanncae49562009-06-05 15:53:17 +0100677 indent += 2;
678 if (dev->num_gpio_in) {
679 qdev_printf("gpio-in %d\n", dev->num_gpio_in);
680 }
681 if (dev->num_gpio_out) {
682 qdev_printf("gpio-out %d\n", dev->num_gpio_out);
683 }
Gerd Hoffmannee6847d2009-07-15 13:43:31 +0200684 qdev_print_props(mon, dev, dev->info->props, "dev", indent);
685 qdev_print_props(mon, dev, dev->parent_bus->info->props, "bus", indent);
Gerd Hoffmann10c4c982009-06-30 14:12:08 +0200686 if (dev->parent_bus->info->print_dev)
687 dev->parent_bus->info->print_dev(mon, dev, indent);
Blue Swirl72cf2d42009-09-12 07:36:22 +0000688 QLIST_FOREACH(child, &dev->child_bus, sibling) {
Gerd Hoffmanncae49562009-06-05 15:53:17 +0100689 qbus_print(mon, child, indent);
690 }
691}
692
693static void qbus_print(Monitor *mon, BusState *bus, int indent)
694{
695 struct DeviceState *dev;
696
697 qdev_printf("bus: %s\n", bus->name);
698 indent += 2;
Gerd Hoffmann10c4c982009-06-30 14:12:08 +0200699 qdev_printf("type %s\n", bus->info->name);
Blue Swirl72cf2d42009-09-12 07:36:22 +0000700 QLIST_FOREACH(dev, &bus->children, sibling) {
Gerd Hoffmanncae49562009-06-05 15:53:17 +0100701 qdev_print(mon, dev, indent);
702 }
703}
704#undef qdev_printf
705
706void do_info_qtree(Monitor *mon)
707{
708 if (main_system_bus)
709 qbus_print(mon, main_system_bus, 0);
710}
Gerd Hoffmann9316d302009-07-29 13:12:24 +0200711
Gerd Hoffmannf6c64e02009-08-03 15:03:09 +0200712void do_info_qdm(Monitor *mon)
Gerd Hoffmann9316d302009-07-29 13:12:24 +0200713{
714 DeviceInfo *info;
715 char msg[256];
716
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);
720 }
721}
Gerd Hoffmann3418bd22009-09-25 21:42:41 +0200722
723void do_device_add(Monitor *mon, const QDict *qdict)
724{
725 QemuOpts *opts;
726
727 opts = qemu_opts_parse(&qemu_device_opts,
728 qdict_get_str(qdict, "config"), "driver");
729 if (opts)
730 qdev_device_add(opts);
731}
732
733void do_device_del(Monitor *mon, const QDict *qdict)
734{
735 const char *id = qdict_get_str(qdict, "id");
736 DeviceState *dev;
737
738 dev = qdev_find_recursive(main_system_bus, id);
739 if (NULL == dev) {
740 qemu_error("Device '%s' not found\n", id);
741 return;
742 }
743 qdev_unplug(dev);
744}