sm501: Add missing arbitration control register
[qemu.git] / hw / core / qdev.c
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
17 * License along with this library; if not, see <http://www.gnu.org/licenses/>.
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
28 #include "qemu/osdep.h"
29 #include "hw/qdev.h"
30 #include "hw/fw-path-provider.h"
31 #include "sysemu/sysemu.h"
32 #include "qapi/qmp/qerror.h"
33 #include "qapi/visitor.h"
34 #include "qapi/qmp/qjson.h"
35 #include "qemu/error-report.h"
36 #include "hw/hotplug.h"
37 #include "hw/boards.h"
38 #include "hw/sysbus.h"
39 #include "qapi-event.h"
40 #include "migration/migration.h"
41
42 bool qdev_hotplug = false;
43 static bool qdev_hot_added = false;
44 bool qdev_hot_removed = false;
45
46 const VMStateDescription *qdev_get_vmsd(DeviceState *dev)
47 {
48 DeviceClass *dc = DEVICE_GET_CLASS(dev);
49 return dc->vmsd;
50 }
51
52 const char *qdev_fw_name(DeviceState *dev)
53 {
54 DeviceClass *dc = DEVICE_GET_CLASS(dev);
55
56 if (dc->fw_name) {
57 return dc->fw_name;
58 }
59
60 return object_get_typename(OBJECT(dev));
61 }
62
63 static void bus_remove_child(BusState *bus, DeviceState *child)
64 {
65 BusChild *kid;
66
67 QTAILQ_FOREACH(kid, &bus->children, sibling) {
68 if (kid->child == child) {
69 char name[32];
70
71 snprintf(name, sizeof(name), "child[%d]", kid->index);
72 QTAILQ_REMOVE(&bus->children, kid, sibling);
73
74 /* This gives back ownership of kid->child back to us. */
75 object_property_del(OBJECT(bus), name, NULL);
76 object_unref(OBJECT(kid->child));
77 g_free(kid);
78 return;
79 }
80 }
81 }
82
83 static void bus_add_child(BusState *bus, DeviceState *child)
84 {
85 char name[32];
86 BusChild *kid = g_malloc0(sizeof(*kid));
87
88 kid->index = bus->max_index++;
89 kid->child = child;
90 object_ref(OBJECT(kid->child));
91
92 QTAILQ_INSERT_HEAD(&bus->children, kid, sibling);
93
94 /* This transfers ownership of kid->child to the property. */
95 snprintf(name, sizeof(name), "child[%d]", kid->index);
96 object_property_add_link(OBJECT(bus), name,
97 object_get_typename(OBJECT(child)),
98 (Object **)&kid->child,
99 NULL, /* read-only property */
100 0, /* return ownership on prop deletion */
101 NULL);
102 }
103
104 void qdev_set_parent_bus(DeviceState *dev, BusState *bus)
105 {
106 bool replugging = dev->parent_bus != NULL;
107
108 if (replugging) {
109 /* Keep a reference to the device while it's not plugged into
110 * any bus, to avoid it potentially evaporating when it is
111 * dereffed in bus_remove_child().
112 */
113 object_ref(OBJECT(dev));
114 bus_remove_child(dev->parent_bus, dev);
115 object_unref(OBJECT(dev->parent_bus));
116 }
117 dev->parent_bus = bus;
118 object_ref(OBJECT(bus));
119 bus_add_child(bus, dev);
120 if (replugging) {
121 object_unref(OBJECT(dev));
122 }
123 }
124
125 /* Create a new device. This only initializes the device state
126 structure and allows properties to be set. The device still needs
127 to be realized. See qdev-core.h. */
128 DeviceState *qdev_create(BusState *bus, const char *name)
129 {
130 DeviceState *dev;
131
132 dev = qdev_try_create(bus, name);
133 if (!dev) {
134 if (bus) {
135 error_report("Unknown device '%s' for bus '%s'", name,
136 object_get_typename(OBJECT(bus)));
137 } else {
138 error_report("Unknown device '%s' for default sysbus", name);
139 }
140 abort();
141 }
142
143 return dev;
144 }
145
146 DeviceState *qdev_try_create(BusState *bus, const char *type)
147 {
148 DeviceState *dev;
149
150 if (object_class_by_name(type) == NULL) {
151 return NULL;
152 }
153 dev = DEVICE(object_new(type));
154 if (!dev) {
155 return NULL;
156 }
157
158 if (!bus) {
159 /* Assert that the device really is a SysBusDevice before
160 * we put it onto the sysbus. Non-sysbus devices which aren't
161 * being put onto a bus should be created with object_new(TYPE_FOO),
162 * not qdev_create(NULL, TYPE_FOO).
163 */
164 g_assert(object_dynamic_cast(OBJECT(dev), TYPE_SYS_BUS_DEVICE));
165 bus = sysbus_get_default();
166 }
167
168 qdev_set_parent_bus(dev, bus);
169 object_unref(OBJECT(dev));
170 return dev;
171 }
172
173 static QTAILQ_HEAD(device_listeners, DeviceListener) device_listeners
174 = QTAILQ_HEAD_INITIALIZER(device_listeners);
175
176 enum ListenerDirection { Forward, Reverse };
177
178 #define DEVICE_LISTENER_CALL(_callback, _direction, _args...) \
179 do { \
180 DeviceListener *_listener; \
181 \
182 switch (_direction) { \
183 case Forward: \
184 QTAILQ_FOREACH(_listener, &device_listeners, link) { \
185 if (_listener->_callback) { \
186 _listener->_callback(_listener, ##_args); \
187 } \
188 } \
189 break; \
190 case Reverse: \
191 QTAILQ_FOREACH_REVERSE(_listener, &device_listeners, \
192 device_listeners, link) { \
193 if (_listener->_callback) { \
194 _listener->_callback(_listener, ##_args); \
195 } \
196 } \
197 break; \
198 default: \
199 abort(); \
200 } \
201 } while (0)
202
203 static int device_listener_add(DeviceState *dev, void *opaque)
204 {
205 DEVICE_LISTENER_CALL(realize, Forward, dev);
206
207 return 0;
208 }
209
210 void device_listener_register(DeviceListener *listener)
211 {
212 QTAILQ_INSERT_TAIL(&device_listeners, listener, link);
213
214 qbus_walk_children(sysbus_get_default(), NULL, NULL, device_listener_add,
215 NULL, NULL);
216 }
217
218 void device_listener_unregister(DeviceListener *listener)
219 {
220 QTAILQ_REMOVE(&device_listeners, listener, link);
221 }
222
223 static void device_realize(DeviceState *dev, Error **errp)
224 {
225 DeviceClass *dc = DEVICE_GET_CLASS(dev);
226
227 if (dc->init) {
228 int rc = dc->init(dev);
229 if (rc < 0) {
230 error_setg(errp, "Device initialization failed.");
231 return;
232 }
233 }
234 }
235
236 static void device_unrealize(DeviceState *dev, Error **errp)
237 {
238 DeviceClass *dc = DEVICE_GET_CLASS(dev);
239
240 if (dc->exit) {
241 int rc = dc->exit(dev);
242 if (rc < 0) {
243 error_setg(errp, "Device exit failed.");
244 return;
245 }
246 }
247 }
248
249 void qdev_set_legacy_instance_id(DeviceState *dev, int alias_id,
250 int required_for_version)
251 {
252 assert(!dev->realized);
253 dev->instance_id_alias = alias_id;
254 dev->alias_required_for_version = required_for_version;
255 }
256
257 HotplugHandler *qdev_get_hotplug_handler(DeviceState *dev)
258 {
259 HotplugHandler *hotplug_ctrl = NULL;
260
261 if (dev->parent_bus && dev->parent_bus->hotplug_handler) {
262 hotplug_ctrl = dev->parent_bus->hotplug_handler;
263 } else if (object_dynamic_cast(qdev_get_machine(), TYPE_MACHINE)) {
264 MachineState *machine = MACHINE(qdev_get_machine());
265 MachineClass *mc = MACHINE_GET_CLASS(machine);
266
267 if (mc->get_hotplug_handler) {
268 hotplug_ctrl = mc->get_hotplug_handler(machine, dev);
269 }
270 }
271 return hotplug_ctrl;
272 }
273
274 static int qdev_reset_one(DeviceState *dev, void *opaque)
275 {
276 device_reset(dev);
277
278 return 0;
279 }
280
281 static int qbus_reset_one(BusState *bus, void *opaque)
282 {
283 BusClass *bc = BUS_GET_CLASS(bus);
284 if (bc->reset) {
285 bc->reset(bus);
286 }
287 return 0;
288 }
289
290 void qdev_reset_all(DeviceState *dev)
291 {
292 qdev_walk_children(dev, NULL, NULL, qdev_reset_one, qbus_reset_one, NULL);
293 }
294
295 void qdev_reset_all_fn(void *opaque)
296 {
297 qdev_reset_all(DEVICE(opaque));
298 }
299
300 void qbus_reset_all(BusState *bus)
301 {
302 qbus_walk_children(bus, NULL, NULL, qdev_reset_one, qbus_reset_one, NULL);
303 }
304
305 void qbus_reset_all_fn(void *opaque)
306 {
307 BusState *bus = opaque;
308 qbus_reset_all(bus);
309 }
310
311 /* can be used as ->unplug() callback for the simple cases */
312 void qdev_simple_device_unplug_cb(HotplugHandler *hotplug_dev,
313 DeviceState *dev, Error **errp)
314 {
315 /* just zap it */
316 object_unparent(OBJECT(dev));
317 }
318
319 /*
320 * Realize @dev.
321 * Device properties should be set before calling this function. IRQs
322 * and MMIO regions should be connected/mapped after calling this
323 * function.
324 * On failure, report an error with error_report() and terminate the
325 * program. This is okay during machine creation. Don't use for
326 * hotplug, because there callers need to recover from failure.
327 * Exception: if you know the device's init() callback can't fail,
328 * then qdev_init_nofail() can't fail either, and is therefore usable
329 * even then. But relying on the device implementation that way is
330 * somewhat unclean, and best avoided.
331 */
332 void qdev_init_nofail(DeviceState *dev)
333 {
334 Error *err = NULL;
335
336 assert(!dev->realized);
337
338 object_ref(OBJECT(dev));
339 object_property_set_bool(OBJECT(dev), true, "realized", &err);
340 if (err) {
341 error_reportf_err(err, "Initialization of device %s failed: ",
342 object_get_typename(OBJECT(dev)));
343 exit(1);
344 }
345 object_unref(OBJECT(dev));
346 }
347
348 void qdev_machine_creation_done(void)
349 {
350 /*
351 * ok, initial machine setup is done, starting from now we can
352 * only create hotpluggable devices
353 */
354 qdev_hotplug = true;
355 }
356
357 bool qdev_machine_modified(void)
358 {
359 return qdev_hot_added || qdev_hot_removed;
360 }
361
362 BusState *qdev_get_parent_bus(DeviceState *dev)
363 {
364 return dev->parent_bus;
365 }
366
367 static NamedGPIOList *qdev_get_named_gpio_list(DeviceState *dev,
368 const char *name)
369 {
370 NamedGPIOList *ngl;
371
372 QLIST_FOREACH(ngl, &dev->gpios, node) {
373 /* NULL is a valid and matchable name, otherwise do a normal
374 * strcmp match.
375 */
376 if ((!ngl->name && !name) ||
377 (name && ngl->name && strcmp(name, ngl->name) == 0)) {
378 return ngl;
379 }
380 }
381
382 ngl = g_malloc0(sizeof(*ngl));
383 ngl->name = g_strdup(name);
384 QLIST_INSERT_HEAD(&dev->gpios, ngl, node);
385 return ngl;
386 }
387
388 void qdev_init_gpio_in_named(DeviceState *dev, qemu_irq_handler handler,
389 const char *name, int n)
390 {
391 int i;
392 NamedGPIOList *gpio_list = qdev_get_named_gpio_list(dev, name);
393
394 assert(gpio_list->num_out == 0 || !name);
395 gpio_list->in = qemu_extend_irqs(gpio_list->in, gpio_list->num_in, handler,
396 dev, n);
397
398 if (!name) {
399 name = "unnamed-gpio-in";
400 }
401 for (i = gpio_list->num_in; i < gpio_list->num_in + n; i++) {
402 gchar *propname = g_strdup_printf("%s[%u]", name, i);
403
404 object_property_add_child(OBJECT(dev), propname,
405 OBJECT(gpio_list->in[i]), &error_abort);
406 g_free(propname);
407 }
408
409 gpio_list->num_in += n;
410 }
411
412 void qdev_init_gpio_in(DeviceState *dev, qemu_irq_handler handler, int n)
413 {
414 qdev_init_gpio_in_named(dev, handler, NULL, n);
415 }
416
417 void qdev_init_gpio_out_named(DeviceState *dev, qemu_irq *pins,
418 const char *name, int n)
419 {
420 int i;
421 NamedGPIOList *gpio_list = qdev_get_named_gpio_list(dev, name);
422
423 assert(gpio_list->num_in == 0 || !name);
424
425 if (!name) {
426 name = "unnamed-gpio-out";
427 }
428 memset(pins, 0, sizeof(*pins) * n);
429 for (i = 0; i < n; ++i) {
430 gchar *propname = g_strdup_printf("%s[%u]", name,
431 gpio_list->num_out + i);
432
433 object_property_add_link(OBJECT(dev), propname, TYPE_IRQ,
434 (Object **)&pins[i],
435 object_property_allow_set_link,
436 OBJ_PROP_LINK_UNREF_ON_RELEASE,
437 &error_abort);
438 g_free(propname);
439 }
440 gpio_list->num_out += n;
441 }
442
443 void qdev_init_gpio_out(DeviceState *dev, qemu_irq *pins, int n)
444 {
445 qdev_init_gpio_out_named(dev, pins, NULL, n);
446 }
447
448 qemu_irq qdev_get_gpio_in_named(DeviceState *dev, const char *name, int n)
449 {
450 NamedGPIOList *gpio_list = qdev_get_named_gpio_list(dev, name);
451
452 assert(n >= 0 && n < gpio_list->num_in);
453 return gpio_list->in[n];
454 }
455
456 qemu_irq qdev_get_gpio_in(DeviceState *dev, int n)
457 {
458 return qdev_get_gpio_in_named(dev, NULL, n);
459 }
460
461 void qdev_connect_gpio_out_named(DeviceState *dev, const char *name, int n,
462 qemu_irq pin)
463 {
464 char *propname = g_strdup_printf("%s[%d]",
465 name ? name : "unnamed-gpio-out", n);
466 if (pin) {
467 /* We need a name for object_property_set_link to work. If the
468 * object has a parent, object_property_add_child will come back
469 * with an error without doing anything. If it has none, it will
470 * never fail. So we can just call it with a NULL Error pointer.
471 */
472 object_property_add_child(container_get(qdev_get_machine(),
473 "/unattached"),
474 "non-qdev-gpio[*]", OBJECT(pin), NULL);
475 }
476 object_property_set_link(OBJECT(dev), OBJECT(pin), propname, &error_abort);
477 g_free(propname);
478 }
479
480 qemu_irq qdev_get_gpio_out_connector(DeviceState *dev, const char *name, int n)
481 {
482 char *propname = g_strdup_printf("%s[%d]",
483 name ? name : "unnamed-gpio-out", n);
484
485 qemu_irq ret = (qemu_irq)object_property_get_link(OBJECT(dev), propname,
486 NULL);
487
488 return ret;
489 }
490
491 /* disconnect a GPIO output, returning the disconnected input (if any) */
492
493 static qemu_irq qdev_disconnect_gpio_out_named(DeviceState *dev,
494 const char *name, int n)
495 {
496 char *propname = g_strdup_printf("%s[%d]",
497 name ? name : "unnamed-gpio-out", n);
498
499 qemu_irq ret = (qemu_irq)object_property_get_link(OBJECT(dev), propname,
500 NULL);
501 if (ret) {
502 object_property_set_link(OBJECT(dev), NULL, propname, NULL);
503 }
504 g_free(propname);
505 return ret;
506 }
507
508 qemu_irq qdev_intercept_gpio_out(DeviceState *dev, qemu_irq icpt,
509 const char *name, int n)
510 {
511 qemu_irq disconnected = qdev_disconnect_gpio_out_named(dev, name, n);
512 qdev_connect_gpio_out_named(dev, name, n, icpt);
513 return disconnected;
514 }
515
516 void qdev_connect_gpio_out(DeviceState * dev, int n, qemu_irq pin)
517 {
518 qdev_connect_gpio_out_named(dev, NULL, n, pin);
519 }
520
521 void qdev_pass_gpios(DeviceState *dev, DeviceState *container,
522 const char *name)
523 {
524 int i;
525 NamedGPIOList *ngl = qdev_get_named_gpio_list(dev, name);
526
527 for (i = 0; i < ngl->num_in; i++) {
528 const char *nm = ngl->name ? ngl->name : "unnamed-gpio-in";
529 char *propname = g_strdup_printf("%s[%d]", nm, i);
530
531 object_property_add_alias(OBJECT(container), propname,
532 OBJECT(dev), propname,
533 &error_abort);
534 g_free(propname);
535 }
536 for (i = 0; i < ngl->num_out; i++) {
537 const char *nm = ngl->name ? ngl->name : "unnamed-gpio-out";
538 char *propname = g_strdup_printf("%s[%d]", nm, i);
539
540 object_property_add_alias(OBJECT(container), propname,
541 OBJECT(dev), propname,
542 &error_abort);
543 g_free(propname);
544 }
545 QLIST_REMOVE(ngl, node);
546 QLIST_INSERT_HEAD(&container->gpios, ngl, node);
547 }
548
549 BusState *qdev_get_child_bus(DeviceState *dev, const char *name)
550 {
551 BusState *bus;
552 Object *child = object_resolve_path_component(OBJECT(dev), name);
553
554 bus = (BusState *)object_dynamic_cast(child, TYPE_BUS);
555 if (bus) {
556 return bus;
557 }
558
559 QLIST_FOREACH(bus, &dev->child_bus, sibling) {
560 if (strcmp(name, bus->name) == 0) {
561 return bus;
562 }
563 }
564 return NULL;
565 }
566
567 int qdev_walk_children(DeviceState *dev,
568 qdev_walkerfn *pre_devfn, qbus_walkerfn *pre_busfn,
569 qdev_walkerfn *post_devfn, qbus_walkerfn *post_busfn,
570 void *opaque)
571 {
572 BusState *bus;
573 int err;
574
575 if (pre_devfn) {
576 err = pre_devfn(dev, opaque);
577 if (err) {
578 return err;
579 }
580 }
581
582 QLIST_FOREACH(bus, &dev->child_bus, sibling) {
583 err = qbus_walk_children(bus, pre_devfn, pre_busfn,
584 post_devfn, post_busfn, opaque);
585 if (err < 0) {
586 return err;
587 }
588 }
589
590 if (post_devfn) {
591 err = post_devfn(dev, opaque);
592 if (err) {
593 return err;
594 }
595 }
596
597 return 0;
598 }
599
600 DeviceState *qdev_find_recursive(BusState *bus, const char *id)
601 {
602 BusChild *kid;
603 DeviceState *ret;
604 BusState *child;
605
606 QTAILQ_FOREACH(kid, &bus->children, sibling) {
607 DeviceState *dev = kid->child;
608
609 if (dev->id && strcmp(dev->id, id) == 0) {
610 return dev;
611 }
612
613 QLIST_FOREACH(child, &dev->child_bus, sibling) {
614 ret = qdev_find_recursive(child, id);
615 if (ret) {
616 return ret;
617 }
618 }
619 }
620 return NULL;
621 }
622
623 static char *bus_get_fw_dev_path(BusState *bus, DeviceState *dev)
624 {
625 BusClass *bc = BUS_GET_CLASS(bus);
626
627 if (bc->get_fw_dev_path) {
628 return bc->get_fw_dev_path(dev);
629 }
630
631 return NULL;
632 }
633
634 static char *qdev_get_fw_dev_path_from_handler(BusState *bus, DeviceState *dev)
635 {
636 Object *obj = OBJECT(dev);
637 char *d = NULL;
638
639 while (!d && obj->parent) {
640 obj = obj->parent;
641 d = fw_path_provider_try_get_dev_path(obj, bus, dev);
642 }
643 return d;
644 }
645
646 char *qdev_get_own_fw_dev_path_from_handler(BusState *bus, DeviceState *dev)
647 {
648 Object *obj = OBJECT(dev);
649
650 return fw_path_provider_try_get_dev_path(obj, bus, dev);
651 }
652
653 static int qdev_get_fw_dev_path_helper(DeviceState *dev, char *p, int size)
654 {
655 int l = 0;
656
657 if (dev && dev->parent_bus) {
658 char *d;
659 l = qdev_get_fw_dev_path_helper(dev->parent_bus->parent, p, size);
660 d = qdev_get_fw_dev_path_from_handler(dev->parent_bus, dev);
661 if (!d) {
662 d = bus_get_fw_dev_path(dev->parent_bus, dev);
663 }
664 if (d) {
665 l += snprintf(p + l, size - l, "%s", d);
666 g_free(d);
667 } else {
668 return l;
669 }
670 }
671 l += snprintf(p + l , size - l, "/");
672
673 return l;
674 }
675
676 char* qdev_get_fw_dev_path(DeviceState *dev)
677 {
678 char path[128];
679 int l;
680
681 l = qdev_get_fw_dev_path_helper(dev, path, 128);
682
683 path[l-1] = '\0';
684
685 return g_strdup(path);
686 }
687
688 char *qdev_get_dev_path(DeviceState *dev)
689 {
690 BusClass *bc;
691
692 if (!dev || !dev->parent_bus) {
693 return NULL;
694 }
695
696 bc = BUS_GET_CLASS(dev->parent_bus);
697 if (bc->get_dev_path) {
698 return bc->get_dev_path(dev);
699 }
700
701 return NULL;
702 }
703
704 /**
705 * Legacy property handling
706 */
707
708 static void qdev_get_legacy_property(Object *obj, Visitor *v,
709 const char *name, void *opaque,
710 Error **errp)
711 {
712 DeviceState *dev = DEVICE(obj);
713 Property *prop = opaque;
714
715 char buffer[1024];
716 char *ptr = buffer;
717
718 prop->info->print(dev, prop, buffer, sizeof(buffer));
719 visit_type_str(v, name, &ptr, errp);
720 }
721
722 /**
723 * qdev_property_add_legacy:
724 * @dev: Device to add the property to.
725 * @prop: The qdev property definition.
726 * @errp: location to store error information.
727 *
728 * Add a legacy QOM property to @dev for qdev property @prop.
729 * On error, store error in @errp.
730 *
731 * Legacy properties are string versions of QOM properties. The format of
732 * the string depends on the property type. Legacy properties are only
733 * needed for "info qtree".
734 *
735 * Do not use this is new code! QOM Properties added through this interface
736 * will be given names in the "legacy" namespace.
737 */
738 static void qdev_property_add_legacy(DeviceState *dev, Property *prop,
739 Error **errp)
740 {
741 gchar *name;
742
743 /* Register pointer properties as legacy properties */
744 if (!prop->info->print && prop->info->get) {
745 return;
746 }
747
748 name = g_strdup_printf("legacy-%s", prop->name);
749 object_property_add(OBJECT(dev), name, "str",
750 prop->info->print ? qdev_get_legacy_property : prop->info->get,
751 NULL,
752 NULL,
753 prop, errp);
754
755 g_free(name);
756 }
757
758 /**
759 * qdev_property_add_static:
760 * @dev: Device to add the property to.
761 * @prop: The qdev property definition.
762 * @errp: location to store error information.
763 *
764 * Add a static QOM property to @dev for qdev property @prop.
765 * On error, store error in @errp. Static properties access data in a struct.
766 * The type of the QOM property is derived from prop->info.
767 */
768 void qdev_property_add_static(DeviceState *dev, Property *prop,
769 Error **errp)
770 {
771 Error *local_err = NULL;
772 Object *obj = OBJECT(dev);
773
774 /*
775 * TODO qdev_prop_ptr does not have getters or setters. It must
776 * go now that it can be replaced with links. The test should be
777 * removed along with it: all static properties are read/write.
778 */
779 if (!prop->info->get && !prop->info->set) {
780 return;
781 }
782
783 object_property_add(obj, prop->name, prop->info->name,
784 prop->info->get, prop->info->set,
785 prop->info->release,
786 prop, &local_err);
787
788 if (local_err) {
789 error_propagate(errp, local_err);
790 return;
791 }
792
793 object_property_set_description(obj, prop->name,
794 prop->info->description,
795 &error_abort);
796
797 if (prop->qtype == QTYPE_NONE) {
798 return;
799 }
800
801 if (prop->qtype == QTYPE_QBOOL) {
802 object_property_set_bool(obj, prop->defval, prop->name, &error_abort);
803 } else if (prop->info->enum_table) {
804 object_property_set_str(obj, prop->info->enum_table[prop->defval],
805 prop->name, &error_abort);
806 } else if (prop->qtype == QTYPE_QINT) {
807 object_property_set_int(obj, prop->defval, prop->name, &error_abort);
808 }
809 }
810
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
823 for (prop = dc->props; prop && prop->name; prop++) {
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
832 static int qdev_add_hotpluggable_device(Object *obj, void *opaque)
833 {
834 GSList **list = opaque;
835 DeviceState *dev = (DeviceState *)object_dynamic_cast(OBJECT(obj),
836 TYPE_DEVICE);
837
838 if (dev == NULL) {
839 return 0;
840 }
841
842 if (dev->realized && object_property_get_bool(obj, "hotpluggable", NULL)) {
843 *list = g_slist_append(*list, dev);
844 }
845
846 return 0;
847 }
848
849 GSList *qdev_build_hotpluggable_device_list(Object *peripheral)
850 {
851 GSList *list = NULL;
852
853 object_child_foreach(peripheral, qdev_add_hotpluggable_device, &list);
854
855 return list;
856 }
857
858 static bool device_get_realized(Object *obj, Error **errp)
859 {
860 DeviceState *dev = DEVICE(obj);
861 return dev->realized;
862 }
863
864 static void device_set_realized(Object *obj, bool value, Error **errp)
865 {
866 DeviceState *dev = DEVICE(obj);
867 DeviceClass *dc = DEVICE_GET_CLASS(dev);
868 HotplugHandler *hotplug_ctrl;
869 BusState *bus;
870 Error *local_err = NULL;
871 bool unattached_parent = false;
872 static int unattached_count;
873 int ret;
874
875 if (dev->hotplugged && !dc->hotpluggable) {
876 error_setg(errp, QERR_DEVICE_NO_HOTPLUG, object_get_typename(obj));
877 return;
878 }
879
880 if (value && !dev->realized) {
881 ret = check_migratable(obj, &local_err);
882 if (ret < 0) {
883 goto fail;
884 }
885
886 if (!obj->parent) {
887 gchar *name = g_strdup_printf("device[%d]", unattached_count++);
888
889 object_property_add_child(container_get(qdev_get_machine(),
890 "/unattached"),
891 name, obj, &error_abort);
892 unattached_parent = true;
893 g_free(name);
894 }
895
896 hotplug_ctrl = qdev_get_hotplug_handler(dev);
897 if (hotplug_ctrl) {
898 hotplug_handler_pre_plug(hotplug_ctrl, dev, &local_err);
899 if (local_err != NULL) {
900 goto fail;
901 }
902 }
903
904 if (dc->realize) {
905 dc->realize(dev, &local_err);
906 }
907
908 if (local_err != NULL) {
909 goto fail;
910 }
911
912 DEVICE_LISTENER_CALL(realize, Forward, dev);
913
914 if (hotplug_ctrl) {
915 hotplug_handler_plug(hotplug_ctrl, dev, &local_err);
916 }
917
918 if (local_err != NULL) {
919 goto post_realize_fail;
920 }
921
922 if (qdev_get_vmsd(dev)) {
923 if (vmstate_register_with_alias_id(dev, -1, qdev_get_vmsd(dev), dev,
924 dev->instance_id_alias,
925 dev->alias_required_for_version,
926 &local_err) < 0) {
927 goto post_realize_fail;
928 }
929 }
930
931 QLIST_FOREACH(bus, &dev->child_bus, sibling) {
932 object_property_set_bool(OBJECT(bus), true, "realized",
933 &local_err);
934 if (local_err != NULL) {
935 goto child_realize_fail;
936 }
937 }
938 if (dev->hotplugged) {
939 device_reset(dev);
940 }
941 dev->pending_deleted_event = false;
942 } else if (!value && dev->realized) {
943 Error **local_errp = NULL;
944 QLIST_FOREACH(bus, &dev->child_bus, sibling) {
945 local_errp = local_err ? NULL : &local_err;
946 object_property_set_bool(OBJECT(bus), false, "realized",
947 local_errp);
948 }
949 if (qdev_get_vmsd(dev)) {
950 vmstate_unregister(dev, qdev_get_vmsd(dev), dev);
951 }
952 if (dc->unrealize) {
953 local_errp = local_err ? NULL : &local_err;
954 dc->unrealize(dev, local_errp);
955 }
956 dev->pending_deleted_event = true;
957 DEVICE_LISTENER_CALL(unrealize, Reverse, dev);
958 }
959
960 if (local_err != NULL) {
961 goto fail;
962 }
963
964 dev->realized = value;
965 return;
966
967 child_realize_fail:
968 QLIST_FOREACH(bus, &dev->child_bus, sibling) {
969 object_property_set_bool(OBJECT(bus), false, "realized",
970 NULL);
971 }
972
973 if (qdev_get_vmsd(dev)) {
974 vmstate_unregister(dev, qdev_get_vmsd(dev), dev);
975 }
976
977 post_realize_fail:
978 if (dc->unrealize) {
979 dc->unrealize(dev, NULL);
980 }
981
982 fail:
983 error_propagate(errp, local_err);
984 if (unattached_parent) {
985 object_unparent(OBJECT(dev));
986 unattached_count--;
987 }
988 }
989
990 static bool device_get_hotpluggable(Object *obj, Error **errp)
991 {
992 DeviceClass *dc = DEVICE_GET_CLASS(obj);
993 DeviceState *dev = DEVICE(obj);
994
995 return dc->hotpluggable && (dev->parent_bus == NULL ||
996 qbus_is_hotpluggable(dev->parent_bus));
997 }
998
999 static bool device_get_hotplugged(Object *obj, Error **err)
1000 {
1001 DeviceState *dev = DEVICE(obj);
1002
1003 return dev->hotplugged;
1004 }
1005
1006 static void device_initfn(Object *obj)
1007 {
1008 DeviceState *dev = DEVICE(obj);
1009 ObjectClass *class;
1010 Property *prop;
1011
1012 if (qdev_hotplug) {
1013 dev->hotplugged = 1;
1014 qdev_hot_added = true;
1015 }
1016
1017 dev->instance_id_alias = -1;
1018 dev->realized = false;
1019
1020 object_property_add_bool(obj, "realized",
1021 device_get_realized, device_set_realized, NULL);
1022 object_property_add_bool(obj, "hotpluggable",
1023 device_get_hotpluggable, NULL, NULL);
1024 object_property_add_bool(obj, "hotplugged",
1025 device_get_hotplugged, NULL,
1026 &error_abort);
1027
1028 class = object_get_class(OBJECT(dev));
1029 do {
1030 for (prop = DEVICE_CLASS(class)->props; prop && prop->name; prop++) {
1031 qdev_property_add_legacy(dev, prop, &error_abort);
1032 qdev_property_add_static(dev, prop, &error_abort);
1033 }
1034 class = object_class_get_parent(class);
1035 } while (class != object_class_by_name(TYPE_DEVICE));
1036
1037 object_property_add_link(OBJECT(dev), "parent_bus", TYPE_BUS,
1038 (Object **)&dev->parent_bus, NULL, 0,
1039 &error_abort);
1040 QLIST_INIT(&dev->gpios);
1041 }
1042
1043 static void device_post_init(Object *obj)
1044 {
1045 qdev_prop_set_globals(DEVICE(obj));
1046 }
1047
1048 /* Unlink device from bus and free the structure. */
1049 static void device_finalize(Object *obj)
1050 {
1051 NamedGPIOList *ngl, *next;
1052
1053 DeviceState *dev = DEVICE(obj);
1054
1055 QLIST_FOREACH_SAFE(ngl, &dev->gpios, node, next) {
1056 QLIST_REMOVE(ngl, node);
1057 qemu_free_irqs(ngl->in, ngl->num_in);
1058 g_free(ngl->name);
1059 g_free(ngl);
1060 /* ngl->out irqs are owned by the other end and should not be freed
1061 * here
1062 */
1063 }
1064 }
1065
1066 static void device_class_base_init(ObjectClass *class, void *data)
1067 {
1068 DeviceClass *klass = DEVICE_CLASS(class);
1069
1070 /* We explicitly look up properties in the superclasses,
1071 * so do not propagate them to the subclasses.
1072 */
1073 klass->props = NULL;
1074 }
1075
1076 static void device_unparent(Object *obj)
1077 {
1078 DeviceState *dev = DEVICE(obj);
1079 BusState *bus;
1080
1081 if (dev->realized) {
1082 object_property_set_bool(obj, false, "realized", NULL);
1083 }
1084 while (dev->num_child_bus) {
1085 bus = QLIST_FIRST(&dev->child_bus);
1086 object_unparent(OBJECT(bus));
1087 }
1088 if (dev->parent_bus) {
1089 bus_remove_child(dev->parent_bus, dev);
1090 object_unref(OBJECT(dev->parent_bus));
1091 dev->parent_bus = NULL;
1092 }
1093
1094 /* Only send event if the device had been completely realized */
1095 if (dev->pending_deleted_event) {
1096 gchar *path = object_get_canonical_path(OBJECT(dev));
1097
1098 qapi_event_send_device_deleted(!!dev->id, dev->id, path, &error_abort);
1099 g_free(path);
1100 }
1101
1102 qemu_opts_del(dev->opts);
1103 dev->opts = NULL;
1104 }
1105
1106 static void device_class_init(ObjectClass *class, void *data)
1107 {
1108 DeviceClass *dc = DEVICE_CLASS(class);
1109
1110 class->unparent = device_unparent;
1111 dc->realize = device_realize;
1112 dc->unrealize = device_unrealize;
1113
1114 /* by default all devices were considered as hotpluggable,
1115 * so with intent to check it in generic qdev_unplug() /
1116 * device_set_realized() functions make every device
1117 * hotpluggable. Devices that shouldn't be hotpluggable,
1118 * should override it in their class_init()
1119 */
1120 dc->hotpluggable = true;
1121 }
1122
1123 void device_reset(DeviceState *dev)
1124 {
1125 DeviceClass *klass = DEVICE_GET_CLASS(dev);
1126
1127 if (klass->reset) {
1128 klass->reset(dev);
1129 }
1130 }
1131
1132 Object *qdev_get_machine(void)
1133 {
1134 static Object *dev;
1135
1136 if (dev == NULL) {
1137 dev = container_get(object_get_root(), "/machine");
1138 }
1139
1140 return dev;
1141 }
1142
1143 static const TypeInfo device_type_info = {
1144 .name = TYPE_DEVICE,
1145 .parent = TYPE_OBJECT,
1146 .instance_size = sizeof(DeviceState),
1147 .instance_init = device_initfn,
1148 .instance_post_init = device_post_init,
1149 .instance_finalize = device_finalize,
1150 .class_base_init = device_class_base_init,
1151 .class_init = device_class_init,
1152 .abstract = true,
1153 .class_size = sizeof(DeviceClass),
1154 };
1155
1156 static void qdev_register_types(void)
1157 {
1158 type_register_static(&device_type_info);
1159 }
1160
1161 type_init(qdev_register_types)