blob: 17a46a7bb3ab3bf30c7db6f32f1bdcadd6b13e70 [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"
Paul Brookaae94602009-05-14 22:35:06 +010032
Gerd Hoffmann3418bd22009-09-25 21:42:41 +020033static int qdev_hotplug = 0;
34
Gerd Hoffmanncdaed7c2009-10-06 21:17:52 +020035/* This is a nasty hack to allow passing a NULL bus to qdev_create. */
Blue Swirlb9aaf7f2009-06-09 18:38:51 +000036static BusState *main_system_bus;
Paul Brook4d6ae672009-05-14 22:35:06 +010037
Gerd Hoffmann0958b4c2009-10-26 15:56:45 +010038DeviceInfo *device_info_list;
Paul Brookaae94602009-05-14 22:35:06 +010039
Gerd Hoffmann8ffb1bc2009-07-15 13:59:25 +020040static BusState *qbus_find_recursive(BusState *bus, const char *name,
41 const BusInfo *info);
42static BusState *qbus_find(const char *path);
43
Paul Brookaae94602009-05-14 22:35:06 +010044/* Register a new device type. */
Gerd Hoffmann074f2ff2009-06-10 09:41:42 +020045void qdev_register(DeviceInfo *info)
Paul Brookaae94602009-05-14 22:35:06 +010046{
Gerd Hoffmann074f2ff2009-06-10 09:41:42 +020047 assert(info->size >= sizeof(DeviceState));
Gerd Hoffmann042f84d2009-06-30 14:12:09 +020048 assert(!info->next);
Paul Brookaae94602009-05-14 22:35:06 +010049
Gerd Hoffmann042f84d2009-06-30 14:12:09 +020050 info->next = device_info_list;
51 device_info_list = info;
Paul Brookaae94602009-05-14 22:35:06 +010052}
53
Gerd Hoffmann81ebb982009-07-15 13:43:32 +020054static DeviceInfo *qdev_find_info(BusInfo *bus_info, const char *name)
55{
56 DeviceInfo *info;
57
Gerd Hoffmann3320e562009-07-15 13:43:33 +020058 /* first check device names */
Gerd Hoffmann81ebb982009-07-15 13:43:32 +020059 for (info = device_info_list; info != NULL; info = info->next) {
60 if (bus_info && info->bus_info != bus_info)
61 continue;
62 if (strcmp(info->name, name) != 0)
63 continue;
64 return info;
65 }
Gerd Hoffmann3320e562009-07-15 13:43:33 +020066
67 /* failing that check the aliases */
68 for (info = device_info_list; info != NULL; info = info->next) {
69 if (bus_info && info->bus_info != bus_info)
70 continue;
71 if (!info->alias)
72 continue;
73 if (strcmp(info->alias, name) != 0)
74 continue;
75 return info;
76 }
Gerd Hoffmann81ebb982009-07-15 13:43:32 +020077 return NULL;
78}
79
Markus Armbruster0c175422010-02-19 19:12:18 +010080static DeviceState *qdev_create_from_info(BusState *bus, DeviceInfo *info)
Paul Brookaae94602009-05-14 22:35:06 +010081{
Paul Brookaae94602009-05-14 22:35:06 +010082 DeviceState *dev;
83
Markus Armbruster0c175422010-02-19 19:12:18 +010084 assert(bus->info == info->bus_info);
Gerd Hoffmann042f84d2009-06-30 14:12:09 +020085 dev = qemu_mallocz(info->size);
86 dev->info = info;
Paul Brook02e2da42009-05-23 00:05:19 +010087 dev->parent_bus = bus;
Gerd Hoffmannee6847d2009-07-15 13:43:31 +020088 qdev_prop_set_defaults(dev, dev->info->props);
89 qdev_prop_set_defaults(dev, dev->parent_bus->info->props);
Gerd Hoffmann458fb672009-12-08 13:11:33 +010090 qdev_prop_set_globals(dev);
Blue Swirl72cf2d42009-09-12 07:36:22 +000091 QLIST_INSERT_HEAD(&bus->children, dev, sibling);
Gerd Hoffmann3418bd22009-09-25 21:42:41 +020092 if (qdev_hotplug) {
93 assert(bus->allow_hotplug);
94 dev->hotplugged = 1;
95 }
Gerd Hoffmann131ec1b2009-09-25 21:42:34 +020096 dev->state = DEV_STATE_CREATED;
Paul Brookaae94602009-05-14 22:35:06 +010097 return dev;
98}
99
Markus Armbruster0c175422010-02-19 19:12:18 +0100100/* Create a new device. This only initializes the device state structure
101 and allows properties to be set. qdev_init should be called to
102 initialize the actual device emulation. */
103DeviceState *qdev_create(BusState *bus, const char *name)
104{
105 DeviceInfo *info;
106
107 if (!bus) {
108 if (!main_system_bus) {
109 main_system_bus = qbus_create(&system_bus_info, NULL, "main-system-bus");
110 }
111 bus = main_system_bus;
112 }
113
114 info = qdev_find_info(bus->info, name);
115 if (!info) {
116 hw_error("Unknown device '%s' for bus '%s'\n", name, bus->info->name);
117 }
118
119 return qdev_create_from_info(bus, info);
120}
121
Markus Armbruster8a9662c2010-02-18 18:44:15 +0100122static void qdev_print_devinfo(DeviceInfo *info)
Gerd Hoffmann1b524b02009-07-29 13:12:23 +0200123{
Markus Armbruster8a9662c2010-02-18 18:44:15 +0100124 error_printf("name \"%s\", bus %s",
125 info->name, info->bus_info->name);
Gerd Hoffmann22f2e342009-08-03 11:26:48 +0200126 if (info->alias) {
Markus Armbruster8a9662c2010-02-18 18:44:15 +0100127 error_printf(", alias \"%s\"", info->alias);
Gerd Hoffmann22f2e342009-08-03 11:26:48 +0200128 }
129 if (info->desc) {
Markus Armbruster8a9662c2010-02-18 18:44:15 +0100130 error_printf(", desc \"%s\"", info->desc);
Gerd Hoffmann22f2e342009-08-03 11:26:48 +0200131 }
132 if (info->no_user) {
Markus Armbruster8a9662c2010-02-18 18:44:15 +0100133 error_printf(", no-user");
Gerd Hoffmann22f2e342009-08-03 11:26:48 +0200134 }
Markus Armbruster8a9662c2010-02-18 18:44:15 +0100135 error_printf("\n");
Gerd Hoffmann1b524b02009-07-29 13:12:23 +0200136}
137
Gerd Hoffmannf31d07d2009-07-31 12:25:37 +0200138static int set_property(const char *name, const char *value, void *opaque)
Gerd Hoffmann8ffb1bc2009-07-15 13:59:25 +0200139{
Gerd Hoffmannf31d07d2009-07-31 12:25:37 +0200140 DeviceState *dev = opaque;
141
142 if (strcmp(name, "driver") == 0)
143 return 0;
144 if (strcmp(name, "bus") == 0)
145 return 0;
146
Mark McLoughlin3df04ac2009-09-23 11:24:05 +0100147 if (qdev_prop_parse(dev, name, value) == -1) {
Gerd Hoffmannf31d07d2009-07-31 12:25:37 +0200148 return -1;
149 }
150 return 0;
151}
152
Markus Armbrusterff952ba2010-01-29 19:48:57 +0100153int qdev_device_help(QemuOpts *opts)
154{
155 const char *driver;
156 DeviceInfo *info;
Markus Armbruster08350cf2010-01-29 19:49:00 +0100157 Property *prop;
Markus Armbrusterff952ba2010-01-29 19:48:57 +0100158
159 driver = qemu_opt_get(opts, "driver");
160 if (driver && !strcmp(driver, "?")) {
161 for (info = device_info_list; info != NULL; info = info->next) {
Markus Armbrusterc64eafa2010-02-19 13:31:49 +0100162 if (info->no_user) {
163 continue; /* not available, don't show */
164 }
Markus Armbruster8a9662c2010-02-18 18:44:15 +0100165 qdev_print_devinfo(info);
Markus Armbrusterff952ba2010-01-29 19:48:57 +0100166 }
167 return 1;
168 }
169
Markus Armbruster08350cf2010-01-29 19:49:00 +0100170 if (!qemu_opt_get(opts, "?")) {
171 return 0;
172 }
173
174 info = qdev_find_info(NULL, driver);
175 if (!info) {
176 return 0;
177 }
178
179 for (prop = info->props; prop && prop->name; prop++) {
Markus Armbruster036f7162010-02-19 11:47:06 +0100180 /*
181 * TODO Properties without a parser are just for dirty hacks.
182 * qdev_prop_ptr is the only such PropertyInfo. It's marked
183 * for removal. This conditional should be removed along with
184 * it.
185 */
186 if (!prop->info->parse) {
187 continue; /* no way to set it, don't show */
188 }
Markus Armbruster8a9662c2010-02-18 18:44:15 +0100189 error_printf("%s.%s=%s\n", info->name, prop->name, prop->info->name);
Markus Armbruster08350cf2010-01-29 19:49:00 +0100190 }
191 return 1;
Markus Armbrusterff952ba2010-01-29 19:48:57 +0100192}
193
Gerd Hoffmannf31d07d2009-07-31 12:25:37 +0200194DeviceState *qdev_device_add(QemuOpts *opts)
195{
196 const char *driver, *path, *id;
Gerd Hoffmann8ffb1bc2009-07-15 13:59:25 +0200197 DeviceInfo *info;
198 DeviceState *qdev;
199 BusState *bus;
Gerd Hoffmann8ffb1bc2009-07-15 13:59:25 +0200200
Gerd Hoffmannf31d07d2009-07-31 12:25:37 +0200201 driver = qemu_opt_get(opts, "driver");
202 if (!driver) {
Markus Armbruster02042762010-02-19 14:17:34 +0100203 qerror_report(QERR_MISSING_PARAMETER, "driver");
Gerd Hoffmann8ffb1bc2009-07-15 13:59:25 +0200204 return NULL;
205 }
Gerd Hoffmannf31d07d2009-07-31 12:25:37 +0200206
207 /* find driver */
Gerd Hoffmann8ffb1bc2009-07-15 13:59:25 +0200208 info = qdev_find_info(NULL, driver);
Markus Armbrusterc64eafa2010-02-19 13:31:49 +0100209 if (!info || info->no_user) {
Markus Armbruster02042762010-02-19 14:17:34 +0100210 qerror_report(QERR_INVALID_PARAMETER, "driver");
211 error_printf_unless_qmp("Try with argument '?' for a list.\n");
Gerd Hoffmann8ffb1bc2009-07-15 13:59:25 +0200212 return NULL;
213 }
Gerd Hoffmann8ffb1bc2009-07-15 13:59:25 +0200214
Gerd Hoffmannf31d07d2009-07-31 12:25:37 +0200215 /* find bus */
216 path = qemu_opt_get(opts, "bus");
217 if (path != NULL) {
Gerd Hoffmann8ffb1bc2009-07-15 13:59:25 +0200218 bus = qbus_find(path);
Markus Armbrusterac8dae62010-02-19 18:09:33 +0100219 if (!bus) {
220 return NULL;
221 }
222 if (bus->info != info->bus_info) {
Markus Armbruster02042762010-02-19 14:17:34 +0100223 qerror_report(QERR_BAD_BUS_FOR_DEVICE,
224 driver, bus->info->name);
Markus Armbruster327867b2010-02-19 19:08:45 +0100225 return NULL;
226 }
Gerd Hoffmann8ffb1bc2009-07-15 13:59:25 +0200227 } else {
228 bus = qbus_find_recursive(main_system_bus, NULL, info->bus_info);
Markus Armbrusterac8dae62010-02-19 18:09:33 +0100229 if (!bus) {
Markus Armbruster02042762010-02-19 14:17:34 +0100230 qerror_report(QERR_NO_BUS_FOR_DEVICE,
231 info->name, info->bus_info->name);
Markus Armbrusterac8dae62010-02-19 18:09:33 +0100232 return NULL;
233 }
Gerd Hoffmann75570082009-08-31 14:23:58 +0200234 }
Gerd Hoffmann3418bd22009-09-25 21:42:41 +0200235 if (qdev_hotplug && !bus->allow_hotplug) {
Markus Armbruster02042762010-02-19 14:17:34 +0100236 qerror_report(QERR_BUS_NO_HOTPLUG, bus->name);
Gerd Hoffmann3418bd22009-09-25 21:42:41 +0200237 return NULL;
238 }
Gerd Hoffmann8ffb1bc2009-07-15 13:59:25 +0200239
Gerd Hoffmannf31d07d2009-07-31 12:25:37 +0200240 /* create device, set properties */
Markus Armbruster0c175422010-02-19 19:12:18 +0100241 qdev = qdev_create_from_info(bus, info);
Gerd Hoffmannf31d07d2009-07-31 12:25:37 +0200242 id = qemu_opts_id(opts);
243 if (id) {
244 qdev->id = id;
Gerd Hoffmann8ffb1bc2009-07-15 13:59:25 +0200245 }
Gerd Hoffmannf31d07d2009-07-31 12:25:37 +0200246 if (qemu_opt_foreach(opts, set_property, qdev, 1) != 0) {
247 qdev_free(qdev);
248 return NULL;
249 }
Markus Armbruster5c17ca22009-10-07 01:16:01 +0200250 if (qdev_init(qdev) < 0) {
Markus Armbruster02042762010-02-19 14:17:34 +0100251 qerror_report(QERR_DEVICE_INIT_FAILED, driver);
Gerd Hoffmann81a322d2009-08-14 10:36:05 +0200252 return NULL;
253 }
Gerd Hoffmannef80b462009-09-25 21:42:49 +0200254 qdev->opts = opts;
Gerd Hoffmann8ffb1bc2009-07-15 13:59:25 +0200255 return qdev;
256}
257
Michael S. Tsirkin7f23f812009-09-16 13:40:27 +0300258static void qdev_reset(void *opaque)
259{
260 DeviceState *dev = opaque;
261 if (dev->info->reset)
262 dev->info->reset(dev);
263}
264
Paul Brookaae94602009-05-14 22:35:06 +0100265/* Initialize a device. Device properties should be set before calling
266 this function. IRQs and MMIO regions should be connected/mapped after
Markus Armbruster18cfeb52009-10-07 01:15:56 +0200267 calling this function.
268 On failure, destroy the device and return negative value.
269 Return 0 on success. */
Gerd Hoffmann81a322d2009-08-14 10:36:05 +0200270int qdev_init(DeviceState *dev)
Paul Brookaae94602009-05-14 22:35:06 +0100271{
Gerd Hoffmann959f7332009-09-01 09:56:12 +0200272 int rc;
273
Gerd Hoffmann131ec1b2009-09-25 21:42:34 +0200274 assert(dev->state == DEV_STATE_CREATED);
Gerd Hoffmann959f7332009-09-01 09:56:12 +0200275 rc = dev->info->init(dev, dev->info);
Markus Armbruster18cfeb52009-10-07 01:15:56 +0200276 if (rc < 0) {
277 qdev_free(dev);
Gerd Hoffmann959f7332009-09-01 09:56:12 +0200278 return rc;
Markus Armbruster18cfeb52009-10-07 01:15:56 +0200279 }
Michael S. Tsirkin7f23f812009-09-16 13:40:27 +0300280 qemu_register_reset(qdev_reset, dev);
Gerd Hoffmann391a0792009-09-01 09:56:14 +0200281 if (dev->info->vmsd)
282 vmstate_register(-1, dev->info->vmsd, dev);
Gerd Hoffmann131ec1b2009-09-25 21:42:34 +0200283 dev->state = DEV_STATE_INITIALIZED;
Gerd Hoffmann959f7332009-09-01 09:56:12 +0200284 return 0;
Paul Brook02e2da42009-05-23 00:05:19 +0100285}
286
Gerd Hoffmann3418bd22009-09-25 21:42:41 +0200287int qdev_unplug(DeviceState *dev)
288{
289 if (!dev->parent_bus->allow_hotplug) {
Markus Armbruster1ecda022010-02-18 17:25:24 +0100290 error_report("Bus %s does not support hotplugging",
291 dev->parent_bus->name);
Gerd Hoffmann3418bd22009-09-25 21:42:41 +0200292 return -1;
293 }
Amit Shah593831d2009-11-02 14:56:41 +0530294 assert(dev->info->unplug != NULL);
295
Gerd Hoffmann3418bd22009-09-25 21:42:41 +0200296 return dev->info->unplug(dev);
297}
298
299/* can be used as ->unplug() callback for the simple cases */
300int qdev_simple_unplug_cb(DeviceState *dev)
301{
302 /* just zap it */
303 qdev_free(dev);
304 return 0;
305}
306
Markus Armbrustere23a1b32009-10-07 01:15:58 +0200307/* Like qdev_init(), but terminate program via hw_error() instead of
308 returning an error value. This is okay during machine creation.
309 Don't use for hotplug, because there callers need to recover from
310 failure. Exception: if you know the device's init() callback can't
311 fail, then qdev_init_nofail() can't fail either, and is therefore
312 usable even then. But relying on the device implementation that
313 way is somewhat unclean, and best avoided. */
314void qdev_init_nofail(DeviceState *dev)
315{
316 DeviceInfo *info = dev->info;
317
318 if (qdev_init(dev) < 0)
319 hw_error("Initialization of device %s failed\n", info->name);
320}
321
Paul Brook02e2da42009-05-23 00:05:19 +0100322/* Unlink device from bus and free the structure. */
323void qdev_free(DeviceState *dev)
324{
Gerd Hoffmann131ec1b2009-09-25 21:42:34 +0200325 BusState *bus;
326
327 if (dev->state == DEV_STATE_INITIALIZED) {
328 while (dev->num_child_bus) {
329 bus = QLIST_FIRST(&dev->child_bus);
330 qbus_free(bus);
331 }
Gerd Hoffmann131ec1b2009-09-25 21:42:34 +0200332 if (dev->info->vmsd)
333 vmstate_unregister(dev->info->vmsd, dev);
Gerd Hoffmannd29275f2009-09-25 21:42:35 +0200334 if (dev->info->exit)
335 dev->info->exit(dev);
Gerd Hoffmannef80b462009-09-25 21:42:49 +0200336 if (dev->opts)
337 qemu_opts_del(dev->opts);
Gerd Hoffmann131ec1b2009-09-25 21:42:34 +0200338 }
Michael S. Tsirkin7f23f812009-09-16 13:40:27 +0300339 qemu_unregister_reset(qdev_reset, dev);
Blue Swirl72cf2d42009-09-12 07:36:22 +0000340 QLIST_REMOVE(dev, sibling);
Gerd Hoffmannccb63de2009-07-15 13:43:34 +0200341 qemu_free(dev);
Paul Brookaae94602009-05-14 22:35:06 +0100342}
343
Gerd Hoffmann3418bd22009-09-25 21:42:41 +0200344void qdev_machine_creation_done(void)
345{
346 /*
347 * ok, initial machine setup is done, starting from now we can
348 * only create hotpluggable devices
349 */
350 qdev_hotplug = 1;
351}
352
Paul Brookaae94602009-05-14 22:35:06 +0100353/* Get a character (serial) device interface. */
354CharDriverState *qdev_init_chardev(DeviceState *dev)
355{
356 static int next_serial;
Amit Shah98b19252010-01-20 00:36:52 +0530357
358 /* FIXME: This function needs to go away: use chardev properties! */
359 return serial_hds[next_serial++];
Paul Brookaae94602009-05-14 22:35:06 +0100360}
361
Paul Brook02e2da42009-05-23 00:05:19 +0100362BusState *qdev_get_parent_bus(DeviceState *dev)
Paul Brookaae94602009-05-14 22:35:06 +0100363{
Paul Brook02e2da42009-05-23 00:05:19 +0100364 return dev->parent_bus;
Paul Brookaae94602009-05-14 22:35:06 +0100365}
366
Paul Brookaae94602009-05-14 22:35:06 +0100367void qdev_init_gpio_in(DeviceState *dev, qemu_irq_handler handler, int n)
368{
369 assert(dev->num_gpio_in == 0);
370 dev->num_gpio_in = n;
371 dev->gpio_in = qemu_allocate_irqs(handler, dev, n);
372}
373
374void qdev_init_gpio_out(DeviceState *dev, qemu_irq *pins, int n)
375{
376 assert(dev->num_gpio_out == 0);
377 dev->num_gpio_out = n;
378 dev->gpio_out = pins;
379}
380
381qemu_irq qdev_get_gpio_in(DeviceState *dev, int n)
382{
383 assert(n >= 0 && n < dev->num_gpio_in);
384 return dev->gpio_in[n];
385}
386
387void qdev_connect_gpio_out(DeviceState * dev, int n, qemu_irq pin)
388{
389 assert(n >= 0 && n < dev->num_gpio_out);
390 dev->gpio_out[n] = pin;
391}
392
Gerd Hoffmanned16ab52009-10-21 15:25:26 +0200393void qdev_set_nic_properties(DeviceState *dev, NICInfo *nd)
394{
395 qdev_prop_set_macaddr(dev, "mac", nd->macaddr);
396 if (nd->vlan)
397 qdev_prop_set_vlan(dev, "vlan", nd->vlan);
398 if (nd->netdev)
399 qdev_prop_set_netdev(dev, "netdev", nd->netdev);
Amit Shah75422b02010-02-25 17:24:43 +0530400 if (nd->nvectors != DEV_NVECTORS_UNSPECIFIED &&
Gerd Hoffmann97b15622009-10-21 15:25:35 +0200401 qdev_prop_exists(dev, "vectors")) {
402 qdev_prop_set_uint32(dev, "vectors", nd->nvectors);
403 }
Gerd Hoffmanned16ab52009-10-21 15:25:26 +0200404}
405
Paul Brookaae94602009-05-14 22:35:06 +0100406static int next_block_unit[IF_COUNT];
407
408/* Get a block device. This should only be used for single-drive devices
409 (e.g. SD/Floppy/MTD). Multi-disk devices (scsi/ide) should use the
410 appropriate bus. */
411BlockDriverState *qdev_init_bdrv(DeviceState *dev, BlockInterfaceType type)
412{
413 int unit = next_block_unit[type]++;
Gerd Hoffmann751c6a12009-07-22 16:42:57 +0200414 DriveInfo *dinfo;
Paul Brookaae94602009-05-14 22:35:06 +0100415
Gerd Hoffmann751c6a12009-07-22 16:42:57 +0200416 dinfo = drive_get(type, 0, unit);
417 return dinfo ? dinfo->bdrv : NULL;
Paul Brookaae94602009-05-14 22:35:06 +0100418}
Paul Brook4d6ae672009-05-14 22:35:06 +0100419
Paul Brook02e2da42009-05-23 00:05:19 +0100420BusState *qdev_get_child_bus(DeviceState *dev, const char *name)
Paul Brook4d6ae672009-05-14 22:35:06 +0100421{
Paul Brook02e2da42009-05-23 00:05:19 +0100422 BusState *bus;
Paul Brook4d6ae672009-05-14 22:35:06 +0100423
Blue Swirl72cf2d42009-09-12 07:36:22 +0000424 QLIST_FOREACH(bus, &dev->child_bus, sibling) {
Paul Brook4d6ae672009-05-14 22:35:06 +0100425 if (strcmp(name, bus->name) == 0) {
Paul Brook02e2da42009-05-23 00:05:19 +0100426 return bus;
Paul Brook4d6ae672009-05-14 22:35:06 +0100427 }
428 }
429 return NULL;
430}
431
Gerd Hoffmann8ffb1bc2009-07-15 13:59:25 +0200432static BusState *qbus_find_recursive(BusState *bus, const char *name,
433 const BusInfo *info)
434{
435 DeviceState *dev;
436 BusState *child, *ret;
437 int match = 1;
438
439 if (name && (strcmp(bus->name, name) != 0)) {
440 match = 0;
441 }
442 if (info && (bus->info != info)) {
443 match = 0;
444 }
445 if (match) {
446 return bus;
447 }
448
Blue Swirl72cf2d42009-09-12 07:36:22 +0000449 QLIST_FOREACH(dev, &bus->children, sibling) {
450 QLIST_FOREACH(child, &dev->child_bus, sibling) {
Gerd Hoffmann8ffb1bc2009-07-15 13:59:25 +0200451 ret = qbus_find_recursive(child, name, info);
452 if (ret) {
453 return ret;
454 }
455 }
456 }
457 return NULL;
458}
459
Gerd Hoffmann3418bd22009-09-25 21:42:41 +0200460static DeviceState *qdev_find_recursive(BusState *bus, const char *id)
461{
462 DeviceState *dev, *ret;
463 BusState *child;
464
465 QLIST_FOREACH(dev, &bus->children, sibling) {
466 if (dev->id && strcmp(dev->id, id) == 0)
467 return dev;
468 QLIST_FOREACH(child, &dev->child_bus, sibling) {
469 ret = qdev_find_recursive(child, id);
470 if (ret) {
471 return ret;
472 }
473 }
474 }
475 return NULL;
476}
477
Markus Armbruster53db16b2010-02-18 18:55:59 +0100478static void qbus_list_bus(DeviceState *dev)
Gerd Hoffmann8ffb1bc2009-07-15 13:59:25 +0200479{
480 BusState *child;
481 const char *sep = " ";
Gerd Hoffmann8ffb1bc2009-07-15 13:59:25 +0200482
Markus Armbruster53db16b2010-02-18 18:55:59 +0100483 error_printf("child busses at \"%s\":",
484 dev->id ? dev->id : dev->info->name);
Blue Swirl72cf2d42009-09-12 07:36:22 +0000485 QLIST_FOREACH(child, &dev->child_bus, sibling) {
Markus Armbruster53db16b2010-02-18 18:55:59 +0100486 error_printf("%s\"%s\"", sep, child->name);
Gerd Hoffmann8ffb1bc2009-07-15 13:59:25 +0200487 sep = ", ";
488 }
Markus Armbruster53db16b2010-02-18 18:55:59 +0100489 error_printf("\n");
Gerd Hoffmann8ffb1bc2009-07-15 13:59:25 +0200490}
491
Markus Armbruster53db16b2010-02-18 18:55:59 +0100492static void qbus_list_dev(BusState *bus)
Gerd Hoffmann8ffb1bc2009-07-15 13:59:25 +0200493{
494 DeviceState *dev;
495 const char *sep = " ";
Gerd Hoffmann8ffb1bc2009-07-15 13:59:25 +0200496
Markus Armbruster53db16b2010-02-18 18:55:59 +0100497 error_printf("devices at \"%s\":", bus->name);
Blue Swirl72cf2d42009-09-12 07:36:22 +0000498 QLIST_FOREACH(dev, &bus->children, sibling) {
Markus Armbruster53db16b2010-02-18 18:55:59 +0100499 error_printf("%s\"%s\"", sep, dev->info->name);
Gerd Hoffmann8ffb1bc2009-07-15 13:59:25 +0200500 if (dev->id)
Markus Armbruster53db16b2010-02-18 18:55:59 +0100501 error_printf("/\"%s\"", dev->id);
Gerd Hoffmann8ffb1bc2009-07-15 13:59:25 +0200502 sep = ", ";
503 }
Markus Armbruster53db16b2010-02-18 18:55:59 +0100504 error_printf("\n");
Gerd Hoffmann8ffb1bc2009-07-15 13:59:25 +0200505}
506
507static BusState *qbus_find_bus(DeviceState *dev, char *elem)
508{
509 BusState *child;
510
Blue Swirl72cf2d42009-09-12 07:36:22 +0000511 QLIST_FOREACH(child, &dev->child_bus, sibling) {
Gerd Hoffmann8ffb1bc2009-07-15 13:59:25 +0200512 if (strcmp(child->name, elem) == 0) {
513 return child;
514 }
515 }
516 return NULL;
517}
518
519static DeviceState *qbus_find_dev(BusState *bus, char *elem)
520{
521 DeviceState *dev;
522
523 /*
524 * try to match in order:
525 * (1) instance id, if present
526 * (2) driver name
527 * (3) driver alias, if present
528 */
Blue Swirl72cf2d42009-09-12 07:36:22 +0000529 QLIST_FOREACH(dev, &bus->children, sibling) {
Gerd Hoffmann8ffb1bc2009-07-15 13:59:25 +0200530 if (dev->id && strcmp(dev->id, elem) == 0) {
531 return dev;
532 }
533 }
Blue Swirl72cf2d42009-09-12 07:36:22 +0000534 QLIST_FOREACH(dev, &bus->children, sibling) {
Gerd Hoffmann8ffb1bc2009-07-15 13:59:25 +0200535 if (strcmp(dev->info->name, elem) == 0) {
536 return dev;
537 }
538 }
Blue Swirl72cf2d42009-09-12 07:36:22 +0000539 QLIST_FOREACH(dev, &bus->children, sibling) {
Gerd Hoffmann8ffb1bc2009-07-15 13:59:25 +0200540 if (dev->info->alias && strcmp(dev->info->alias, elem) == 0) {
541 return dev;
542 }
543 }
544 return NULL;
545}
546
547static BusState *qbus_find(const char *path)
548{
549 DeviceState *dev;
550 BusState *bus;
Markus Armbruster53db16b2010-02-18 18:55:59 +0100551 char elem[128];
Gerd Hoffmann8ffb1bc2009-07-15 13:59:25 +0200552 int pos, len;
553
554 /* find start element */
555 if (path[0] == '/') {
556 bus = main_system_bus;
557 pos = 0;
558 } else {
559 if (sscanf(path, "%127[^/]%n", elem, &len) != 1) {
Markus Armbrusterfc98eb42010-02-19 16:09:25 +0100560 assert(!path[0]);
561 elem[0] = len = 0;
Gerd Hoffmann8ffb1bc2009-07-15 13:59:25 +0200562 }
563 bus = qbus_find_recursive(main_system_bus, elem, NULL);
564 if (!bus) {
Markus Armbrusterac8dae62010-02-19 18:09:33 +0100565 qerror_report(QERR_BUS_NOT_FOUND, elem);
Gerd Hoffmann8ffb1bc2009-07-15 13:59:25 +0200566 return NULL;
567 }
568 pos = len;
569 }
570
571 for (;;) {
Markus Armbrusterfc98eb42010-02-19 16:09:25 +0100572 assert(path[pos] == '/' || !path[pos]);
573 while (path[pos] == '/') {
574 pos++;
575 }
Gerd Hoffmann8ffb1bc2009-07-15 13:59:25 +0200576 if (path[pos] == '\0') {
Gerd Hoffmann8ffb1bc2009-07-15 13:59:25 +0200577 return bus;
578 }
579
580 /* find device */
Markus Armbrusterfc98eb42010-02-19 16:09:25 +0100581 if (sscanf(path+pos, "%127[^/]%n", elem, &len) != 1) {
582 assert(0);
583 elem[0] = len = 0;
Gerd Hoffmann8ffb1bc2009-07-15 13:59:25 +0200584 }
585 pos += len;
586 dev = qbus_find_dev(bus, elem);
587 if (!dev) {
Markus Armbrusterac8dae62010-02-19 18:09:33 +0100588 qerror_report(QERR_DEVICE_NOT_FOUND, elem);
Markus Armbruster8bc27242010-02-10 20:52:01 +0100589 if (!monitor_cur_is_qmp()) {
590 qbus_list_dev(bus);
591 }
Gerd Hoffmann8ffb1bc2009-07-15 13:59:25 +0200592 return NULL;
593 }
Markus Armbrusterfc98eb42010-02-19 16:09:25 +0100594
595 assert(path[pos] == '/' || !path[pos]);
596 while (path[pos] == '/') {
597 pos++;
598 }
Gerd Hoffmann8ffb1bc2009-07-15 13:59:25 +0200599 if (path[pos] == '\0') {
600 /* last specified element is a device. If it has exactly
601 * one child bus accept it nevertheless */
602 switch (dev->num_child_bus) {
603 case 0:
Markus Armbrusterac8dae62010-02-19 18:09:33 +0100604 qerror_report(QERR_DEVICE_NO_BUS, elem);
Gerd Hoffmann8ffb1bc2009-07-15 13:59:25 +0200605 return NULL;
606 case 1:
Blue Swirl72cf2d42009-09-12 07:36:22 +0000607 return QLIST_FIRST(&dev->child_bus);
Gerd Hoffmann8ffb1bc2009-07-15 13:59:25 +0200608 default:
Markus Armbrusterac8dae62010-02-19 18:09:33 +0100609 qerror_report(QERR_DEVICE_MULTIPLE_BUSSES, elem);
Markus Armbruster8bc27242010-02-10 20:52:01 +0100610 if (!monitor_cur_is_qmp()) {
611 qbus_list_bus(dev);
612 }
Gerd Hoffmann8ffb1bc2009-07-15 13:59:25 +0200613 return NULL;
614 }
615 }
616
617 /* find bus */
Markus Armbrusterfc98eb42010-02-19 16:09:25 +0100618 if (sscanf(path+pos, "%127[^/]%n", elem, &len) != 1) {
619 assert(0);
620 elem[0] = len = 0;
Gerd Hoffmann8ffb1bc2009-07-15 13:59:25 +0200621 }
622 pos += len;
623 bus = qbus_find_bus(dev, elem);
624 if (!bus) {
Markus Armbrusterac8dae62010-02-19 18:09:33 +0100625 qerror_report(QERR_BUS_NOT_FOUND, elem);
Markus Armbruster8bc27242010-02-10 20:52:01 +0100626 if (!monitor_cur_is_qmp()) {
627 qbus_list_bus(dev);
628 }
Gerd Hoffmann8ffb1bc2009-07-15 13:59:25 +0200629 return NULL;
630 }
631 }
632}
633
Gerd Hoffmanncd739fb2009-09-16 22:25:27 +0200634void qbus_create_inplace(BusState *bus, BusInfo *info,
635 DeviceState *parent, const char *name)
Paul Brook02e2da42009-05-23 00:05:19 +0100636{
Gerd Hoffmannd271de92009-07-15 13:59:24 +0200637 char *buf;
638 int i,len;
Paul Brook02e2da42009-05-23 00:05:19 +0100639
Gerd Hoffmann10c4c982009-06-30 14:12:08 +0200640 bus->info = info;
Paul Brook02e2da42009-05-23 00:05:19 +0100641 bus->parent = parent;
Gerd Hoffmannd271de92009-07-15 13:59:24 +0200642
643 if (name) {
644 /* use supplied name */
645 bus->name = qemu_strdup(name);
646 } else if (parent && parent->id) {
647 /* parent device has id -> use it for bus name */
648 len = strlen(parent->id) + 16;
649 buf = qemu_malloc(len);
650 snprintf(buf, len, "%s.%d", parent->id, parent->num_child_bus);
651 bus->name = buf;
652 } else {
653 /* no id -> use lowercase bus type for bus name */
654 len = strlen(info->name) + 16;
655 buf = qemu_malloc(len);
656 len = snprintf(buf, len, "%s.%d", info->name,
657 parent ? parent->num_child_bus : 0);
658 for (i = 0; i < len; i++)
Christoph Eggerbb87ece2009-07-30 15:28:45 +0200659 buf[i] = qemu_tolower(buf[i]);
Gerd Hoffmannd271de92009-07-15 13:59:24 +0200660 bus->name = buf;
661 }
662
Blue Swirl72cf2d42009-09-12 07:36:22 +0000663 QLIST_INIT(&bus->children);
Paul Brook02e2da42009-05-23 00:05:19 +0100664 if (parent) {
Blue Swirl72cf2d42009-09-12 07:36:22 +0000665 QLIST_INSERT_HEAD(&parent->child_bus, bus, sibling);
Gerd Hoffmannd271de92009-07-15 13:59:24 +0200666 parent->num_child_bus++;
Paul Brook02e2da42009-05-23 00:05:19 +0100667 }
Gerd Hoffmanncd739fb2009-09-16 22:25:27 +0200668
669}
670
671BusState *qbus_create(BusInfo *info, DeviceState *parent, const char *name)
672{
673 BusState *bus;
674
675 bus = qemu_mallocz(info->size);
676 bus->qdev_allocated = 1;
677 qbus_create_inplace(bus, info, parent, name);
Paul Brook02e2da42009-05-23 00:05:19 +0100678 return bus;
679}
Gerd Hoffmanncae49562009-06-05 15:53:17 +0100680
Gerd Hoffmann131ec1b2009-09-25 21:42:34 +0200681void qbus_free(BusState *bus)
682{
683 DeviceState *dev;
684
685 while ((dev = QLIST_FIRST(&bus->children)) != NULL) {
686 qdev_free(dev);
687 }
688 if (bus->parent) {
689 QLIST_REMOVE(bus, sibling);
690 bus->parent->num_child_bus--;
691 }
692 if (bus->qdev_allocated) {
693 qemu_free(bus);
694 }
695}
696
Gerd Hoffmanncae49562009-06-05 15:53:17 +0100697#define qdev_printf(fmt, ...) monitor_printf(mon, "%*s" fmt, indent, "", ## __VA_ARGS__)
698static void qbus_print(Monitor *mon, BusState *bus, int indent);
699
Gerd Hoffmannee6847d2009-07-15 13:43:31 +0200700static void qdev_print_props(Monitor *mon, DeviceState *dev, Property *props,
701 const char *prefix, int indent)
702{
703 char buf[64];
704
705 if (!props)
706 return;
707 while (props->name) {
Markus Armbruster036f7162010-02-19 11:47:06 +0100708 /*
709 * TODO Properties without a print method are just for dirty
710 * hacks. qdev_prop_ptr is the only such PropertyInfo. It's
711 * marked for removal. The test props->info->print should be
712 * removed along with it.
713 */
Gerd Hoffmannee6847d2009-07-15 13:43:31 +0200714 if (props->info->print) {
715 props->info->print(dev, props, buf, sizeof(buf));
716 qdev_printf("%s-prop: %s = %s\n", prefix, props->name, buf);
717 }
718 props++;
719 }
720}
721
Gerd Hoffmanncae49562009-06-05 15:53:17 +0100722static void qdev_print(Monitor *mon, DeviceState *dev, int indent)
723{
Gerd Hoffmanncae49562009-06-05 15:53:17 +0100724 BusState *child;
Gerd Hoffmannccb63de2009-07-15 13:43:34 +0200725 qdev_printf("dev: %s, id \"%s\"\n", dev->info->name,
726 dev->id ? dev->id : "");
Gerd Hoffmanncae49562009-06-05 15:53:17 +0100727 indent += 2;
728 if (dev->num_gpio_in) {
729 qdev_printf("gpio-in %d\n", dev->num_gpio_in);
730 }
731 if (dev->num_gpio_out) {
732 qdev_printf("gpio-out %d\n", dev->num_gpio_out);
733 }
Gerd Hoffmannee6847d2009-07-15 13:43:31 +0200734 qdev_print_props(mon, dev, dev->info->props, "dev", indent);
735 qdev_print_props(mon, dev, dev->parent_bus->info->props, "bus", indent);
Gerd Hoffmann10c4c982009-06-30 14:12:08 +0200736 if (dev->parent_bus->info->print_dev)
737 dev->parent_bus->info->print_dev(mon, dev, indent);
Blue Swirl72cf2d42009-09-12 07:36:22 +0000738 QLIST_FOREACH(child, &dev->child_bus, sibling) {
Gerd Hoffmanncae49562009-06-05 15:53:17 +0100739 qbus_print(mon, child, indent);
740 }
741}
742
743static void qbus_print(Monitor *mon, BusState *bus, int indent)
744{
745 struct DeviceState *dev;
746
747 qdev_printf("bus: %s\n", bus->name);
748 indent += 2;
Gerd Hoffmann10c4c982009-06-30 14:12:08 +0200749 qdev_printf("type %s\n", bus->info->name);
Blue Swirl72cf2d42009-09-12 07:36:22 +0000750 QLIST_FOREACH(dev, &bus->children, sibling) {
Gerd Hoffmanncae49562009-06-05 15:53:17 +0100751 qdev_print(mon, dev, indent);
752 }
753}
754#undef qdev_printf
755
756void do_info_qtree(Monitor *mon)
757{
758 if (main_system_bus)
759 qbus_print(mon, main_system_bus, 0);
760}
Gerd Hoffmann9316d302009-07-29 13:12:24 +0200761
Gerd Hoffmannf6c64e02009-08-03 15:03:09 +0200762void do_info_qdm(Monitor *mon)
Gerd Hoffmann9316d302009-07-29 13:12:24 +0200763{
764 DeviceInfo *info;
Gerd Hoffmann9316d302009-07-29 13:12:24 +0200765
766 for (info = device_info_list; info != NULL; info = info->next) {
Markus Armbruster8a9662c2010-02-18 18:44:15 +0100767 qdev_print_devinfo(info);
Gerd Hoffmann9316d302009-07-29 13:12:24 +0200768 }
769}
Gerd Hoffmann3418bd22009-09-25 21:42:41 +0200770
Markus Armbruster8bc27242010-02-10 20:52:01 +0100771/**
772 * do_device_add(): Add a device
773 *
774 * Argument qdict contains
775 * - "driver": the name of the new device's driver
776 * - "bus": the device's parent bus (device tree path)
777 * - "id": the device's ID (must be unique)
778 * - device properties
779 *
780 * Example:
781 *
782 * { "driver": "usb-net", "id": "eth1", "netdev": "netdev1" }
783 */
784int do_device_add(Monitor *mon, const QDict *qdict, QObject **ret_data)
Gerd Hoffmann3418bd22009-09-25 21:42:41 +0200785{
786 QemuOpts *opts;
787
Markus Armbrusterc7e4e8c2010-02-10 20:47:28 +0100788 opts = qemu_opts_from_qdict(&qemu_device_opts, qdict);
Markus Armbruster8bc27242010-02-10 20:52:01 +0100789 if (!opts) {
790 return -1;
Kevin Wolf0f853a32010-02-16 13:12:38 +0100791 }
Markus Armbruster8bc27242010-02-10 20:52:01 +0100792 if (!monitor_cur_is_qmp() && qdev_device_help(opts)) {
793 qemu_opts_del(opts);
794 return 0;
795 }
796 if (!qdev_device_add(opts)) {
797 qemu_opts_del(opts);
798 return -1;
799 }
800 return 0;
Gerd Hoffmann3418bd22009-09-25 21:42:41 +0200801}
802
803void do_device_del(Monitor *mon, const QDict *qdict)
804{
805 const char *id = qdict_get_str(qdict, "id");
806 DeviceState *dev;
807
808 dev = qdev_find_recursive(main_system_bus, id);
809 if (NULL == dev) {
Markus Armbruster1ecda022010-02-18 17:25:24 +0100810 error_report("Device '%s' not found", id);
Gerd Hoffmann3418bd22009-09-25 21:42:41 +0200811 return;
812 }
813 qdev_unplug(dev);
814}