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