]>
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 | ||
18c86e2b | 28 | #include "qemu/osdep.h" |
e688df6b | 29 | #include "qapi/error.h" |
c577ff62 | 30 | #include "qapi/qapi-events-qdev.h" |
b4a42f81 | 31 | #include "qapi/qmp/qerror.h" |
7b1b5d19 | 32 | #include "qapi/visitor.h" |
d49b6836 | 33 | #include "qemu/error-report.h" |
922a01a0 | 34 | #include "qemu/option.h" |
0ee4de6c | 35 | #include "hw/hotplug.h" |
64552b6b | 36 | #include "hw/irq.h" |
a27bd6c7 | 37 | #include "hw/qdev-properties.h" |
b7454548 | 38 | #include "hw/boards.h" |
7474f1be | 39 | #include "hw/sysbus.h" |
d6454270 | 40 | #include "migration/vmstate.h" |
70804c83 | 41 | #include "trace.h" |
aae9460e | 42 | |
9bed84c1 | 43 | bool qdev_hotplug = false; |
0ac8ef71 | 44 | static bool qdev_hot_added = false; |
21def24a | 45 | bool qdev_hot_removed = false; |
3418bd25 | 46 | |
4be9f0d1 AL |
47 | const VMStateDescription *qdev_get_vmsd(DeviceState *dev) |
48 | { | |
6e008585 AL |
49 | DeviceClass *dc = DEVICE_GET_CLASS(dev); |
50 | return dc->vmsd; | |
4be9f0d1 AL |
51 | } |
52 | ||
0866aca1 | 53 | static void bus_remove_child(BusState *bus, DeviceState *child) |
0c17542d | 54 | { |
0866aca1 AL |
55 | BusChild *kid; |
56 | ||
57 | QTAILQ_FOREACH(kid, &bus->children, sibling) { | |
58 | if (kid->child == child) { | |
59 | char name[32]; | |
60 | ||
61 | snprintf(name, sizeof(name), "child[%d]", kid->index); | |
62 | QTAILQ_REMOVE(&bus->children, kid, sibling); | |
9d127820 | 63 | |
12b2e9f3 TK |
64 | bus->num_children--; |
65 | ||
9d127820 | 66 | /* This gives back ownership of kid->child back to us. */ |
0866aca1 | 67 | object_property_del(OBJECT(bus), name, NULL); |
9d127820 | 68 | object_unref(OBJECT(kid->child)); |
0866aca1 AL |
69 | g_free(kid); |
70 | return; | |
71 | } | |
72 | } | |
73 | } | |
74 | ||
75 | static void bus_add_child(BusState *bus, DeviceState *child) | |
76 | { | |
77 | char name[32]; | |
78 | BusChild *kid = g_malloc0(sizeof(*kid)); | |
0c17542d | 79 | |
12b2e9f3 | 80 | bus->num_children++; |
0866aca1 AL |
81 | kid->index = bus->max_index++; |
82 | kid->child = child; | |
9d127820 | 83 | object_ref(OBJECT(kid->child)); |
a5296ca9 | 84 | |
0866aca1 AL |
85 | QTAILQ_INSERT_HEAD(&bus->children, kid, sibling); |
86 | ||
9d127820 | 87 | /* This transfers ownership of kid->child to the property. */ |
0866aca1 AL |
88 | snprintf(name, sizeof(name), "child[%d]", kid->index); |
89 | object_property_add_link(OBJECT(bus), name, | |
90 | object_get_typename(OBJECT(child)), | |
39f72ef9 SH |
91 | (Object **)&kid->child, |
92 | NULL, /* read-only property */ | |
93 | 0, /* return ownership on prop deletion */ | |
94 | NULL); | |
0866aca1 AL |
95 | } |
96 | ||
97 | void qdev_set_parent_bus(DeviceState *dev, BusState *bus) | |
98 | { | |
a7c3a4f9 | 99 | BusState *old_parent_bus = dev->parent_bus; |
91c968ac | 100 | |
a7c3a4f9 | 101 | if (old_parent_bus) { |
70804c83 | 102 | trace_qdev_update_parent_bus(dev, object_get_typename(OBJECT(dev)), |
a7c3a4f9 | 103 | old_parent_bus, object_get_typename(OBJECT(old_parent_bus)), |
70804c83 DH |
104 | OBJECT(bus), object_get_typename(OBJECT(bus))); |
105 | /* | |
106 | * Keep a reference to the device while it's not plugged into | |
91c968ac PM |
107 | * any bus, to avoid it potentially evaporating when it is |
108 | * dereffed in bus_remove_child(). | |
a7c3a4f9 DH |
109 | * Also keep the ref of the parent bus until the end, so that |
110 | * we can safely call resettable_change_parent() below. | |
91c968ac PM |
111 | */ |
112 | object_ref(OBJECT(dev)); | |
113 | bus_remove_child(dev->parent_bus, dev); | |
91c968ac | 114 | } |
9fbe6127 | 115 | dev->parent_bus = bus; |
62d7ba66 | 116 | object_ref(OBJECT(bus)); |
0866aca1 | 117 | bus_add_child(bus, dev); |
a7c3a4f9 DH |
118 | if (dev->realized) { |
119 | resettable_change_parent(OBJECT(dev), OBJECT(bus), | |
120 | OBJECT(old_parent_bus)); | |
121 | } | |
122 | if (old_parent_bus) { | |
123 | object_unref(OBJECT(old_parent_bus)); | |
91c968ac PM |
124 | object_unref(OBJECT(dev)); |
125 | } | |
0c17542d MA |
126 | } |
127 | ||
0210afe6 MA |
128 | /* Create a new device. This only initializes the device state |
129 | structure and allows properties to be set. The device still needs | |
130 | to be realized. See qdev-core.h. */ | |
02e2da45 | 131 | DeviceState *qdev_create(BusState *bus, const char *name) |
0bcdeda7 BS |
132 | { |
133 | DeviceState *dev; | |
134 | ||
135 | dev = qdev_try_create(bus, name); | |
136 | if (!dev) { | |
e92714c7 | 137 | if (bus) { |
312fd5f2 | 138 | error_report("Unknown device '%s' for bus '%s'", name, |
23e3fbec | 139 | object_get_typename(OBJECT(bus))); |
e92714c7 | 140 | } else { |
312fd5f2 | 141 | error_report("Unknown device '%s' for default sysbus", name); |
e92714c7 | 142 | } |
01ed1d52 | 143 | abort(); |
0bcdeda7 BS |
144 | } |
145 | ||
146 | return dev; | |
147 | } | |
148 | ||
da57febf | 149 | DeviceState *qdev_try_create(BusState *bus, const char *type) |
aae9460e | 150 | { |
9fbe6127 AL |
151 | DeviceState *dev; |
152 | ||
da57febf | 153 | if (object_class_by_name(type) == NULL) { |
4ed658ca AF |
154 | return NULL; |
155 | } | |
da57febf | 156 | dev = DEVICE(object_new(type)); |
9fbe6127 AL |
157 | if (!dev) { |
158 | return NULL; | |
159 | } | |
160 | ||
10c4c98a | 161 | if (!bus) { |
7474f1be PM |
162 | /* Assert that the device really is a SysBusDevice before |
163 | * we put it onto the sysbus. Non-sysbus devices which aren't | |
164 | * being put onto a bus should be created with object_new(TYPE_FOO), | |
165 | * not qdev_create(NULL, TYPE_FOO). | |
166 | */ | |
167 | g_assert(object_dynamic_cast(OBJECT(dev), TYPE_SYS_BUS_DEVICE)); | |
68694897 | 168 | bus = sysbus_get_default(); |
10c4c98a GH |
169 | } |
170 | ||
9fbe6127 | 171 | qdev_set_parent_bus(dev, bus); |
b09995ae | 172 | object_unref(OBJECT(dev)); |
9fbe6127 | 173 | return dev; |
aae9460e PB |
174 | } |
175 | ||
eae3eb3e | 176 | static QTAILQ_HEAD(, DeviceListener) device_listeners |
707ff800 PD |
177 | = QTAILQ_HEAD_INITIALIZER(device_listeners); |
178 | ||
179 | enum ListenerDirection { Forward, Reverse }; | |
180 | ||
181 | #define DEVICE_LISTENER_CALL(_callback, _direction, _args...) \ | |
182 | do { \ | |
183 | DeviceListener *_listener; \ | |
184 | \ | |
185 | switch (_direction) { \ | |
186 | case Forward: \ | |
187 | QTAILQ_FOREACH(_listener, &device_listeners, link) { \ | |
188 | if (_listener->_callback) { \ | |
189 | _listener->_callback(_listener, ##_args); \ | |
190 | } \ | |
191 | } \ | |
192 | break; \ | |
193 | case Reverse: \ | |
194 | QTAILQ_FOREACH_REVERSE(_listener, &device_listeners, \ | |
eae3eb3e | 195 | link) { \ |
707ff800 PD |
196 | if (_listener->_callback) { \ |
197 | _listener->_callback(_listener, ##_args); \ | |
198 | } \ | |
199 | } \ | |
200 | break; \ | |
201 | default: \ | |
202 | abort(); \ | |
203 | } \ | |
204 | } while (0) | |
205 | ||
206 | static int device_listener_add(DeviceState *dev, void *opaque) | |
207 | { | |
208 | DEVICE_LISTENER_CALL(realize, Forward, dev); | |
209 | ||
210 | return 0; | |
211 | } | |
212 | ||
213 | void device_listener_register(DeviceListener *listener) | |
214 | { | |
215 | QTAILQ_INSERT_TAIL(&device_listeners, listener, link); | |
216 | ||
217 | qbus_walk_children(sysbus_get_default(), NULL, NULL, device_listener_add, | |
218 | NULL, NULL); | |
219 | } | |
220 | ||
221 | void device_listener_unregister(DeviceListener *listener) | |
222 | { | |
223 | QTAILQ_REMOVE(&device_listeners, listener, link); | |
224 | } | |
225 | ||
f3a85056 JF |
226 | bool qdev_should_hide_device(QemuOpts *opts) |
227 | { | |
228 | int rc = -1; | |
229 | DeviceListener *listener; | |
230 | ||
231 | QTAILQ_FOREACH(listener, &device_listeners, link) { | |
232 | if (listener->should_be_hidden) { | |
233 | /* | |
234 | * should_be_hidden_will return | |
235 | * 1 if device matches opts and it should be hidden | |
236 | * 0 if device matches opts and should not be hidden | |
237 | * -1 if device doesn't match ops | |
238 | */ | |
239 | rc = listener->should_be_hidden(listener, opts); | |
240 | } | |
241 | ||
242 | if (rc > 0) { | |
243 | break; | |
244 | } | |
245 | } | |
246 | ||
247 | return rc > 0; | |
248 | } | |
249 | ||
4d2ffa08 JK |
250 | void qdev_set_legacy_instance_id(DeviceState *dev, int alias_id, |
251 | int required_for_version) | |
252 | { | |
7983c8a3 | 253 | assert(!dev->realized); |
4d2ffa08 JK |
254 | dev->instance_id_alias = alias_id; |
255 | dev->alias_required_for_version = required_for_version; | |
256 | } | |
257 | ||
03fcbd9d TH |
258 | HotplugHandler *qdev_get_machine_hotplug_handler(DeviceState *dev) |
259 | { | |
260 | MachineState *machine; | |
261 | MachineClass *mc; | |
262 | Object *m_obj = qdev_get_machine(); | |
263 | ||
264 | if (object_dynamic_cast(m_obj, TYPE_MACHINE)) { | |
265 | machine = MACHINE(m_obj); | |
266 | mc = MACHINE_GET_CLASS(machine); | |
267 | if (mc->get_hotplug_handler) { | |
268 | return mc->get_hotplug_handler(machine, dev); | |
269 | } | |
270 | } | |
271 | ||
272 | return NULL; | |
273 | } | |
274 | ||
d2321d31 PX |
275 | bool qdev_hotplug_allowed(DeviceState *dev, Error **errp) |
276 | { | |
277 | MachineState *machine; | |
278 | MachineClass *mc; | |
279 | Object *m_obj = qdev_get_machine(); | |
280 | ||
281 | if (object_dynamic_cast(m_obj, TYPE_MACHINE)) { | |
282 | machine = MACHINE(m_obj); | |
283 | mc = MACHINE_GET_CLASS(machine); | |
284 | if (mc->hotplug_allowed) { | |
285 | return mc->hotplug_allowed(machine, dev, errp); | |
286 | } | |
287 | } | |
288 | ||
289 | return true; | |
290 | } | |
291 | ||
14405c27 DH |
292 | HotplugHandler *qdev_get_bus_hotplug_handler(DeviceState *dev) |
293 | { | |
294 | if (dev->parent_bus) { | |
295 | return dev->parent_bus->hotplug_handler; | |
296 | } | |
297 | return NULL; | |
298 | } | |
299 | ||
c06b2ffb | 300 | HotplugHandler *qdev_get_hotplug_handler(DeviceState *dev) |
7716b8ca | 301 | { |
17cc0128 | 302 | HotplugHandler *hotplug_ctrl = qdev_get_machine_hotplug_handler(dev); |
7716b8ca | 303 | |
17cc0128 | 304 | if (hotplug_ctrl == NULL && dev->parent_bus) { |
14405c27 | 305 | hotplug_ctrl = qdev_get_bus_hotplug_handler(dev); |
7716b8ca IM |
306 | } |
307 | return hotplug_ctrl; | |
308 | } | |
309 | ||
70804c83 DH |
310 | static int qdev_prereset(DeviceState *dev, void *opaque) |
311 | { | |
312 | trace_qdev_reset_tree(dev, object_get_typename(OBJECT(dev))); | |
313 | return 0; | |
314 | } | |
315 | ||
316 | static int qbus_prereset(BusState *bus, void *opaque) | |
317 | { | |
318 | trace_qbus_reset_tree(bus, object_get_typename(OBJECT(bus))); | |
319 | return 0; | |
320 | } | |
321 | ||
ec990eb6 AL |
322 | static int qdev_reset_one(DeviceState *dev, void *opaque) |
323 | { | |
f703a04c | 324 | device_legacy_reset(dev); |
ec990eb6 AL |
325 | |
326 | return 0; | |
327 | } | |
328 | ||
b4694b7c IY |
329 | static int qbus_reset_one(BusState *bus, void *opaque) |
330 | { | |
0d936928 | 331 | BusClass *bc = BUS_GET_CLASS(bus); |
70804c83 | 332 | trace_qbus_reset(bus, object_get_typename(OBJECT(bus))); |
0d936928 | 333 | if (bc->reset) { |
dcc20931 | 334 | bc->reset(bus); |
b4694b7c IY |
335 | } |
336 | return 0; | |
337 | } | |
338 | ||
5af0a04b IY |
339 | void qdev_reset_all(DeviceState *dev) |
340 | { | |
70804c83 DH |
341 | trace_qdev_reset_all(dev, object_get_typename(OBJECT(dev))); |
342 | qdev_walk_children(dev, qdev_prereset, qbus_prereset, | |
343 | qdev_reset_one, qbus_reset_one, NULL); | |
5af0a04b IY |
344 | } |
345 | ||
ff8de075 DH |
346 | void qdev_reset_all_fn(void *opaque) |
347 | { | |
348 | qdev_reset_all(DEVICE(opaque)); | |
349 | } | |
350 | ||
d0508c36 PB |
351 | void qbus_reset_all(BusState *bus) |
352 | { | |
70804c83 DH |
353 | trace_qbus_reset_all(bus, object_get_typename(OBJECT(bus))); |
354 | qbus_walk_children(bus, qdev_prereset, qbus_prereset, | |
355 | qdev_reset_one, qbus_reset_one, NULL); | |
d0508c36 PB |
356 | } |
357 | ||
80376c3f IY |
358 | void qbus_reset_all_fn(void *opaque) |
359 | { | |
360 | BusState *bus = opaque; | |
d0508c36 | 361 | qbus_reset_all(bus); |
80376c3f IY |
362 | } |
363 | ||
abb89dbf DH |
364 | void device_cold_reset(DeviceState *dev) |
365 | { | |
366 | resettable_reset(OBJECT(dev), RESET_TYPE_COLD); | |
367 | } | |
368 | ||
c11256aa DH |
369 | bool device_is_in_reset(DeviceState *dev) |
370 | { | |
371 | return resettable_is_in_reset(OBJECT(dev)); | |
372 | } | |
373 | ||
374 | static ResettableState *device_get_reset_state(Object *obj) | |
375 | { | |
376 | DeviceState *dev = DEVICE(obj); | |
377 | return &dev->reset; | |
378 | } | |
379 | ||
380 | static void device_reset_child_foreach(Object *obj, ResettableChildCallback cb, | |
381 | void *opaque, ResetType type) | |
382 | { | |
383 | DeviceState *dev = DEVICE(obj); | |
384 | BusState *bus; | |
385 | ||
386 | QLIST_FOREACH(bus, &dev->child_bus, sibling) { | |
387 | cb(OBJECT(bus), opaque, type); | |
388 | } | |
389 | } | |
390 | ||
3418bd25 | 391 | /* can be used as ->unplug() callback for the simple cases */ |
014176f9 IM |
392 | void qdev_simple_device_unplug_cb(HotplugHandler *hotplug_dev, |
393 | DeviceState *dev, Error **errp) | |
394 | { | |
07578b0a | 395 | object_property_set_bool(OBJECT(dev), false, "realized", NULL); |
014176f9 | 396 | } |
3b29a101 | 397 | |
0210afe6 MA |
398 | /* |
399 | * Realize @dev. | |
400 | * Device properties should be set before calling this function. IRQs | |
401 | * and MMIO regions should be connected/mapped after calling this | |
402 | * function. | |
403 | * On failure, report an error with error_report() and terminate the | |
404 | * program. This is okay during machine creation. Don't use for | |
405 | * hotplug, because there callers need to recover from failure. | |
406 | * Exception: if you know the device's init() callback can't fail, | |
407 | * then qdev_init_nofail() can't fail either, and is therefore usable | |
408 | * even then. But relying on the device implementation that way is | |
409 | * somewhat unclean, and best avoided. | |
410 | */ | |
e23a1b33 MA |
411 | void qdev_init_nofail(DeviceState *dev) |
412 | { | |
c4bacafb | 413 | Error *err = NULL; |
7de3abe5 | 414 | |
c4bacafb MA |
415 | assert(!dev->realized); |
416 | ||
0d4104e5 | 417 | object_ref(OBJECT(dev)); |
c4bacafb MA |
418 | object_property_set_bool(OBJECT(dev), true, "realized", &err); |
419 | if (err) { | |
c29b77f9 MA |
420 | error_reportf_err(err, "Initialization of device %s failed: ", |
421 | object_get_typename(OBJECT(dev))); | |
bd6c9a61 MA |
422 | exit(1); |
423 | } | |
0d4104e5 | 424 | object_unref(OBJECT(dev)); |
e23a1b33 MA |
425 | } |
426 | ||
3418bd25 GH |
427 | void qdev_machine_creation_done(void) |
428 | { | |
429 | /* | |
430 | * ok, initial machine setup is done, starting from now we can | |
431 | * only create hotpluggable devices | |
432 | */ | |
9bed84c1 | 433 | qdev_hotplug = true; |
3418bd25 GH |
434 | } |
435 | ||
0ac8ef71 AW |
436 | bool qdev_machine_modified(void) |
437 | { | |
438 | return qdev_hot_added || qdev_hot_removed; | |
439 | } | |
440 | ||
02e2da45 | 441 | BusState *qdev_get_parent_bus(DeviceState *dev) |
aae9460e | 442 | { |
02e2da45 | 443 | return dev->parent_bus; |
aae9460e PB |
444 | } |
445 | ||
a5f54290 PC |
446 | static NamedGPIOList *qdev_get_named_gpio_list(DeviceState *dev, |
447 | const char *name) | |
448 | { | |
449 | NamedGPIOList *ngl; | |
450 | ||
451 | QLIST_FOREACH(ngl, &dev->gpios, node) { | |
3a87dde8 MAL |
452 | /* NULL is a valid and matchable name. */ |
453 | if (g_strcmp0(name, ngl->name) == 0) { | |
a5f54290 PC |
454 | return ngl; |
455 | } | |
456 | } | |
457 | ||
458 | ngl = g_malloc0(sizeof(*ngl)); | |
459 | ngl->name = g_strdup(name); | |
460 | QLIST_INSERT_HEAD(&dev->gpios, ngl, node); | |
461 | return ngl; | |
462 | } | |
463 | ||
4a151677 PM |
464 | void qdev_init_gpio_in_named_with_opaque(DeviceState *dev, |
465 | qemu_irq_handler handler, | |
466 | void *opaque, | |
467 | const char *name, int n) | |
a5f54290 | 468 | { |
a69bef1c | 469 | int i; |
a5f54290 PC |
470 | NamedGPIOList *gpio_list = qdev_get_named_gpio_list(dev, name); |
471 | ||
b235a71f | 472 | assert(gpio_list->num_out == 0 || !name); |
a5f54290 | 473 | gpio_list->in = qemu_extend_irqs(gpio_list->in, gpio_list->num_in, handler, |
4a151677 | 474 | opaque, n); |
a69bef1c | 475 | |
6c76b377 PF |
476 | if (!name) { |
477 | name = "unnamed-gpio-in"; | |
478 | } | |
a69bef1c | 479 | for (i = gpio_list->num_in; i < gpio_list->num_in + n; i++) { |
6c76b377 PF |
480 | gchar *propname = g_strdup_printf("%s[%u]", name, i); |
481 | ||
a69bef1c PC |
482 | object_property_add_child(OBJECT(dev), propname, |
483 | OBJECT(gpio_list->in[i]), &error_abort); | |
6c76b377 | 484 | g_free(propname); |
a69bef1c | 485 | } |
a69bef1c | 486 | |
a5f54290 PC |
487 | gpio_list->num_in += n; |
488 | } | |
489 | ||
aae9460e PB |
490 | void qdev_init_gpio_in(DeviceState *dev, qemu_irq_handler handler, int n) |
491 | { | |
a5f54290 PC |
492 | qdev_init_gpio_in_named(dev, handler, NULL, n); |
493 | } | |
494 | ||
495 | void qdev_init_gpio_out_named(DeviceState *dev, qemu_irq *pins, | |
496 | const char *name, int n) | |
497 | { | |
688b057a | 498 | int i; |
a5f54290 PC |
499 | NamedGPIOList *gpio_list = qdev_get_named_gpio_list(dev, name); |
500 | ||
b235a71f | 501 | assert(gpio_list->num_in == 0 || !name); |
688b057a | 502 | |
6c76b377 PF |
503 | if (!name) { |
504 | name = "unnamed-gpio-out"; | |
505 | } | |
506 | memset(pins, 0, sizeof(*pins) * n); | |
688b057a | 507 | for (i = 0; i < n; ++i) { |
6c76b377 PF |
508 | gchar *propname = g_strdup_printf("%s[%u]", name, |
509 | gpio_list->num_out + i); | |
510 | ||
688b057a PC |
511 | object_property_add_link(OBJECT(dev), propname, TYPE_IRQ, |
512 | (Object **)&pins[i], | |
513 | object_property_allow_set_link, | |
265b578c | 514 | OBJ_PROP_LINK_STRONG, |
688b057a | 515 | &error_abort); |
6c76b377 | 516 | g_free(propname); |
688b057a | 517 | } |
6c76b377 | 518 | gpio_list->num_out += n; |
aae9460e PB |
519 | } |
520 | ||
521 | void qdev_init_gpio_out(DeviceState *dev, qemu_irq *pins, int n) | |
522 | { | |
a5f54290 PC |
523 | qdev_init_gpio_out_named(dev, pins, NULL, n); |
524 | } | |
525 | ||
526 | qemu_irq qdev_get_gpio_in_named(DeviceState *dev, const char *name, int n) | |
527 | { | |
528 | NamedGPIOList *gpio_list = qdev_get_named_gpio_list(dev, name); | |
529 | ||
530 | assert(n >= 0 && n < gpio_list->num_in); | |
531 | return gpio_list->in[n]; | |
aae9460e PB |
532 | } |
533 | ||
534 | qemu_irq qdev_get_gpio_in(DeviceState *dev, int n) | |
535 | { | |
a5f54290 PC |
536 | return qdev_get_gpio_in_named(dev, NULL, n); |
537 | } | |
538 | ||
539 | void qdev_connect_gpio_out_named(DeviceState *dev, const char *name, int n, | |
540 | qemu_irq pin) | |
541 | { | |
02757df2 PC |
542 | char *propname = g_strdup_printf("%s[%d]", |
543 | name ? name : "unnamed-gpio-out", n); | |
544 | if (pin) { | |
545 | /* We need a name for object_property_set_link to work. If the | |
546 | * object has a parent, object_property_add_child will come back | |
547 | * with an error without doing anything. If it has none, it will | |
548 | * never fail. So we can just call it with a NULL Error pointer. | |
549 | */ | |
88950eef AF |
550 | object_property_add_child(container_get(qdev_get_machine(), |
551 | "/unattached"), | |
552 | "non-qdev-gpio[*]", OBJECT(pin), NULL); | |
02757df2 PC |
553 | } |
554 | object_property_set_link(OBJECT(dev), OBJECT(pin), propname, &error_abort); | |
555 | g_free(propname); | |
aae9460e PB |
556 | } |
557 | ||
b7973186 AG |
558 | qemu_irq qdev_get_gpio_out_connector(DeviceState *dev, const char *name, int n) |
559 | { | |
2244f233 | 560 | g_autofree char *propname = g_strdup_printf("%s[%d]", |
b7973186 AG |
561 | name ? name : "unnamed-gpio-out", n); |
562 | ||
563 | qemu_irq ret = (qemu_irq)object_property_get_link(OBJECT(dev), propname, | |
564 | NULL); | |
565 | ||
566 | return ret; | |
567 | } | |
568 | ||
67cc32eb | 569 | /* disconnect a GPIO output, returning the disconnected input (if any) */ |
0c24db2b PC |
570 | |
571 | static qemu_irq qdev_disconnect_gpio_out_named(DeviceState *dev, | |
572 | const char *name, int n) | |
573 | { | |
574 | char *propname = g_strdup_printf("%s[%d]", | |
575 | name ? name : "unnamed-gpio-out", n); | |
576 | ||
577 | qemu_irq ret = (qemu_irq)object_property_get_link(OBJECT(dev), propname, | |
578 | NULL); | |
579 | if (ret) { | |
580 | object_property_set_link(OBJECT(dev), NULL, propname, NULL); | |
581 | } | |
582 | g_free(propname); | |
583 | return ret; | |
584 | } | |
a5f54290 | 585 | |
0c24db2b PC |
586 | qemu_irq qdev_intercept_gpio_out(DeviceState *dev, qemu_irq icpt, |
587 | const char *name, int n) | |
588 | { | |
589 | qemu_irq disconnected = qdev_disconnect_gpio_out_named(dev, name, n); | |
590 | qdev_connect_gpio_out_named(dev, name, n, icpt); | |
591 | return disconnected; | |
aae9460e PB |
592 | } |
593 | ||
594 | void qdev_connect_gpio_out(DeviceState * dev, int n, qemu_irq pin) | |
595 | { | |
a5f54290 | 596 | qdev_connect_gpio_out_named(dev, NULL, n, pin); |
aae9460e PB |
597 | } |
598 | ||
17a96a14 PC |
599 | void qdev_pass_gpios(DeviceState *dev, DeviceState *container, |
600 | const char *name) | |
601 | { | |
602 | int i; | |
603 | NamedGPIOList *ngl = qdev_get_named_gpio_list(dev, name); | |
604 | ||
605 | for (i = 0; i < ngl->num_in; i++) { | |
606 | const char *nm = ngl->name ? ngl->name : "unnamed-gpio-in"; | |
607 | char *propname = g_strdup_printf("%s[%d]", nm, i); | |
608 | ||
609 | object_property_add_alias(OBJECT(container), propname, | |
610 | OBJECT(dev), propname, | |
611 | &error_abort); | |
6bc5cf92 | 612 | g_free(propname); |
17a96a14 PC |
613 | } |
614 | for (i = 0; i < ngl->num_out; i++) { | |
615 | const char *nm = ngl->name ? ngl->name : "unnamed-gpio-out"; | |
616 | char *propname = g_strdup_printf("%s[%d]", nm, i); | |
617 | ||
618 | object_property_add_alias(OBJECT(container), propname, | |
619 | OBJECT(dev), propname, | |
620 | &error_abort); | |
6bc5cf92 | 621 | g_free(propname); |
17a96a14 PC |
622 | } |
623 | QLIST_REMOVE(ngl, node); | |
624 | QLIST_INSERT_HEAD(&container->gpios, ngl, node); | |
625 | } | |
626 | ||
02e2da45 | 627 | BusState *qdev_get_child_bus(DeviceState *dev, const char *name) |
4d6ae674 | 628 | { |
02e2da45 | 629 | BusState *bus; |
f698c8ba PC |
630 | Object *child = object_resolve_path_component(OBJECT(dev), name); |
631 | ||
632 | bus = (BusState *)object_dynamic_cast(child, TYPE_BUS); | |
633 | if (bus) { | |
634 | return bus; | |
635 | } | |
4d6ae674 | 636 | |
72cf2d4f | 637 | QLIST_FOREACH(bus, &dev->child_bus, sibling) { |
4d6ae674 | 638 | if (strcmp(name, bus->name) == 0) { |
02e2da45 | 639 | return bus; |
4d6ae674 PB |
640 | } |
641 | } | |
642 | return NULL; | |
643 | } | |
644 | ||
0293214b PB |
645 | int qdev_walk_children(DeviceState *dev, |
646 | qdev_walkerfn *pre_devfn, qbus_walkerfn *pre_busfn, | |
647 | qdev_walkerfn *post_devfn, qbus_walkerfn *post_busfn, | |
648 | void *opaque) | |
81699d8a AL |
649 | { |
650 | BusState *bus; | |
651 | int err; | |
652 | ||
0293214b PB |
653 | if (pre_devfn) { |
654 | err = pre_devfn(dev, opaque); | |
81699d8a AL |
655 | if (err) { |
656 | return err; | |
657 | } | |
658 | } | |
659 | ||
660 | QLIST_FOREACH(bus, &dev->child_bus, sibling) { | |
0293214b PB |
661 | err = qbus_walk_children(bus, pre_devfn, pre_busfn, |
662 | post_devfn, post_busfn, opaque); | |
81699d8a AL |
663 | if (err < 0) { |
664 | return err; | |
665 | } | |
666 | } | |
667 | ||
0293214b PB |
668 | if (post_devfn) { |
669 | err = post_devfn(dev, opaque); | |
670 | if (err) { | |
671 | return err; | |
672 | } | |
673 | } | |
674 | ||
81699d8a AL |
675 | return 0; |
676 | } | |
677 | ||
a2ee6b4f | 678 | DeviceState *qdev_find_recursive(BusState *bus, const char *id) |
3418bd25 | 679 | { |
0866aca1 AL |
680 | BusChild *kid; |
681 | DeviceState *ret; | |
3418bd25 GH |
682 | BusState *child; |
683 | ||
0866aca1 AL |
684 | QTAILQ_FOREACH(kid, &bus->children, sibling) { |
685 | DeviceState *dev = kid->child; | |
686 | ||
687 | if (dev->id && strcmp(dev->id, id) == 0) { | |
3418bd25 | 688 | return dev; |
0866aca1 AL |
689 | } |
690 | ||
3418bd25 GH |
691 | QLIST_FOREACH(child, &dev->child_bus, sibling) { |
692 | ret = qdev_find_recursive(child, id); | |
693 | if (ret) { | |
694 | return ret; | |
695 | } | |
696 | } | |
697 | } | |
698 | return NULL; | |
699 | } | |
700 | ||
09e5ab63 | 701 | char *qdev_get_dev_path(DeviceState *dev) |
85ed303b | 702 | { |
0d936928 | 703 | BusClass *bc; |
09e5ab63 AL |
704 | |
705 | if (!dev || !dev->parent_bus) { | |
706 | return NULL; | |
707 | } | |
708 | ||
0d936928 AL |
709 | bc = BUS_GET_CLASS(dev->parent_bus); |
710 | if (bc->get_dev_path) { | |
711 | return bc->get_dev_path(dev); | |
09e5ab63 AL |
712 | } |
713 | ||
714 | return NULL; | |
44677ded | 715 | } |
a5296ca9 AL |
716 | |
717 | /** | |
718 | * Legacy property handling | |
719 | */ | |
720 | ||
d7bce999 EB |
721 | static void qdev_get_legacy_property(Object *obj, Visitor *v, |
722 | const char *name, void *opaque, | |
723 | Error **errp) | |
a5296ca9 | 724 | { |
57c9fafe | 725 | DeviceState *dev = DEVICE(obj); |
a5296ca9 AL |
726 | Property *prop = opaque; |
727 | ||
e3cb6ba6 PB |
728 | char buffer[1024]; |
729 | char *ptr = buffer; | |
a5296ca9 | 730 | |
e3cb6ba6 | 731 | prop->info->print(dev, prop, buffer, sizeof(buffer)); |
51e72bc1 | 732 | visit_type_str(v, name, &ptr, errp); |
a5296ca9 AL |
733 | } |
734 | ||
a5296ca9 | 735 | /** |
77b06bba | 736 | * qdev_class_add_legacy_property: |
d9d8d452 C |
737 | * @dev: Device to add the property to. |
738 | * @prop: The qdev property definition. | |
d9d8d452 C |
739 | * |
740 | * Add a legacy QOM property to @dev for qdev property @prop. | |
a5296ca9 | 741 | * |
d9d8d452 C |
742 | * Legacy properties are string versions of QOM properties. The format of |
743 | * the string depends on the property type. Legacy properties are only | |
744 | * needed for "info qtree". | |
a5296ca9 | 745 | * |
6871a0d0 | 746 | * Do not use this in new code! QOM Properties added through this interface |
d9d8d452 | 747 | * will be given names in the "legacy" namespace. |
a5296ca9 | 748 | */ |
77b06bba | 749 | static void qdev_class_add_legacy_property(DeviceClass *dc, Property *prop) |
a5296ca9 | 750 | { |
77b06bba | 751 | g_autofree char *name = NULL; |
a5296ca9 | 752 | |
f3be016d | 753 | /* Register pointer properties as legacy properties */ |
03ff7770 | 754 | if (!prop->info->print && prop->info->get) { |
68ee3569 PB |
755 | return; |
756 | } | |
f3be016d | 757 | |
ca2cc788 | 758 | name = g_strdup_printf("legacy-%s", prop->name); |
77b06bba MAL |
759 | object_class_property_add(OBJECT_CLASS(dc), name, "str", |
760 | prop->info->print ? qdev_get_legacy_property : prop->info->get, | |
761 | NULL, NULL, prop, &error_abort); | |
ca2cc788 PB |
762 | } |
763 | ||
94d912d1 | 764 | void qdev_property_add_static(DeviceState *dev, Property *prop) |
ca2cc788 | 765 | { |
fdae245f | 766 | Object *obj = OBJECT(dev); |
77b06bba | 767 | ObjectProperty *op; |
fdae245f | 768 | |
77b06bba MAL |
769 | assert(!prop->info->create); |
770 | ||
771 | op = object_property_add(obj, prop->name, prop->info->name, | |
772 | prop->info->get, prop->info->set, | |
773 | prop->info->release, | |
774 | prop, &error_abort); | |
b8c9cd5c GA |
775 | |
776 | object_property_set_description(obj, prop->name, | |
777 | prop->info->description, | |
778 | &error_abort); | |
779 | ||
5cc56cc6 | 780 | if (prop->set_default) { |
77b06bba MAL |
781 | prop->info->set_default_value(op, prop); |
782 | if (op->init) { | |
783 | op->init(obj, op); | |
784 | } | |
fdae245f | 785 | } |
6a146eba | 786 | } |
1de81d28 | 787 | |
77b06bba MAL |
788 | static void qdev_class_add_property(DeviceClass *klass, Property *prop) |
789 | { | |
790 | ObjectClass *oc = OBJECT_CLASS(klass); | |
791 | ||
792 | if (prop->info->create) { | |
793 | prop->info->create(oc, prop, &error_abort); | |
794 | } else { | |
795 | ObjectProperty *op; | |
796 | ||
797 | op = object_class_property_add(oc, | |
798 | prop->name, prop->info->name, | |
799 | prop->info->get, prop->info->set, | |
800 | prop->info->release, | |
801 | prop, &error_abort); | |
802 | if (prop->set_default) { | |
803 | prop->info->set_default_value(op, prop); | |
804 | } | |
805 | } | |
806 | object_class_property_set_description(oc, prop->name, | |
807 | prop->info->description, | |
808 | &error_abort); | |
809 | } | |
810 | ||
67cc7e0a SH |
811 | /* @qdev_alias_all_properties - Add alias properties to the source object for |
812 | * all qdev properties on the target DeviceState. | |
813 | */ | |
814 | void qdev_alias_all_properties(DeviceState *target, Object *source) | |
815 | { | |
816 | ObjectClass *class; | |
817 | Property *prop; | |
818 | ||
819 | class = object_get_class(OBJECT(target)); | |
820 | do { | |
821 | DeviceClass *dc = DEVICE_CLASS(class); | |
822 | ||
385d8f22 | 823 | for (prop = dc->props_; prop && prop->name; prop++) { |
67cc7e0a SH |
824 | object_property_add_alias(source, prop->name, |
825 | OBJECT(target), prop->name, | |
826 | &error_abort); | |
827 | } | |
828 | class = object_class_get_parent(class); | |
829 | } while (class != object_class_by_name(TYPE_DEVICE)); | |
830 | } | |
831 | ||
a7737e44 | 832 | static bool device_get_realized(Object *obj, Error **errp) |
249d4172 AF |
833 | { |
834 | DeviceState *dev = DEVICE(obj); | |
835 | return dev->realized; | |
836 | } | |
837 | ||
40f03bd5 | 838 | static bool check_only_migratable(Object *obj, Error **errp) |
1bfe5f05 JQ |
839 | { |
840 | DeviceClass *dc = DEVICE_GET_CLASS(obj); | |
841 | ||
842 | if (!vmstate_check_only_migratable(dc->vmsd)) { | |
40f03bd5 | 843 | error_setg(errp, "Device %s is not migratable, but " |
1bfe5f05 JQ |
844 | "--only-migratable was specified", |
845 | object_get_typename(obj)); | |
846 | return false; | |
847 | } | |
848 | ||
849 | return true; | |
850 | } | |
851 | ||
a7737e44 | 852 | static void device_set_realized(Object *obj, bool value, Error **errp) |
249d4172 AF |
853 | { |
854 | DeviceState *dev = DEVICE(obj); | |
855 | DeviceClass *dc = DEVICE_GET_CLASS(dev); | |
7716b8ca | 856 | HotplugHandler *hotplug_ctrl; |
5c21ce77 | 857 | BusState *bus; |
249d4172 | 858 | Error *local_err = NULL; |
69382d8b IM |
859 | bool unattached_parent = false; |
860 | static int unattached_count; | |
249d4172 | 861 | |
1a37eca1 | 862 | if (dev->hotplugged && !dc->hotpluggable) { |
c6bd8c70 | 863 | error_setg(errp, QERR_DEVICE_NO_HOTPLUG, object_get_typename(obj)); |
1a37eca1 IM |
864 | return; |
865 | } | |
866 | ||
249d4172 | 867 | if (value && !dev->realized) { |
1bfe5f05 | 868 | if (!check_only_migratable(obj, &local_err)) { |
7562f907 AA |
869 | goto fail; |
870 | } | |
871 | ||
d578029e | 872 | if (!obj->parent) { |
249d4172 AF |
873 | gchar *name = g_strdup_printf("device[%d]", unattached_count++); |
874 | ||
875 | object_property_add_child(container_get(qdev_get_machine(), | |
876 | "/unattached"), | |
d578029e | 877 | name, obj, &error_abort); |
69382d8b | 878 | unattached_parent = true; |
249d4172 AF |
879 | g_free(name); |
880 | } | |
881 | ||
41346263 IM |
882 | hotplug_ctrl = qdev_get_hotplug_handler(dev); |
883 | if (hotplug_ctrl) { | |
884 | hotplug_handler_pre_plug(hotplug_ctrl, dev, &local_err); | |
885 | if (local_err != NULL) { | |
886 | goto fail; | |
887 | } | |
888 | } | |
889 | ||
a7ddba52 IM |
890 | if (dc->realize) { |
891 | dc->realize(dev, &local_err); | |
40f03bd5 VSO |
892 | if (local_err != NULL) { |
893 | goto fail; | |
894 | } | |
1d45a705 GA |
895 | } |
896 | ||
707ff800 PD |
897 | DEVICE_LISTENER_CALL(realize, Forward, dev); |
898 | ||
04162f8f MR |
899 | /* |
900 | * always free/re-initialize here since the value cannot be cleaned up | |
901 | * in device_unrealize due to its usage later on in the unplug path | |
902 | */ | |
903 | g_free(dev->canonical_path); | |
904 | dev->canonical_path = object_get_canonical_path(OBJECT(dev)); | |
905 | ||
1d45a705 | 906 | if (qdev_get_vmsd(dev)) { |
3cad405b | 907 | if (vmstate_register_with_alias_id(VMSTATE_IF(dev), |
1df2c9a2 PX |
908 | VMSTATE_INSTANCE_ID_ANY, |
909 | qdev_get_vmsd(dev), dev, | |
67980031 DDAG |
910 | dev->instance_id_alias, |
911 | dev->alias_required_for_version, | |
912 | &local_err) < 0) { | |
913 | goto post_realize_fail; | |
914 | } | |
249d4172 | 915 | } |
1d45a705 | 916 | |
e755e127 DH |
917 | /* |
918 | * Clear the reset state, in case the object was previously unrealized | |
919 | * with a dirty state. | |
920 | */ | |
921 | resettable_state_clear(&dev->reset); | |
922 | ||
1d45a705 GA |
923 | QLIST_FOREACH(bus, &dev->child_bus, sibling) { |
924 | object_property_set_bool(OBJECT(bus), true, "realized", | |
5c21ce77 | 925 | &local_err); |
1d45a705 GA |
926 | if (local_err != NULL) { |
927 | goto child_realize_fail; | |
5c21ce77 BD |
928 | } |
929 | } | |
1d45a705 | 930 | if (dev->hotplugged) { |
e755e127 DH |
931 | /* |
932 | * Reset the device, as well as its subtree which, at this point, | |
933 | * should be realized too. | |
934 | */ | |
935 | resettable_assert_reset(OBJECT(dev), RESET_TYPE_COLD); | |
936 | resettable_change_parent(OBJECT(dev), OBJECT(dev->parent_bus), | |
937 | NULL); | |
938 | resettable_release_reset(OBJECT(dev), RESET_TYPE_COLD); | |
249d4172 | 939 | } |
352e8da7 | 940 | dev->pending_deleted_event = false; |
25e89788 SH |
941 | |
942 | if (hotplug_ctrl) { | |
8b5e6caf IM |
943 | hotplug_handler_plug(hotplug_ctrl, dev, &local_err); |
944 | if (local_err != NULL) { | |
945 | goto child_realize_fail; | |
946 | } | |
947 | } | |
948 | ||
249d4172 | 949 | } else if (!value && dev->realized) { |
40f03bd5 | 950 | /* We want local_err to track only the first error */ |
5c21ce77 BD |
951 | QLIST_FOREACH(bus, &dev->child_bus, sibling) { |
952 | object_property_set_bool(OBJECT(bus), false, "realized", | |
40f03bd5 | 953 | local_err ? NULL : &local_err); |
5c21ce77 | 954 | } |
cd4520ad | 955 | if (qdev_get_vmsd(dev)) { |
3cad405b | 956 | vmstate_unregister(VMSTATE_IF(dev), qdev_get_vmsd(dev), dev); |
fe6c2117 | 957 | } |
cd4520ad | 958 | if (dc->unrealize) { |
40f03bd5 | 959 | dc->unrealize(dev, local_err ? NULL : &local_err); |
249d4172 | 960 | } |
352e8da7 | 961 | dev->pending_deleted_event = true; |
707ff800 | 962 | DEVICE_LISTENER_CALL(unrealize, Reverse, dev); |
249d4172 | 963 | |
40f03bd5 VSO |
964 | if (local_err != NULL) { |
965 | goto fail; | |
966 | } | |
249d4172 AF |
967 | } |
968 | ||
40f03bd5 | 969 | assert(local_err == NULL); |
c7f8d0f3 | 970 | dev->realized = value; |
1d45a705 GA |
971 | return; |
972 | ||
973 | child_realize_fail: | |
974 | QLIST_FOREACH(bus, &dev->child_bus, sibling) { | |
975 | object_property_set_bool(OBJECT(bus), false, "realized", | |
976 | NULL); | |
977 | } | |
978 | ||
979 | if (qdev_get_vmsd(dev)) { | |
3cad405b | 980 | vmstate_unregister(VMSTATE_IF(dev), qdev_get_vmsd(dev), dev); |
1d45a705 GA |
981 | } |
982 | ||
983 | post_realize_fail: | |
04162f8f MR |
984 | g_free(dev->canonical_path); |
985 | dev->canonical_path = NULL; | |
1d45a705 GA |
986 | if (dc->unrealize) { |
987 | dc->unrealize(dev, NULL); | |
988 | } | |
989 | ||
990 | fail: | |
991 | error_propagate(errp, local_err); | |
69382d8b IM |
992 | if (unattached_parent) { |
993 | object_unparent(OBJECT(dev)); | |
994 | unattached_count--; | |
995 | } | |
249d4172 AF |
996 | } |
997 | ||
a7737e44 | 998 | static bool device_get_hotpluggable(Object *obj, Error **errp) |
1a37eca1 IM |
999 | { |
1000 | DeviceClass *dc = DEVICE_GET_CLASS(obj); | |
1001 | DeviceState *dev = DEVICE(obj); | |
1002 | ||
2b81b35f | 1003 | return dc->hotpluggable && (dev->parent_bus == NULL || |
39b888bd | 1004 | qbus_is_hotpluggable(dev->parent_bus)); |
1a37eca1 IM |
1005 | } |
1006 | ||
40f03bd5 | 1007 | static bool device_get_hotplugged(Object *obj, Error **errp) |
d012ffc1 IM |
1008 | { |
1009 | DeviceState *dev = DEVICE(obj); | |
1010 | ||
1011 | return dev->hotplugged; | |
1012 | } | |
1013 | ||
9674bfe4 AL |
1014 | static void device_initfn(Object *obj) |
1015 | { | |
1016 | DeviceState *dev = DEVICE(obj); | |
9674bfe4 AL |
1017 | |
1018 | if (qdev_hotplug) { | |
1019 | dev->hotplugged = 1; | |
1020 | qdev_hot_added = true; | |
1021 | } | |
1022 | ||
1023 | dev->instance_id_alias = -1; | |
7983c8a3 | 1024 | dev->realized = false; |
a1190ab6 | 1025 | dev->allow_unplug_during_migration = false; |
9674bfe4 | 1026 | |
a5f54290 | 1027 | QLIST_INIT(&dev->gpios); |
9674bfe4 AL |
1028 | } |
1029 | ||
1c3994f6 MAL |
1030 | static void device_post_init(Object *obj) |
1031 | { | |
1a3ec8c1 MA |
1032 | /* |
1033 | * Note: ordered so that the user's global properties take | |
1034 | * precedence. | |
1035 | */ | |
1c3994f6 | 1036 | object_apply_compat_props(obj); |
25f8dd96 | 1037 | qdev_prop_set_globals(DEVICE(obj)); |
99a0b036 EH |
1038 | } |
1039 | ||
60adba37 AL |
1040 | /* Unlink device from bus and free the structure. */ |
1041 | static void device_finalize(Object *obj) | |
1042 | { | |
a5f54290 PC |
1043 | NamedGPIOList *ngl, *next; |
1044 | ||
60adba37 | 1045 | DeviceState *dev = DEVICE(obj); |
a5f54290 PC |
1046 | |
1047 | QLIST_FOREACH_SAFE(ngl, &dev->gpios, node, next) { | |
1048 | QLIST_REMOVE(ngl, node); | |
f173d57a | 1049 | qemu_free_irqs(ngl->in, ngl->num_in); |
a5f54290 PC |
1050 | g_free(ngl->name); |
1051 | g_free(ngl); | |
1052 | /* ngl->out irqs are owned by the other end and should not be freed | |
1053 | * here | |
1054 | */ | |
1055 | } | |
f7b879e0 MR |
1056 | |
1057 | /* Only send event if the device had been completely realized */ | |
1058 | if (dev->pending_deleted_event) { | |
1059 | g_assert(dev->canonical_path); | |
1060 | ||
3ab72385 | 1061 | qapi_event_send_device_deleted(!!dev->id, dev->id, dev->canonical_path); |
f7b879e0 MR |
1062 | g_free(dev->canonical_path); |
1063 | dev->canonical_path = NULL; | |
1064 | } | |
1065 | ||
1066 | qemu_opts_del(dev->opts); | |
60adba37 AL |
1067 | } |
1068 | ||
bce54474 PB |
1069 | static void device_class_base_init(ObjectClass *class, void *data) |
1070 | { | |
1071 | DeviceClass *klass = DEVICE_CLASS(class); | |
1072 | ||
1073 | /* We explicitly look up properties in the superclasses, | |
1074 | * so do not propagate them to the subclasses. | |
1075 | */ | |
385d8f22 | 1076 | klass->props_ = NULL; |
60adba37 AL |
1077 | } |
1078 | ||
5d5b24d0 | 1079 | static void device_unparent(Object *obj) |
667d22d1 PB |
1080 | { |
1081 | DeviceState *dev = DEVICE(obj); | |
06f7f2bb | 1082 | BusState *bus; |
667d22d1 | 1083 | |
5c21ce77 BD |
1084 | if (dev->realized) { |
1085 | object_property_set_bool(obj, false, "realized", NULL); | |
1086 | } | |
06f7f2bb PB |
1087 | while (dev->num_child_bus) { |
1088 | bus = QLIST_FIRST(&dev->child_bus); | |
6780a22c | 1089 | object_unparent(OBJECT(bus)); |
06f7f2bb | 1090 | } |
06f7f2bb | 1091 | if (dev->parent_bus) { |
5d5b24d0 | 1092 | bus_remove_child(dev->parent_bus, dev); |
62d7ba66 PB |
1093 | object_unref(OBJECT(dev->parent_bus)); |
1094 | dev->parent_bus = NULL; | |
5d5b24d0 | 1095 | } |
667d22d1 PB |
1096 | } |
1097 | ||
107b5969 MAL |
1098 | static char * |
1099 | device_vmstate_if_get_id(VMStateIf *obj) | |
1100 | { | |
1101 | DeviceState *dev = DEVICE(obj); | |
1102 | ||
1103 | return qdev_get_dev_path(dev); | |
1104 | } | |
1105 | ||
c11256aa DH |
1106 | /** |
1107 | * device_phases_reset: | |
1108 | * Transition reset method for devices to allow moving | |
1109 | * smoothly from legacy reset method to multi-phases | |
1110 | */ | |
1111 | static void device_phases_reset(DeviceState *dev) | |
1112 | { | |
1113 | ResettableClass *rc = RESETTABLE_GET_CLASS(dev); | |
1114 | ||
1115 | if (rc->phases.enter) { | |
1116 | rc->phases.enter(OBJECT(dev), RESET_TYPE_COLD); | |
1117 | } | |
1118 | if (rc->phases.hold) { | |
1119 | rc->phases.hold(OBJECT(dev)); | |
1120 | } | |
1121 | if (rc->phases.exit) { | |
1122 | rc->phases.exit(OBJECT(dev)); | |
1123 | } | |
1124 | } | |
1125 | ||
1126 | static void device_transitional_reset(Object *obj) | |
1127 | { | |
1128 | DeviceClass *dc = DEVICE_GET_CLASS(obj); | |
1129 | ||
1130 | /* | |
1131 | * This will call either @device_phases_reset (for multi-phases transitioned | |
1132 | * devices) or a device's specific method for not-yet transitioned devices. | |
1133 | * In both case, it does not reset children. | |
1134 | */ | |
1135 | if (dc->reset) { | |
1136 | dc->reset(DEVICE(obj)); | |
1137 | } | |
1138 | } | |
1139 | ||
1140 | /** | |
1141 | * device_get_transitional_reset: | |
1142 | * check if the device's class is ready for multi-phase | |
1143 | */ | |
1144 | static ResettableTrFunction device_get_transitional_reset(Object *obj) | |
1145 | { | |
1146 | DeviceClass *dc = DEVICE_GET_CLASS(obj); | |
1147 | if (dc->reset != device_phases_reset) { | |
1148 | /* | |
1149 | * dc->reset has been overridden by a subclass, | |
1150 | * the device is not ready for multi phase yet. | |
1151 | */ | |
1152 | return device_transitional_reset; | |
1153 | } | |
1154 | return NULL; | |
1155 | } | |
1156 | ||
667d22d1 PB |
1157 | static void device_class_init(ObjectClass *class, void *data) |
1158 | { | |
249d4172 | 1159 | DeviceClass *dc = DEVICE_CLASS(class); |
107b5969 | 1160 | VMStateIfClass *vc = VMSTATE_IF_CLASS(class); |
c11256aa | 1161 | ResettableClass *rc = RESETTABLE_CLASS(class); |
249d4172 | 1162 | |
5d5b24d0 | 1163 | class->unparent = device_unparent; |
267a3264 IM |
1164 | |
1165 | /* by default all devices were considered as hotpluggable, | |
1166 | * so with intent to check it in generic qdev_unplug() / | |
1167 | * device_set_realized() functions make every device | |
1168 | * hotpluggable. Devices that shouldn't be hotpluggable, | |
1169 | * should override it in their class_init() | |
1170 | */ | |
1171 | dc->hotpluggable = true; | |
e90f2a8c | 1172 | dc->user_creatable = true; |
107b5969 | 1173 | vc->get_id = device_vmstate_if_get_id; |
c11256aa DH |
1174 | rc->get_state = device_get_reset_state; |
1175 | rc->child_foreach = device_reset_child_foreach; | |
1176 | ||
1177 | /* | |
1178 | * @device_phases_reset is put as the default reset method below, allowing | |
1179 | * to do the multi-phase transition from base classes to leaf classes. It | |
1180 | * allows a legacy-reset Device class to extend a multi-phases-reset | |
1181 | * Device class for the following reason: | |
1182 | * + If a base class B has been moved to multi-phase, then it does not | |
1183 | * override this default reset method and may have defined phase methods. | |
1184 | * + A child class C (extending class B) which uses | |
1185 | * device_class_set_parent_reset() (or similar means) to override the | |
1186 | * reset method will still work as expected. @device_phases_reset function | |
1187 | * will be registered as the parent reset method and effectively call | |
1188 | * parent reset phases. | |
1189 | */ | |
1190 | dc->reset = device_phases_reset; | |
1191 | rc->get_transitional_function = device_get_transitional_reset; | |
c68fc935 MAL |
1192 | |
1193 | object_class_property_add_bool(class, "realized", | |
1194 | device_get_realized, device_set_realized, | |
1195 | &error_abort); | |
1196 | object_class_property_add_bool(class, "hotpluggable", | |
1197 | device_get_hotpluggable, NULL, | |
1198 | &error_abort); | |
1199 | object_class_property_add_bool(class, "hotplugged", | |
1200 | device_get_hotplugged, NULL, | |
1201 | &error_abort); | |
1202 | object_class_property_add_link(class, "parent_bus", TYPE_BUS, | |
1203 | offsetof(DeviceState, parent_bus), NULL, 0, | |
1204 | &error_abort); | |
667d22d1 PB |
1205 | } |
1206 | ||
4f67d30b MAL |
1207 | void device_class_set_props(DeviceClass *dc, Property *props) |
1208 | { | |
77b06bba MAL |
1209 | Property *prop; |
1210 | ||
385d8f22 | 1211 | dc->props_ = props; |
77b06bba MAL |
1212 | for (prop = props; prop && prop->name; prop++) { |
1213 | qdev_class_add_legacy_property(dc, prop); | |
1214 | qdev_class_add_property(dc, prop); | |
1215 | } | |
4f67d30b MAL |
1216 | } |
1217 | ||
46795cf2 PMD |
1218 | void device_class_set_parent_reset(DeviceClass *dc, |
1219 | DeviceReset dev_reset, | |
1220 | DeviceReset *parent_reset) | |
1221 | { | |
1222 | *parent_reset = dc->reset; | |
1223 | dc->reset = dev_reset; | |
1224 | } | |
1225 | ||
1226 | void device_class_set_parent_realize(DeviceClass *dc, | |
1227 | DeviceRealize dev_realize, | |
1228 | DeviceRealize *parent_realize) | |
1229 | { | |
1230 | *parent_realize = dc->realize; | |
1231 | dc->realize = dev_realize; | |
1232 | } | |
1233 | ||
1234 | void device_class_set_parent_unrealize(DeviceClass *dc, | |
1235 | DeviceUnrealize dev_unrealize, | |
1236 | DeviceUnrealize *parent_unrealize) | |
1237 | { | |
1238 | *parent_unrealize = dc->unrealize; | |
1239 | dc->unrealize = dev_unrealize; | |
1240 | } | |
1241 | ||
f703a04c | 1242 | void device_legacy_reset(DeviceState *dev) |
94afdadc AL |
1243 | { |
1244 | DeviceClass *klass = DEVICE_GET_CLASS(dev); | |
1245 | ||
70804c83 | 1246 | trace_qdev_reset(dev, object_get_typename(OBJECT(dev))); |
94afdadc AL |
1247 | if (klass->reset) { |
1248 | klass->reset(dev); | |
1249 | } | |
1250 | } | |
1251 | ||
f05f6b4a PB |
1252 | Object *qdev_get_machine(void) |
1253 | { | |
1254 | static Object *dev; | |
1255 | ||
1256 | if (dev == NULL) { | |
dfe47e70 | 1257 | dev = container_get(object_get_root(), "/machine"); |
f05f6b4a PB |
1258 | } |
1259 | ||
1260 | return dev; | |
1261 | } | |
1262 | ||
8c43a6f0 | 1263 | static const TypeInfo device_type_info = { |
32fea402 AL |
1264 | .name = TYPE_DEVICE, |
1265 | .parent = TYPE_OBJECT, | |
1266 | .instance_size = sizeof(DeviceState), | |
9674bfe4 | 1267 | .instance_init = device_initfn, |
99a0b036 | 1268 | .instance_post_init = device_post_init, |
60adba37 | 1269 | .instance_finalize = device_finalize, |
bce54474 | 1270 | .class_base_init = device_class_base_init, |
667d22d1 | 1271 | .class_init = device_class_init, |
32fea402 AL |
1272 | .abstract = true, |
1273 | .class_size = sizeof(DeviceClass), | |
107b5969 MAL |
1274 | .interfaces = (InterfaceInfo[]) { |
1275 | { TYPE_VMSTATE_IF }, | |
c11256aa | 1276 | { TYPE_RESETTABLE_INTERFACE }, |
107b5969 MAL |
1277 | { } |
1278 | } | |
32fea402 AL |
1279 | }; |
1280 | ||
83f7d43a | 1281 | static void qdev_register_types(void) |
32fea402 AL |
1282 | { |
1283 | type_register_static(&device_type_info); | |
1284 | } | |
1285 | ||
83f7d43a | 1286 | type_init(qdev_register_types) |