]>
Commit | Line | Data |
---|---|---|
aae9460e PB |
1 | /* |
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 | |
8167ee88 | 17 | * License along with this library; if not, see <http://www.gnu.org/licenses/>. |
aae9460e PB |
18 | */ |
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 | ||
9d07d757 | 28 | #include "net.h" |
aae9460e PB |
29 | #include "qdev.h" |
30 | #include "sysemu.h" | |
cae4956e | 31 | #include "monitor.h" |
aae9460e | 32 | |
3418bd25 | 33 | static int qdev_hotplug = 0; |
0ac8ef71 AW |
34 | static bool qdev_hot_added = false; |
35 | static bool qdev_hot_removed = false; | |
3418bd25 | 36 | |
cdaed7c7 | 37 | /* This is a nasty hack to allow passing a NULL bus to qdev_create. */ |
b9aaf7f8 | 38 | static BusState *main_system_bus; |
4d6ae674 | 39 | |
0958b4cc | 40 | DeviceInfo *device_info_list; |
aae9460e | 41 | |
8ffb1bcf GH |
42 | static BusState *qbus_find_recursive(BusState *bus, const char *name, |
43 | const BusInfo *info); | |
44 | static BusState *qbus_find(const char *path); | |
45 | ||
aae9460e | 46 | /* Register a new device type. */ |
074f2fff | 47 | void qdev_register(DeviceInfo *info) |
aae9460e | 48 | { |
074f2fff | 49 | assert(info->size >= sizeof(DeviceState)); |
042f84d0 | 50 | assert(!info->next); |
aae9460e | 51 | |
042f84d0 GH |
52 | info->next = device_info_list; |
53 | device_info_list = info; | |
aae9460e PB |
54 | } |
55 | ||
81ebb98b GH |
56 | static DeviceInfo *qdev_find_info(BusInfo *bus_info, const char *name) |
57 | { | |
58 | DeviceInfo *info; | |
59 | ||
3320e56e | 60 | /* first check device names */ |
81ebb98b GH |
61 | for (info = device_info_list; info != NULL; info = info->next) { |
62 | if (bus_info && info->bus_info != bus_info) | |
63 | continue; | |
64 | if (strcmp(info->name, name) != 0) | |
65 | continue; | |
66 | return info; | |
67 | } | |
3320e56e GH |
68 | |
69 | /* failing that check the aliases */ | |
70 | for (info = device_info_list; info != NULL; info = info->next) { | |
71 | if (bus_info && info->bus_info != bus_info) | |
72 | continue; | |
73 | if (!info->alias) | |
74 | continue; | |
75 | if (strcmp(info->alias, name) != 0) | |
76 | continue; | |
77 | return info; | |
78 | } | |
81ebb98b GH |
79 | return NULL; |
80 | } | |
81 | ||
0c17542d MA |
82 | static DeviceState *qdev_create_from_info(BusState *bus, DeviceInfo *info) |
83 | { | |
84 | DeviceState *dev; | |
85 | ||
86 | assert(bus->info == info->bus_info); | |
87 | dev = qemu_mallocz(info->size); | |
88 | dev->info = info; | |
89 | dev->parent_bus = bus; | |
90 | qdev_prop_set_defaults(dev, dev->info->props); | |
91 | qdev_prop_set_defaults(dev, dev->parent_bus->info->props); | |
92 | qdev_prop_set_globals(dev); | |
93 | QLIST_INSERT_HEAD(&bus->children, dev, sibling); | |
94 | if (qdev_hotplug) { | |
95 | assert(bus->allow_hotplug); | |
96 | dev->hotplugged = 1; | |
0ac8ef71 | 97 | qdev_hot_added = true; |
0c17542d | 98 | } |
4d2ffa08 | 99 | dev->instance_id_alias = -1; |
0c17542d MA |
100 | dev->state = DEV_STATE_CREATED; |
101 | return dev; | |
102 | } | |
103 | ||
aae9460e PB |
104 | /* Create a new device. This only initializes the device state structure |
105 | and allows properties to be set. qdev_init should be called to | |
106 | initialize the actual device emulation. */ | |
02e2da45 | 107 | DeviceState *qdev_create(BusState *bus, const char *name) |
0bcdeda7 BS |
108 | { |
109 | DeviceState *dev; | |
110 | ||
111 | dev = qdev_try_create(bus, name); | |
112 | if (!dev) { | |
113 | hw_error("Unknown device '%s' for bus '%s'\n", name, bus->info->name); | |
114 | } | |
115 | ||
116 | return dev; | |
117 | } | |
118 | ||
119 | DeviceState *qdev_try_create(BusState *bus, const char *name) | |
aae9460e | 120 | { |
042f84d0 | 121 | DeviceInfo *info; |
aae9460e | 122 | |
10c4c98a | 123 | if (!bus) { |
68694897 | 124 | bus = sysbus_get_default(); |
10c4c98a GH |
125 | } |
126 | ||
81ebb98b | 127 | info = qdev_find_info(bus->info, name); |
042f84d0 | 128 | if (!info) { |
0bcdeda7 | 129 | return NULL; |
aae9460e PB |
130 | } |
131 | ||
0c17542d | 132 | return qdev_create_from_info(bus, info); |
aae9460e PB |
133 | } |
134 | ||
8a9662ca | 135 | static void qdev_print_devinfo(DeviceInfo *info) |
1b524b04 | 136 | { |
8a9662ca MA |
137 | error_printf("name \"%s\", bus %s", |
138 | info->name, info->bus_info->name); | |
22f2e344 | 139 | if (info->alias) { |
8a9662ca | 140 | error_printf(", alias \"%s\"", info->alias); |
22f2e344 GH |
141 | } |
142 | if (info->desc) { | |
8a9662ca | 143 | error_printf(", desc \"%s\"", info->desc); |
22f2e344 GH |
144 | } |
145 | if (info->no_user) { | |
8a9662ca | 146 | error_printf(", no-user"); |
22f2e344 | 147 | } |
8a9662ca | 148 | error_printf("\n"); |
1b524b04 GH |
149 | } |
150 | ||
f31d07d1 | 151 | static int set_property(const char *name, const char *value, void *opaque) |
8ffb1bcf | 152 | { |
f31d07d1 GH |
153 | DeviceState *dev = opaque; |
154 | ||
155 | if (strcmp(name, "driver") == 0) | |
156 | return 0; | |
157 | if (strcmp(name, "bus") == 0) | |
158 | return 0; | |
159 | ||
3df04ac3 | 160 | if (qdev_prop_parse(dev, name, value) == -1) { |
f31d07d1 GH |
161 | return -1; |
162 | } | |
163 | return 0; | |
164 | } | |
165 | ||
ff952ba2 MA |
166 | int qdev_device_help(QemuOpts *opts) |
167 | { | |
168 | const char *driver; | |
169 | DeviceInfo *info; | |
08350cf0 | 170 | Property *prop; |
ff952ba2 MA |
171 | |
172 | driver = qemu_opt_get(opts, "driver"); | |
173 | if (driver && !strcmp(driver, "?")) { | |
174 | for (info = device_info_list; info != NULL; info = info->next) { | |
c64eafaf MA |
175 | if (info->no_user) { |
176 | continue; /* not available, don't show */ | |
177 | } | |
8a9662ca | 178 | qdev_print_devinfo(info); |
ff952ba2 MA |
179 | } |
180 | return 1; | |
181 | } | |
182 | ||
08350cf0 MA |
183 | if (!qemu_opt_get(opts, "?")) { |
184 | return 0; | |
185 | } | |
186 | ||
187 | info = qdev_find_info(NULL, driver); | |
188 | if (!info) { | |
189 | return 0; | |
190 | } | |
191 | ||
192 | for (prop = info->props; prop && prop->name; prop++) { | |
036f7166 MA |
193 | /* |
194 | * TODO Properties without a parser are just for dirty hacks. | |
195 | * qdev_prop_ptr is the only such PropertyInfo. It's marked | |
196 | * for removal. This conditional should be removed along with | |
197 | * it. | |
198 | */ | |
199 | if (!prop->info->parse) { | |
200 | continue; /* no way to set it, don't show */ | |
201 | } | |
8a9662ca | 202 | error_printf("%s.%s=%s\n", info->name, prop->name, prop->info->name); |
08350cf0 MA |
203 | } |
204 | return 1; | |
ff952ba2 MA |
205 | } |
206 | ||
f31d07d1 GH |
207 | DeviceState *qdev_device_add(QemuOpts *opts) |
208 | { | |
209 | const char *driver, *path, *id; | |
8ffb1bcf GH |
210 | DeviceInfo *info; |
211 | DeviceState *qdev; | |
212 | BusState *bus; | |
8ffb1bcf | 213 | |
f31d07d1 GH |
214 | driver = qemu_opt_get(opts, "driver"); |
215 | if (!driver) { | |
0204276b | 216 | qerror_report(QERR_MISSING_PARAMETER, "driver"); |
8ffb1bcf GH |
217 | return NULL; |
218 | } | |
f31d07d1 GH |
219 | |
220 | /* find driver */ | |
8ffb1bcf | 221 | info = qdev_find_info(NULL, driver); |
c64eafaf | 222 | if (!info || info->no_user) { |
e17ba87c | 223 | qerror_report(QERR_INVALID_PARAMETER_VALUE, "driver", "a driver name"); |
0204276b | 224 | error_printf_unless_qmp("Try with argument '?' for a list.\n"); |
8ffb1bcf GH |
225 | return NULL; |
226 | } | |
8ffb1bcf | 227 | |
f31d07d1 GH |
228 | /* find bus */ |
229 | path = qemu_opt_get(opts, "bus"); | |
230 | if (path != NULL) { | |
8ffb1bcf | 231 | bus = qbus_find(path); |
ac8dae67 MA |
232 | if (!bus) { |
233 | return NULL; | |
234 | } | |
235 | if (bus->info != info->bus_info) { | |
0204276b MA |
236 | qerror_report(QERR_BAD_BUS_FOR_DEVICE, |
237 | driver, bus->info->name); | |
327867b6 MA |
238 | return NULL; |
239 | } | |
8ffb1bcf GH |
240 | } else { |
241 | bus = qbus_find_recursive(main_system_bus, NULL, info->bus_info); | |
ac8dae67 | 242 | if (!bus) { |
0204276b MA |
243 | qerror_report(QERR_NO_BUS_FOR_DEVICE, |
244 | info->name, info->bus_info->name); | |
ac8dae67 MA |
245 | return NULL; |
246 | } | |
75570088 | 247 | } |
3418bd25 | 248 | if (qdev_hotplug && !bus->allow_hotplug) { |
0204276b | 249 | qerror_report(QERR_BUS_NO_HOTPLUG, bus->name); |
3418bd25 GH |
250 | return NULL; |
251 | } | |
8ffb1bcf | 252 | |
f31d07d1 | 253 | /* create device, set properties */ |
0c17542d | 254 | qdev = qdev_create_from_info(bus, info); |
f31d07d1 GH |
255 | id = qemu_opts_id(opts); |
256 | if (id) { | |
257 | qdev->id = id; | |
258 | } | |
259 | if (qemu_opt_foreach(opts, set_property, qdev, 1) != 0) { | |
260 | qdev_free(qdev); | |
261 | return NULL; | |
8ffb1bcf | 262 | } |
5c17ca25 | 263 | if (qdev_init(qdev) < 0) { |
0204276b | 264 | qerror_report(QERR_DEVICE_INIT_FAILED, driver); |
81a322d4 GH |
265 | return NULL; |
266 | } | |
ef80b466 | 267 | qdev->opts = opts; |
8ffb1bcf GH |
268 | return qdev; |
269 | } | |
270 | ||
aae9460e PB |
271 | /* Initialize a device. Device properties should be set before calling |
272 | this function. IRQs and MMIO regions should be connected/mapped after | |
18cfeb52 MA |
273 | calling this function. |
274 | On failure, destroy the device and return negative value. | |
275 | Return 0 on success. */ | |
81a322d4 | 276 | int qdev_init(DeviceState *dev) |
aae9460e | 277 | { |
959f733a GH |
278 | int rc; |
279 | ||
131ec1bd | 280 | assert(dev->state == DEV_STATE_CREATED); |
959f733a | 281 | rc = dev->info->init(dev, dev->info); |
18cfeb52 MA |
282 | if (rc < 0) { |
283 | qdev_free(dev); | |
959f733a | 284 | return rc; |
18cfeb52 | 285 | } |
4d2ffa08 | 286 | if (dev->info->vmsd) { |
0be71e32 | 287 | vmstate_register_with_alias_id(dev, -1, dev->info->vmsd, dev, |
4d2ffa08 JK |
288 | dev->instance_id_alias, |
289 | dev->alias_required_for_version); | |
290 | } | |
131ec1bd | 291 | dev->state = DEV_STATE_INITIALIZED; |
959f733a | 292 | return 0; |
02e2da45 PB |
293 | } |
294 | ||
4d2ffa08 JK |
295 | void qdev_set_legacy_instance_id(DeviceState *dev, int alias_id, |
296 | int required_for_version) | |
297 | { | |
298 | assert(dev->state == DEV_STATE_CREATED); | |
299 | dev->instance_id_alias = alias_id; | |
300 | dev->alias_required_for_version = required_for_version; | |
301 | } | |
302 | ||
3418bd25 GH |
303 | int qdev_unplug(DeviceState *dev) |
304 | { | |
305 | if (!dev->parent_bus->allow_hotplug) { | |
cc601cb7 | 306 | qerror_report(QERR_BUS_NO_HOTPLUG, dev->parent_bus->name); |
3418bd25 GH |
307 | return -1; |
308 | } | |
593831de AS |
309 | assert(dev->info->unplug != NULL); |
310 | ||
0ac8ef71 AW |
311 | qdev_hot_removed = true; |
312 | ||
3418bd25 GH |
313 | return dev->info->unplug(dev); |
314 | } | |
315 | ||
ec990eb6 AL |
316 | static int qdev_reset_one(DeviceState *dev, void *opaque) |
317 | { | |
318 | if (dev->info->reset) { | |
319 | dev->info->reset(dev); | |
320 | } | |
321 | ||
322 | return 0; | |
323 | } | |
324 | ||
325 | BusState *sysbus_get_default(void) | |
326 | { | |
68694897 SW |
327 | if (!main_system_bus) { |
328 | main_system_bus = qbus_create(&system_bus_info, NULL, | |
329 | "main-system-bus"); | |
330 | } | |
ec990eb6 AL |
331 | return main_system_bus; |
332 | } | |
333 | ||
b4694b7c IY |
334 | static int qbus_reset_one(BusState *bus, void *opaque) |
335 | { | |
336 | if (bus->info->reset) { | |
337 | return bus->info->reset(bus); | |
338 | } | |
339 | return 0; | |
340 | } | |
341 | ||
5af0a04b IY |
342 | void qdev_reset_all(DeviceState *dev) |
343 | { | |
344 | qdev_walk_children(dev, qdev_reset_one, qbus_reset_one, NULL); | |
345 | } | |
346 | ||
80376c3f IY |
347 | void qbus_reset_all_fn(void *opaque) |
348 | { | |
349 | BusState *bus = opaque; | |
f530cce3 | 350 | qbus_walk_children(bus, qdev_reset_one, qbus_reset_one, NULL); |
80376c3f IY |
351 | } |
352 | ||
3418bd25 GH |
353 | /* can be used as ->unplug() callback for the simple cases */ |
354 | int qdev_simple_unplug_cb(DeviceState *dev) | |
355 | { | |
356 | /* just zap it */ | |
357 | qdev_free(dev); | |
358 | return 0; | |
359 | } | |
360 | ||
e23a1b33 MA |
361 | /* Like qdev_init(), but terminate program via hw_error() instead of |
362 | returning an error value. This is okay during machine creation. | |
363 | Don't use for hotplug, because there callers need to recover from | |
364 | failure. Exception: if you know the device's init() callback can't | |
365 | fail, then qdev_init_nofail() can't fail either, and is therefore | |
366 | usable even then. But relying on the device implementation that | |
367 | way is somewhat unclean, and best avoided. */ | |
368 | void qdev_init_nofail(DeviceState *dev) | |
369 | { | |
370 | DeviceInfo *info = dev->info; | |
371 | ||
bd6c9a61 MA |
372 | if (qdev_init(dev) < 0) { |
373 | error_report("Initialization of device %s failed\n", info->name); | |
374 | exit(1); | |
375 | } | |
e23a1b33 MA |
376 | } |
377 | ||
02e2da45 PB |
378 | /* Unlink device from bus and free the structure. */ |
379 | void qdev_free(DeviceState *dev) | |
380 | { | |
131ec1bd | 381 | BusState *bus; |
d21357df | 382 | Property *prop; |
131ec1bd GH |
383 | |
384 | if (dev->state == DEV_STATE_INITIALIZED) { | |
385 | while (dev->num_child_bus) { | |
386 | bus = QLIST_FIRST(&dev->child_bus); | |
387 | qbus_free(bus); | |
388 | } | |
131ec1bd | 389 | if (dev->info->vmsd) |
0be71e32 | 390 | vmstate_unregister(dev, dev->info->vmsd, dev); |
d29275f1 GH |
391 | if (dev->info->exit) |
392 | dev->info->exit(dev); | |
ef80b466 GH |
393 | if (dev->opts) |
394 | qemu_opts_del(dev->opts); | |
131ec1bd | 395 | } |
72cf2d4f | 396 | QLIST_REMOVE(dev, sibling); |
d21357df MA |
397 | for (prop = dev->info->props; prop && prop->name; prop++) { |
398 | if (prop->info->free) { | |
399 | prop->info->free(dev, prop); | |
400 | } | |
401 | } | |
ccb63de3 | 402 | qemu_free(dev); |
aae9460e PB |
403 | } |
404 | ||
3418bd25 GH |
405 | void qdev_machine_creation_done(void) |
406 | { | |
407 | /* | |
408 | * ok, initial machine setup is done, starting from now we can | |
409 | * only create hotpluggable devices | |
410 | */ | |
411 | qdev_hotplug = 1; | |
412 | } | |
413 | ||
0ac8ef71 AW |
414 | bool qdev_machine_modified(void) |
415 | { | |
416 | return qdev_hot_added || qdev_hot_removed; | |
417 | } | |
418 | ||
aae9460e PB |
419 | /* Get a character (serial) device interface. */ |
420 | CharDriverState *qdev_init_chardev(DeviceState *dev) | |
421 | { | |
422 | static int next_serial; | |
98b19252 AS |
423 | |
424 | /* FIXME: This function needs to go away: use chardev properties! */ | |
425 | return serial_hds[next_serial++]; | |
aae9460e PB |
426 | } |
427 | ||
02e2da45 | 428 | BusState *qdev_get_parent_bus(DeviceState *dev) |
aae9460e | 429 | { |
02e2da45 | 430 | return dev->parent_bus; |
aae9460e PB |
431 | } |
432 | ||
aae9460e PB |
433 | void qdev_init_gpio_in(DeviceState *dev, qemu_irq_handler handler, int n) |
434 | { | |
435 | assert(dev->num_gpio_in == 0); | |
436 | dev->num_gpio_in = n; | |
437 | dev->gpio_in = qemu_allocate_irqs(handler, dev, n); | |
438 | } | |
439 | ||
440 | void qdev_init_gpio_out(DeviceState *dev, qemu_irq *pins, int n) | |
441 | { | |
442 | assert(dev->num_gpio_out == 0); | |
443 | dev->num_gpio_out = n; | |
444 | dev->gpio_out = pins; | |
445 | } | |
446 | ||
447 | qemu_irq qdev_get_gpio_in(DeviceState *dev, int n) | |
448 | { | |
449 | assert(n >= 0 && n < dev->num_gpio_in); | |
450 | return dev->gpio_in[n]; | |
451 | } | |
452 | ||
453 | void qdev_connect_gpio_out(DeviceState * dev, int n, qemu_irq pin) | |
454 | { | |
455 | assert(n >= 0 && n < dev->num_gpio_out); | |
456 | dev->gpio_out[n] = pin; | |
457 | } | |
458 | ||
ed16ab5a GH |
459 | void qdev_set_nic_properties(DeviceState *dev, NICInfo *nd) |
460 | { | |
461 | qdev_prop_set_macaddr(dev, "mac", nd->macaddr); | |
462 | if (nd->vlan) | |
463 | qdev_prop_set_vlan(dev, "vlan", nd->vlan); | |
464 | if (nd->netdev) | |
465 | qdev_prop_set_netdev(dev, "netdev", nd->netdev); | |
75422b0d | 466 | if (nd->nvectors != DEV_NVECTORS_UNSPECIFIED && |
97b15621 GH |
467 | qdev_prop_exists(dev, "vectors")) { |
468 | qdev_prop_set_uint32(dev, "vectors", nd->nvectors); | |
469 | } | |
ed16ab5a GH |
470 | } |
471 | ||
02e2da45 | 472 | BusState *qdev_get_child_bus(DeviceState *dev, const char *name) |
4d6ae674 | 473 | { |
02e2da45 | 474 | BusState *bus; |
4d6ae674 | 475 | |
72cf2d4f | 476 | QLIST_FOREACH(bus, &dev->child_bus, sibling) { |
4d6ae674 | 477 | if (strcmp(name, bus->name) == 0) { |
02e2da45 | 478 | return bus; |
4d6ae674 PB |
479 | } |
480 | } | |
481 | return NULL; | |
482 | } | |
483 | ||
81699d8a AL |
484 | int qbus_walk_children(BusState *bus, qdev_walkerfn *devfn, |
485 | qbus_walkerfn *busfn, void *opaque) | |
486 | { | |
487 | DeviceState *dev; | |
488 | int err; | |
489 | ||
490 | if (busfn) { | |
491 | err = busfn(bus, opaque); | |
492 | if (err) { | |
493 | return err; | |
494 | } | |
495 | } | |
496 | ||
497 | QLIST_FOREACH(dev, &bus->children, sibling) { | |
498 | err = qdev_walk_children(dev, devfn, busfn, opaque); | |
499 | if (err < 0) { | |
500 | return err; | |
501 | } | |
502 | } | |
503 | ||
504 | return 0; | |
505 | } | |
506 | ||
507 | int qdev_walk_children(DeviceState *dev, qdev_walkerfn *devfn, | |
508 | qbus_walkerfn *busfn, void *opaque) | |
509 | { | |
510 | BusState *bus; | |
511 | int err; | |
512 | ||
513 | if (devfn) { | |
514 | err = devfn(dev, opaque); | |
515 | if (err) { | |
516 | return err; | |
517 | } | |
518 | } | |
519 | ||
520 | QLIST_FOREACH(bus, &dev->child_bus, sibling) { | |
521 | err = qbus_walk_children(bus, devfn, busfn, opaque); | |
522 | if (err < 0) { | |
523 | return err; | |
524 | } | |
525 | } | |
526 | ||
527 | return 0; | |
528 | } | |
529 | ||
8ffb1bcf GH |
530 | static BusState *qbus_find_recursive(BusState *bus, const char *name, |
531 | const BusInfo *info) | |
532 | { | |
533 | DeviceState *dev; | |
534 | BusState *child, *ret; | |
535 | int match = 1; | |
536 | ||
537 | if (name && (strcmp(bus->name, name) != 0)) { | |
538 | match = 0; | |
539 | } | |
540 | if (info && (bus->info != info)) { | |
541 | match = 0; | |
542 | } | |
543 | if (match) { | |
544 | return bus; | |
545 | } | |
546 | ||
72cf2d4f BS |
547 | QLIST_FOREACH(dev, &bus->children, sibling) { |
548 | QLIST_FOREACH(child, &dev->child_bus, sibling) { | |
8ffb1bcf GH |
549 | ret = qbus_find_recursive(child, name, info); |
550 | if (ret) { | |
551 | return ret; | |
552 | } | |
553 | } | |
554 | } | |
555 | return NULL; | |
556 | } | |
557 | ||
a2ee6b4f | 558 | DeviceState *qdev_find_recursive(BusState *bus, const char *id) |
3418bd25 GH |
559 | { |
560 | DeviceState *dev, *ret; | |
561 | BusState *child; | |
562 | ||
563 | QLIST_FOREACH(dev, &bus->children, sibling) { | |
564 | if (dev->id && strcmp(dev->id, id) == 0) | |
565 | return dev; | |
566 | QLIST_FOREACH(child, &dev->child_bus, sibling) { | |
567 | ret = qdev_find_recursive(child, id); | |
568 | if (ret) { | |
569 | return ret; | |
570 | } | |
571 | } | |
572 | } | |
573 | return NULL; | |
574 | } | |
575 | ||
53db16b5 | 576 | static void qbus_list_bus(DeviceState *dev) |
8ffb1bcf GH |
577 | { |
578 | BusState *child; | |
579 | const char *sep = " "; | |
8ffb1bcf | 580 | |
53db16b5 MA |
581 | error_printf("child busses at \"%s\":", |
582 | dev->id ? dev->id : dev->info->name); | |
72cf2d4f | 583 | QLIST_FOREACH(child, &dev->child_bus, sibling) { |
53db16b5 | 584 | error_printf("%s\"%s\"", sep, child->name); |
8ffb1bcf GH |
585 | sep = ", "; |
586 | } | |
53db16b5 | 587 | error_printf("\n"); |
8ffb1bcf GH |
588 | } |
589 | ||
53db16b5 | 590 | static void qbus_list_dev(BusState *bus) |
8ffb1bcf GH |
591 | { |
592 | DeviceState *dev; | |
593 | const char *sep = " "; | |
8ffb1bcf | 594 | |
53db16b5 | 595 | error_printf("devices at \"%s\":", bus->name); |
72cf2d4f | 596 | QLIST_FOREACH(dev, &bus->children, sibling) { |
53db16b5 | 597 | error_printf("%s\"%s\"", sep, dev->info->name); |
8ffb1bcf | 598 | if (dev->id) |
53db16b5 | 599 | error_printf("/\"%s\"", dev->id); |
8ffb1bcf GH |
600 | sep = ", "; |
601 | } | |
53db16b5 | 602 | error_printf("\n"); |
8ffb1bcf GH |
603 | } |
604 | ||
605 | static BusState *qbus_find_bus(DeviceState *dev, char *elem) | |
606 | { | |
607 | BusState *child; | |
608 | ||
72cf2d4f | 609 | QLIST_FOREACH(child, &dev->child_bus, sibling) { |
8ffb1bcf GH |
610 | if (strcmp(child->name, elem) == 0) { |
611 | return child; | |
612 | } | |
613 | } | |
614 | return NULL; | |
615 | } | |
616 | ||
617 | static DeviceState *qbus_find_dev(BusState *bus, char *elem) | |
618 | { | |
619 | DeviceState *dev; | |
620 | ||
621 | /* | |
622 | * try to match in order: | |
623 | * (1) instance id, if present | |
624 | * (2) driver name | |
625 | * (3) driver alias, if present | |
626 | */ | |
72cf2d4f | 627 | QLIST_FOREACH(dev, &bus->children, sibling) { |
8ffb1bcf GH |
628 | if (dev->id && strcmp(dev->id, elem) == 0) { |
629 | return dev; | |
630 | } | |
631 | } | |
72cf2d4f | 632 | QLIST_FOREACH(dev, &bus->children, sibling) { |
8ffb1bcf GH |
633 | if (strcmp(dev->info->name, elem) == 0) { |
634 | return dev; | |
635 | } | |
636 | } | |
72cf2d4f | 637 | QLIST_FOREACH(dev, &bus->children, sibling) { |
8ffb1bcf GH |
638 | if (dev->info->alias && strcmp(dev->info->alias, elem) == 0) { |
639 | return dev; | |
640 | } | |
641 | } | |
642 | return NULL; | |
643 | } | |
644 | ||
645 | static BusState *qbus_find(const char *path) | |
646 | { | |
647 | DeviceState *dev; | |
648 | BusState *bus; | |
53db16b5 | 649 | char elem[128]; |
8ffb1bcf GH |
650 | int pos, len; |
651 | ||
652 | /* find start element */ | |
653 | if (path[0] == '/') { | |
654 | bus = main_system_bus; | |
655 | pos = 0; | |
656 | } else { | |
657 | if (sscanf(path, "%127[^/]%n", elem, &len) != 1) { | |
fc98eb43 MA |
658 | assert(!path[0]); |
659 | elem[0] = len = 0; | |
8ffb1bcf GH |
660 | } |
661 | bus = qbus_find_recursive(main_system_bus, elem, NULL); | |
662 | if (!bus) { | |
ac8dae67 | 663 | qerror_report(QERR_BUS_NOT_FOUND, elem); |
8ffb1bcf GH |
664 | return NULL; |
665 | } | |
666 | pos = len; | |
667 | } | |
668 | ||
669 | for (;;) { | |
fc98eb43 MA |
670 | assert(path[pos] == '/' || !path[pos]); |
671 | while (path[pos] == '/') { | |
672 | pos++; | |
673 | } | |
8ffb1bcf | 674 | if (path[pos] == '\0') { |
8ffb1bcf GH |
675 | return bus; |
676 | } | |
677 | ||
678 | /* find device */ | |
fc98eb43 MA |
679 | if (sscanf(path+pos, "%127[^/]%n", elem, &len) != 1) { |
680 | assert(0); | |
681 | elem[0] = len = 0; | |
8ffb1bcf GH |
682 | } |
683 | pos += len; | |
684 | dev = qbus_find_dev(bus, elem); | |
685 | if (!dev) { | |
ac8dae67 | 686 | qerror_report(QERR_DEVICE_NOT_FOUND, elem); |
8bc27249 MA |
687 | if (!monitor_cur_is_qmp()) { |
688 | qbus_list_dev(bus); | |
689 | } | |
8ffb1bcf GH |
690 | return NULL; |
691 | } | |
fc98eb43 MA |
692 | |
693 | assert(path[pos] == '/' || !path[pos]); | |
694 | while (path[pos] == '/') { | |
695 | pos++; | |
696 | } | |
8ffb1bcf GH |
697 | if (path[pos] == '\0') { |
698 | /* last specified element is a device. If it has exactly | |
699 | * one child bus accept it nevertheless */ | |
700 | switch (dev->num_child_bus) { | |
701 | case 0: | |
ac8dae67 | 702 | qerror_report(QERR_DEVICE_NO_BUS, elem); |
8ffb1bcf GH |
703 | return NULL; |
704 | case 1: | |
72cf2d4f | 705 | return QLIST_FIRST(&dev->child_bus); |
8ffb1bcf | 706 | default: |
ac8dae67 | 707 | qerror_report(QERR_DEVICE_MULTIPLE_BUSSES, elem); |
8bc27249 MA |
708 | if (!monitor_cur_is_qmp()) { |
709 | qbus_list_bus(dev); | |
710 | } | |
8ffb1bcf GH |
711 | return NULL; |
712 | } | |
713 | } | |
714 | ||
715 | /* find bus */ | |
fc98eb43 MA |
716 | if (sscanf(path+pos, "%127[^/]%n", elem, &len) != 1) { |
717 | assert(0); | |
718 | elem[0] = len = 0; | |
8ffb1bcf GH |
719 | } |
720 | pos += len; | |
721 | bus = qbus_find_bus(dev, elem); | |
722 | if (!bus) { | |
ac8dae67 | 723 | qerror_report(QERR_BUS_NOT_FOUND, elem); |
8bc27249 MA |
724 | if (!monitor_cur_is_qmp()) { |
725 | qbus_list_bus(dev); | |
726 | } | |
8ffb1bcf GH |
727 | return NULL; |
728 | } | |
729 | } | |
730 | } | |
731 | ||
cd739fb6 GH |
732 | void qbus_create_inplace(BusState *bus, BusInfo *info, |
733 | DeviceState *parent, const char *name) | |
02e2da45 | 734 | { |
d271de9f GH |
735 | char *buf; |
736 | int i,len; | |
02e2da45 | 737 | |
10c4c98a | 738 | bus->info = info; |
02e2da45 | 739 | bus->parent = parent; |
d271de9f GH |
740 | |
741 | if (name) { | |
742 | /* use supplied name */ | |
743 | bus->name = qemu_strdup(name); | |
744 | } else if (parent && parent->id) { | |
745 | /* parent device has id -> use it for bus name */ | |
746 | len = strlen(parent->id) + 16; | |
747 | buf = qemu_malloc(len); | |
748 | snprintf(buf, len, "%s.%d", parent->id, parent->num_child_bus); | |
749 | bus->name = buf; | |
750 | } else { | |
751 | /* no id -> use lowercase bus type for bus name */ | |
752 | len = strlen(info->name) + 16; | |
753 | buf = qemu_malloc(len); | |
754 | len = snprintf(buf, len, "%s.%d", info->name, | |
755 | parent ? parent->num_child_bus : 0); | |
756 | for (i = 0; i < len; i++) | |
bb87ece5 | 757 | buf[i] = qemu_tolower(buf[i]); |
d271de9f GH |
758 | bus->name = buf; |
759 | } | |
760 | ||
72cf2d4f | 761 | QLIST_INIT(&bus->children); |
02e2da45 | 762 | if (parent) { |
72cf2d4f | 763 | QLIST_INSERT_HEAD(&parent->child_bus, bus, sibling); |
d271de9f | 764 | parent->num_child_bus++; |
80376c3f IY |
765 | } else if (bus != main_system_bus) { |
766 | /* TODO: once all bus devices are qdevified, | |
767 | only reset handler for main_system_bus should be registered here. */ | |
768 | qemu_register_reset(qbus_reset_all_fn, bus); | |
02e2da45 | 769 | } |
cd739fb6 GH |
770 | } |
771 | ||
772 | BusState *qbus_create(BusInfo *info, DeviceState *parent, const char *name) | |
773 | { | |
774 | BusState *bus; | |
775 | ||
776 | bus = qemu_mallocz(info->size); | |
777 | bus->qdev_allocated = 1; | |
778 | qbus_create_inplace(bus, info, parent, name); | |
02e2da45 PB |
779 | return bus; |
780 | } | |
cae4956e | 781 | |
131ec1bd GH |
782 | void qbus_free(BusState *bus) |
783 | { | |
784 | DeviceState *dev; | |
785 | ||
786 | while ((dev = QLIST_FIRST(&bus->children)) != NULL) { | |
787 | qdev_free(dev); | |
788 | } | |
789 | if (bus->parent) { | |
790 | QLIST_REMOVE(bus, sibling); | |
791 | bus->parent->num_child_bus--; | |
80376c3f IY |
792 | } else { |
793 | assert(bus != main_system_bus); /* main_system_bus is never freed */ | |
794 | qemu_unregister_reset(qbus_reset_all_fn, bus); | |
131ec1bd | 795 | } |
e163ae7b | 796 | qemu_free((void*)bus->name); |
131ec1bd GH |
797 | if (bus->qdev_allocated) { |
798 | qemu_free(bus); | |
799 | } | |
800 | } | |
801 | ||
cae4956e GH |
802 | #define qdev_printf(fmt, ...) monitor_printf(mon, "%*s" fmt, indent, "", ## __VA_ARGS__) |
803 | static void qbus_print(Monitor *mon, BusState *bus, int indent); | |
804 | ||
ee6847d1 GH |
805 | static void qdev_print_props(Monitor *mon, DeviceState *dev, Property *props, |
806 | const char *prefix, int indent) | |
807 | { | |
808 | char buf[64]; | |
809 | ||
810 | if (!props) | |
811 | return; | |
812 | while (props->name) { | |
036f7166 MA |
813 | /* |
814 | * TODO Properties without a print method are just for dirty | |
815 | * hacks. qdev_prop_ptr is the only such PropertyInfo. It's | |
816 | * marked for removal. The test props->info->print should be | |
817 | * removed along with it. | |
818 | */ | |
ee6847d1 GH |
819 | if (props->info->print) { |
820 | props->info->print(dev, props, buf, sizeof(buf)); | |
821 | qdev_printf("%s-prop: %s = %s\n", prefix, props->name, buf); | |
822 | } | |
823 | props++; | |
824 | } | |
825 | } | |
826 | ||
cae4956e GH |
827 | static void qdev_print(Monitor *mon, DeviceState *dev, int indent) |
828 | { | |
cae4956e | 829 | BusState *child; |
ccb63de3 GH |
830 | qdev_printf("dev: %s, id \"%s\"\n", dev->info->name, |
831 | dev->id ? dev->id : ""); | |
cae4956e GH |
832 | indent += 2; |
833 | if (dev->num_gpio_in) { | |
834 | qdev_printf("gpio-in %d\n", dev->num_gpio_in); | |
835 | } | |
836 | if (dev->num_gpio_out) { | |
837 | qdev_printf("gpio-out %d\n", dev->num_gpio_out); | |
838 | } | |
ee6847d1 GH |
839 | qdev_print_props(mon, dev, dev->info->props, "dev", indent); |
840 | qdev_print_props(mon, dev, dev->parent_bus->info->props, "bus", indent); | |
10c4c98a GH |
841 | if (dev->parent_bus->info->print_dev) |
842 | dev->parent_bus->info->print_dev(mon, dev, indent); | |
72cf2d4f | 843 | QLIST_FOREACH(child, &dev->child_bus, sibling) { |
cae4956e GH |
844 | qbus_print(mon, child, indent); |
845 | } | |
846 | } | |
847 | ||
848 | static void qbus_print(Monitor *mon, BusState *bus, int indent) | |
849 | { | |
850 | struct DeviceState *dev; | |
851 | ||
852 | qdev_printf("bus: %s\n", bus->name); | |
853 | indent += 2; | |
10c4c98a | 854 | qdev_printf("type %s\n", bus->info->name); |
72cf2d4f | 855 | QLIST_FOREACH(dev, &bus->children, sibling) { |
cae4956e GH |
856 | qdev_print(mon, dev, indent); |
857 | } | |
858 | } | |
859 | #undef qdev_printf | |
860 | ||
861 | void do_info_qtree(Monitor *mon) | |
862 | { | |
863 | if (main_system_bus) | |
864 | qbus_print(mon, main_system_bus, 0); | |
865 | } | |
9316d30f | 866 | |
f6c64e0e | 867 | void do_info_qdm(Monitor *mon) |
9316d30f GH |
868 | { |
869 | DeviceInfo *info; | |
9316d30f GH |
870 | |
871 | for (info = device_info_list; info != NULL; info = info->next) { | |
8a9662ca | 872 | qdev_print_devinfo(info); |
9316d30f GH |
873 | } |
874 | } | |
3418bd25 | 875 | |
8bc27249 | 876 | int do_device_add(Monitor *mon, const QDict *qdict, QObject **ret_data) |
3418bd25 GH |
877 | { |
878 | QemuOpts *opts; | |
879 | ||
3329f07b | 880 | opts = qemu_opts_from_qdict(qemu_find_opts("device"), qdict); |
8bc27249 MA |
881 | if (!opts) { |
882 | return -1; | |
883 | } | |
884 | if (!monitor_cur_is_qmp() && qdev_device_help(opts)) { | |
885 | qemu_opts_del(opts); | |
886 | return 0; | |
0f853a38 | 887 | } |
8bc27249 MA |
888 | if (!qdev_device_add(opts)) { |
889 | qemu_opts_del(opts); | |
890 | return -1; | |
891 | } | |
892 | return 0; | |
3418bd25 GH |
893 | } |
894 | ||
17a38eaa | 895 | int do_device_del(Monitor *mon, const QDict *qdict, QObject **ret_data) |
3418bd25 GH |
896 | { |
897 | const char *id = qdict_get_str(qdict, "id"); | |
898 | DeviceState *dev; | |
899 | ||
900 | dev = qdev_find_recursive(main_system_bus, id); | |
901 | if (NULL == dev) { | |
17a38eaa MA |
902 | qerror_report(QERR_DEVICE_NOT_FOUND, id); |
903 | return -1; | |
3418bd25 | 904 | } |
17a38eaa | 905 | return qdev_unplug(dev); |
3418bd25 | 906 | } |
1ca4d09a GN |
907 | |
908 | static int qdev_get_fw_dev_path_helper(DeviceState *dev, char *p, int size) | |
909 | { | |
910 | int l = 0; | |
911 | ||
912 | if (dev && dev->parent_bus) { | |
913 | char *d; | |
914 | l = qdev_get_fw_dev_path_helper(dev->parent_bus->parent, p, size); | |
915 | if (dev->parent_bus->info->get_fw_dev_path) { | |
916 | d = dev->parent_bus->info->get_fw_dev_path(dev); | |
917 | l += snprintf(p + l, size - l, "%s", d); | |
918 | qemu_free(d); | |
919 | } else { | |
920 | l += snprintf(p + l, size - l, "%s", dev->info->name); | |
921 | } | |
922 | } | |
923 | l += snprintf(p + l , size - l, "/"); | |
924 | ||
925 | return l; | |
926 | } | |
927 | ||
928 | char* qdev_get_fw_dev_path(DeviceState *dev) | |
929 | { | |
930 | char path[128]; | |
931 | int l; | |
932 | ||
933 | l = qdev_get_fw_dev_path_helper(dev, path, 128); | |
934 | ||
935 | path[l-1] = '\0'; | |
936 | ||
937 | return strdup(path); | |
938 | } |