hw/arm/bcm2836: Only provide "enabled-cpus" property to multicore SoCs
[qemu.git] / hw / core / qdev-properties.c
1 #include "qemu/osdep.h"
2 #include "hw/qdev-properties.h"
3 #include "qapi/error.h"
4 #include "qapi/qapi-types-misc.h"
5 #include "qapi/qmp/qerror.h"
6 #include "qemu/ctype.h"
7 #include "qemu/error-report.h"
8 #include "qapi/visitor.h"
9 #include "qemu/uuid.h"
10 #include "qemu/units.h"
11 #include "qemu/cutils.h"
12 #include "qdev-prop-internal.h"
13
14 void qdev_prop_set_after_realize(DeviceState *dev, const char *name,
15 Error **errp)
16 {
17 if (dev->id) {
18 error_setg(errp, "Attempt to set property '%s' on device '%s' "
19 "(type '%s') after it was realized", name, dev->id,
20 object_get_typename(OBJECT(dev)));
21 } else {
22 error_setg(errp, "Attempt to set property '%s' on anonymous device "
23 "(type '%s') after it was realized", name,
24 object_get_typename(OBJECT(dev)));
25 }
26 }
27
28 void qdev_prop_allow_set_link_before_realize(const Object *obj,
29 const char *name,
30 Object *val, Error **errp)
31 {
32 DeviceState *dev = DEVICE(obj);
33
34 if (dev->realized) {
35 error_setg(errp, "Attempt to set link property '%s' on device '%s' "
36 "(type '%s') after it was realized",
37 name, dev->id, object_get_typename(obj));
38 }
39 }
40
41 void *qdev_get_prop_ptr(DeviceState *dev, Property *prop)
42 {
43 void *ptr = dev;
44 ptr += prop->offset;
45 return ptr;
46 }
47
48 void qdev_propinfo_get_enum(Object *obj, Visitor *v, const char *name,
49 void *opaque, Error **errp)
50 {
51 DeviceState *dev = DEVICE(obj);
52 Property *prop = opaque;
53 int *ptr = qdev_get_prop_ptr(dev, prop);
54
55 visit_type_enum(v, prop->name, ptr, prop->info->enum_table, errp);
56 }
57
58 void qdev_propinfo_set_enum(Object *obj, Visitor *v, const char *name,
59 void *opaque, Error **errp)
60 {
61 DeviceState *dev = DEVICE(obj);
62 Property *prop = opaque;
63 int *ptr = qdev_get_prop_ptr(dev, prop);
64
65 if (dev->realized) {
66 qdev_prop_set_after_realize(dev, name, errp);
67 return;
68 }
69
70 visit_type_enum(v, prop->name, ptr, prop->info->enum_table, errp);
71 }
72
73 void qdev_propinfo_set_default_value_enum(ObjectProperty *op,
74 const Property *prop)
75 {
76 object_property_set_default_str(op,
77 qapi_enum_lookup(prop->info->enum_table, prop->defval.i));
78 }
79
80 const PropertyInfo qdev_prop_enum = {
81 .name = "enum",
82 .get = qdev_propinfo_get_enum,
83 .set = qdev_propinfo_set_enum,
84 .set_default_value = qdev_propinfo_set_default_value_enum,
85 };
86
87 /* Bit */
88
89 static uint32_t qdev_get_prop_mask(Property *prop)
90 {
91 assert(prop->info == &qdev_prop_bit);
92 return 0x1 << prop->bitnr;
93 }
94
95 static void bit_prop_set(DeviceState *dev, Property *props, bool val)
96 {
97 uint32_t *p = qdev_get_prop_ptr(dev, props);
98 uint32_t mask = qdev_get_prop_mask(props);
99 if (val) {
100 *p |= mask;
101 } else {
102 *p &= ~mask;
103 }
104 }
105
106 static void prop_get_bit(Object *obj, Visitor *v, const char *name,
107 void *opaque, Error **errp)
108 {
109 DeviceState *dev = DEVICE(obj);
110 Property *prop = opaque;
111 uint32_t *p = qdev_get_prop_ptr(dev, prop);
112 bool value = (*p & qdev_get_prop_mask(prop)) != 0;
113
114 visit_type_bool(v, name, &value, errp);
115 }
116
117 static void prop_set_bit(Object *obj, Visitor *v, const char *name,
118 void *opaque, Error **errp)
119 {
120 DeviceState *dev = DEVICE(obj);
121 Property *prop = opaque;
122 bool value;
123
124 if (dev->realized) {
125 qdev_prop_set_after_realize(dev, name, errp);
126 return;
127 }
128
129 if (!visit_type_bool(v, name, &value, errp)) {
130 return;
131 }
132 bit_prop_set(dev, prop, value);
133 }
134
135 static void set_default_value_bool(ObjectProperty *op, const Property *prop)
136 {
137 object_property_set_default_bool(op, prop->defval.u);
138 }
139
140 const PropertyInfo qdev_prop_bit = {
141 .name = "bool",
142 .description = "on/off",
143 .get = prop_get_bit,
144 .set = prop_set_bit,
145 .set_default_value = set_default_value_bool,
146 };
147
148 /* Bit64 */
149
150 static uint64_t qdev_get_prop_mask64(Property *prop)
151 {
152 assert(prop->info == &qdev_prop_bit64);
153 return 0x1ull << prop->bitnr;
154 }
155
156 static void bit64_prop_set(DeviceState *dev, Property *props, bool val)
157 {
158 uint64_t *p = qdev_get_prop_ptr(dev, props);
159 uint64_t mask = qdev_get_prop_mask64(props);
160 if (val) {
161 *p |= mask;
162 } else {
163 *p &= ~mask;
164 }
165 }
166
167 static void prop_get_bit64(Object *obj, Visitor *v, const char *name,
168 void *opaque, Error **errp)
169 {
170 DeviceState *dev = DEVICE(obj);
171 Property *prop = opaque;
172 uint64_t *p = qdev_get_prop_ptr(dev, prop);
173 bool value = (*p & qdev_get_prop_mask64(prop)) != 0;
174
175 visit_type_bool(v, name, &value, errp);
176 }
177
178 static void prop_set_bit64(Object *obj, Visitor *v, const char *name,
179 void *opaque, Error **errp)
180 {
181 DeviceState *dev = DEVICE(obj);
182 Property *prop = opaque;
183 bool value;
184
185 if (dev->realized) {
186 qdev_prop_set_after_realize(dev, name, errp);
187 return;
188 }
189
190 if (!visit_type_bool(v, name, &value, errp)) {
191 return;
192 }
193 bit64_prop_set(dev, prop, value);
194 }
195
196 const PropertyInfo qdev_prop_bit64 = {
197 .name = "bool",
198 .description = "on/off",
199 .get = prop_get_bit64,
200 .set = prop_set_bit64,
201 .set_default_value = set_default_value_bool,
202 };
203
204 /* --- bool --- */
205
206 static void get_bool(Object *obj, Visitor *v, const char *name, void *opaque,
207 Error **errp)
208 {
209 DeviceState *dev = DEVICE(obj);
210 Property *prop = opaque;
211 bool *ptr = qdev_get_prop_ptr(dev, prop);
212
213 visit_type_bool(v, name, ptr, errp);
214 }
215
216 static void set_bool(Object *obj, Visitor *v, const char *name, void *opaque,
217 Error **errp)
218 {
219 DeviceState *dev = DEVICE(obj);
220 Property *prop = opaque;
221 bool *ptr = qdev_get_prop_ptr(dev, prop);
222
223 if (dev->realized) {
224 qdev_prop_set_after_realize(dev, name, errp);
225 return;
226 }
227
228 visit_type_bool(v, name, ptr, errp);
229 }
230
231 const PropertyInfo qdev_prop_bool = {
232 .name = "bool",
233 .get = get_bool,
234 .set = set_bool,
235 .set_default_value = set_default_value_bool,
236 };
237
238 /* --- 8bit integer --- */
239
240 static void get_uint8(Object *obj, Visitor *v, const char *name, void *opaque,
241 Error **errp)
242 {
243 DeviceState *dev = DEVICE(obj);
244 Property *prop = opaque;
245 uint8_t *ptr = qdev_get_prop_ptr(dev, prop);
246
247 visit_type_uint8(v, name, ptr, errp);
248 }
249
250 static void set_uint8(Object *obj, Visitor *v, const char *name, void *opaque,
251 Error **errp)
252 {
253 DeviceState *dev = DEVICE(obj);
254 Property *prop = opaque;
255 uint8_t *ptr = qdev_get_prop_ptr(dev, prop);
256
257 if (dev->realized) {
258 qdev_prop_set_after_realize(dev, name, errp);
259 return;
260 }
261
262 visit_type_uint8(v, name, ptr, errp);
263 }
264
265 void qdev_propinfo_set_default_value_int(ObjectProperty *op,
266 const Property *prop)
267 {
268 object_property_set_default_int(op, prop->defval.i);
269 }
270
271 void qdev_propinfo_set_default_value_uint(ObjectProperty *op,
272 const Property *prop)
273 {
274 object_property_set_default_uint(op, prop->defval.u);
275 }
276
277 const PropertyInfo qdev_prop_uint8 = {
278 .name = "uint8",
279 .get = get_uint8,
280 .set = set_uint8,
281 .set_default_value = qdev_propinfo_set_default_value_uint,
282 };
283
284 /* --- 16bit integer --- */
285
286 void qdev_propinfo_get_uint16(Object *obj, Visitor *v, const char *name,
287 void *opaque, Error **errp)
288 {
289 DeviceState *dev = DEVICE(obj);
290 Property *prop = opaque;
291 uint16_t *ptr = qdev_get_prop_ptr(dev, prop);
292
293 visit_type_uint16(v, name, ptr, errp);
294 }
295
296 static void set_uint16(Object *obj, Visitor *v, const char *name,
297 void *opaque, Error **errp)
298 {
299 DeviceState *dev = DEVICE(obj);
300 Property *prop = opaque;
301 uint16_t *ptr = qdev_get_prop_ptr(dev, prop);
302
303 if (dev->realized) {
304 qdev_prop_set_after_realize(dev, name, errp);
305 return;
306 }
307
308 visit_type_uint16(v, name, ptr, errp);
309 }
310
311 const PropertyInfo qdev_prop_uint16 = {
312 .name = "uint16",
313 .get = qdev_propinfo_get_uint16,
314 .set = set_uint16,
315 .set_default_value = qdev_propinfo_set_default_value_uint,
316 };
317
318 /* --- 32bit integer --- */
319
320 static void get_uint32(Object *obj, Visitor *v, const char *name,
321 void *opaque, Error **errp)
322 {
323 DeviceState *dev = DEVICE(obj);
324 Property *prop = opaque;
325 uint32_t *ptr = qdev_get_prop_ptr(dev, prop);
326
327 visit_type_uint32(v, name, ptr, errp);
328 }
329
330 static void set_uint32(Object *obj, Visitor *v, const char *name,
331 void *opaque, Error **errp)
332 {
333 DeviceState *dev = DEVICE(obj);
334 Property *prop = opaque;
335 uint32_t *ptr = qdev_get_prop_ptr(dev, prop);
336
337 if (dev->realized) {
338 qdev_prop_set_after_realize(dev, name, errp);
339 return;
340 }
341
342 visit_type_uint32(v, name, ptr, errp);
343 }
344
345 void qdev_propinfo_get_int32(Object *obj, Visitor *v, const char *name,
346 void *opaque, Error **errp)
347 {
348 DeviceState *dev = DEVICE(obj);
349 Property *prop = opaque;
350 int32_t *ptr = qdev_get_prop_ptr(dev, prop);
351
352 visit_type_int32(v, name, ptr, errp);
353 }
354
355 static void set_int32(Object *obj, Visitor *v, const char *name, void *opaque,
356 Error **errp)
357 {
358 DeviceState *dev = DEVICE(obj);
359 Property *prop = opaque;
360 int32_t *ptr = qdev_get_prop_ptr(dev, prop);
361
362 if (dev->realized) {
363 qdev_prop_set_after_realize(dev, name, errp);
364 return;
365 }
366
367 visit_type_int32(v, name, ptr, errp);
368 }
369
370 const PropertyInfo qdev_prop_uint32 = {
371 .name = "uint32",
372 .get = get_uint32,
373 .set = set_uint32,
374 .set_default_value = qdev_propinfo_set_default_value_uint,
375 };
376
377 const PropertyInfo qdev_prop_int32 = {
378 .name = "int32",
379 .get = qdev_propinfo_get_int32,
380 .set = set_int32,
381 .set_default_value = qdev_propinfo_set_default_value_int,
382 };
383
384 /* --- 64bit integer --- */
385
386 static void get_uint64(Object *obj, Visitor *v, const char *name,
387 void *opaque, Error **errp)
388 {
389 DeviceState *dev = DEVICE(obj);
390 Property *prop = opaque;
391 uint64_t *ptr = qdev_get_prop_ptr(dev, prop);
392
393 visit_type_uint64(v, name, ptr, errp);
394 }
395
396 static void set_uint64(Object *obj, Visitor *v, const char *name,
397 void *opaque, Error **errp)
398 {
399 DeviceState *dev = DEVICE(obj);
400 Property *prop = opaque;
401 uint64_t *ptr = qdev_get_prop_ptr(dev, prop);
402
403 if (dev->realized) {
404 qdev_prop_set_after_realize(dev, name, errp);
405 return;
406 }
407
408 visit_type_uint64(v, name, ptr, errp);
409 }
410
411 static void get_int64(Object *obj, Visitor *v, const char *name,
412 void *opaque, Error **errp)
413 {
414 DeviceState *dev = DEVICE(obj);
415 Property *prop = opaque;
416 int64_t *ptr = qdev_get_prop_ptr(dev, prop);
417
418 visit_type_int64(v, name, ptr, errp);
419 }
420
421 static void set_int64(Object *obj, Visitor *v, const char *name,
422 void *opaque, Error **errp)
423 {
424 DeviceState *dev = DEVICE(obj);
425 Property *prop = opaque;
426 int64_t *ptr = qdev_get_prop_ptr(dev, prop);
427
428 if (dev->realized) {
429 qdev_prop_set_after_realize(dev, name, errp);
430 return;
431 }
432
433 visit_type_int64(v, name, ptr, errp);
434 }
435
436 const PropertyInfo qdev_prop_uint64 = {
437 .name = "uint64",
438 .get = get_uint64,
439 .set = set_uint64,
440 .set_default_value = qdev_propinfo_set_default_value_uint,
441 };
442
443 const PropertyInfo qdev_prop_int64 = {
444 .name = "int64",
445 .get = get_int64,
446 .set = set_int64,
447 .set_default_value = qdev_propinfo_set_default_value_int,
448 };
449
450 /* --- string --- */
451
452 static void release_string(Object *obj, const char *name, void *opaque)
453 {
454 Property *prop = opaque;
455 g_free(*(char **)qdev_get_prop_ptr(DEVICE(obj), prop));
456 }
457
458 static void get_string(Object *obj, Visitor *v, const char *name,
459 void *opaque, Error **errp)
460 {
461 DeviceState *dev = DEVICE(obj);
462 Property *prop = opaque;
463 char **ptr = qdev_get_prop_ptr(dev, prop);
464
465 if (!*ptr) {
466 char *str = (char *)"";
467 visit_type_str(v, name, &str, errp);
468 } else {
469 visit_type_str(v, name, ptr, errp);
470 }
471 }
472
473 static void set_string(Object *obj, Visitor *v, const char *name,
474 void *opaque, Error **errp)
475 {
476 DeviceState *dev = DEVICE(obj);
477 Property *prop = opaque;
478 char **ptr = qdev_get_prop_ptr(dev, prop);
479 char *str;
480
481 if (dev->realized) {
482 qdev_prop_set_after_realize(dev, name, errp);
483 return;
484 }
485
486 if (!visit_type_str(v, name, &str, errp)) {
487 return;
488 }
489 g_free(*ptr);
490 *ptr = str;
491 }
492
493 const PropertyInfo qdev_prop_string = {
494 .name = "str",
495 .release = release_string,
496 .get = get_string,
497 .set = set_string,
498 };
499
500 /* --- on/off/auto --- */
501
502 const PropertyInfo qdev_prop_on_off_auto = {
503 .name = "OnOffAuto",
504 .description = "on/off/auto",
505 .enum_table = &OnOffAuto_lookup,
506 .get = qdev_propinfo_get_enum,
507 .set = qdev_propinfo_set_enum,
508 .set_default_value = qdev_propinfo_set_default_value_enum,
509 };
510
511 /* --- 32bit unsigned int 'size' type --- */
512
513 void qdev_propinfo_get_size32(Object *obj, Visitor *v, const char *name,
514 void *opaque, Error **errp)
515 {
516 DeviceState *dev = DEVICE(obj);
517 Property *prop = opaque;
518 uint32_t *ptr = qdev_get_prop_ptr(dev, prop);
519 uint64_t value = *ptr;
520
521 visit_type_size(v, name, &value, errp);
522 }
523
524 static void set_size32(Object *obj, Visitor *v, const char *name, void *opaque,
525 Error **errp)
526 {
527 DeviceState *dev = DEVICE(obj);
528 Property *prop = opaque;
529 uint32_t *ptr = qdev_get_prop_ptr(dev, prop);
530 uint64_t value;
531
532 if (dev->realized) {
533 qdev_prop_set_after_realize(dev, name, errp);
534 return;
535 }
536
537 if (!visit_type_size(v, name, &value, errp)) {
538 return;
539 }
540
541 if (value > UINT32_MAX) {
542 error_setg(errp,
543 "Property %s.%s doesn't take value %" PRIu64
544 " (maximum: %u)",
545 dev->id ? : "", name, value, UINT32_MAX);
546 return;
547 }
548
549 *ptr = value;
550 }
551
552 const PropertyInfo qdev_prop_size32 = {
553 .name = "size",
554 .get = qdev_propinfo_get_size32,
555 .set = set_size32,
556 .set_default_value = qdev_propinfo_set_default_value_uint,
557 };
558
559 /* --- UUID --- */
560
561 static void get_uuid(Object *obj, Visitor *v, const char *name, void *opaque,
562 Error **errp)
563 {
564 DeviceState *dev = DEVICE(obj);
565 Property *prop = opaque;
566 QemuUUID *uuid = qdev_get_prop_ptr(dev, prop);
567 char buffer[UUID_FMT_LEN + 1];
568 char *p = buffer;
569
570 qemu_uuid_unparse(uuid, buffer);
571
572 visit_type_str(v, name, &p, errp);
573 }
574
575 #define UUID_VALUE_AUTO "auto"
576
577 static void set_uuid(Object *obj, Visitor *v, const char *name, void *opaque,
578 Error **errp)
579 {
580 DeviceState *dev = DEVICE(obj);
581 Property *prop = opaque;
582 QemuUUID *uuid = qdev_get_prop_ptr(dev, prop);
583 char *str;
584
585 if (dev->realized) {
586 qdev_prop_set_after_realize(dev, name, errp);
587 return;
588 }
589
590 if (!visit_type_str(v, name, &str, errp)) {
591 return;
592 }
593
594 if (!strcmp(str, UUID_VALUE_AUTO)) {
595 qemu_uuid_generate(uuid);
596 } else if (qemu_uuid_parse(str, uuid) < 0) {
597 error_set_from_qdev_prop_error(errp, EINVAL, dev, prop, str);
598 }
599 g_free(str);
600 }
601
602 static void set_default_uuid_auto(ObjectProperty *op, const Property *prop)
603 {
604 object_property_set_default_str(op, UUID_VALUE_AUTO);
605 }
606
607 const PropertyInfo qdev_prop_uuid = {
608 .name = "str",
609 .description = "UUID (aka GUID) or \"" UUID_VALUE_AUTO
610 "\" for random value (default)",
611 .get = get_uuid,
612 .set = set_uuid,
613 .set_default_value = set_default_uuid_auto,
614 };
615
616 /* --- support for array properties --- */
617
618 /* Used as an opaque for the object properties we add for each
619 * array element. Note that the struct Property must be first
620 * in the struct so that a pointer to this works as the opaque
621 * for the underlying element's property hooks as well as for
622 * our own release callback.
623 */
624 typedef struct {
625 struct Property prop;
626 char *propname;
627 ObjectPropertyRelease *release;
628 } ArrayElementProperty;
629
630 /* object property release callback for array element properties:
631 * we call the underlying element's property release hook, and
632 * then free the memory we allocated when we added the property.
633 */
634 static void array_element_release(Object *obj, const char *name, void *opaque)
635 {
636 ArrayElementProperty *p = opaque;
637 if (p->release) {
638 p->release(obj, name, opaque);
639 }
640 g_free(p->propname);
641 g_free(p);
642 }
643
644 static void set_prop_arraylen(Object *obj, Visitor *v, const char *name,
645 void *opaque, Error **errp)
646 {
647 /* Setter for the property which defines the length of a
648 * variable-sized property array. As well as actually setting the
649 * array-length field in the device struct, we have to create the
650 * array itself and dynamically add the corresponding properties.
651 */
652 DeviceState *dev = DEVICE(obj);
653 Property *prop = opaque;
654 uint32_t *alenptr = qdev_get_prop_ptr(dev, prop);
655 void **arrayptr = (void *)dev + prop->arrayoffset;
656 void *eltptr;
657 const char *arrayname;
658 int i;
659
660 if (dev->realized) {
661 qdev_prop_set_after_realize(dev, name, errp);
662 return;
663 }
664 if (*alenptr) {
665 error_setg(errp, "array size property %s may not be set more than once",
666 name);
667 return;
668 }
669 if (!visit_type_uint32(v, name, alenptr, errp)) {
670 return;
671 }
672 if (!*alenptr) {
673 return;
674 }
675
676 /* DEFINE_PROP_ARRAY guarantees that name should start with this prefix;
677 * strip it off so we can get the name of the array itself.
678 */
679 assert(strncmp(name, PROP_ARRAY_LEN_PREFIX,
680 strlen(PROP_ARRAY_LEN_PREFIX)) == 0);
681 arrayname = name + strlen(PROP_ARRAY_LEN_PREFIX);
682
683 /* Note that it is the responsibility of the individual device's deinit
684 * to free the array proper.
685 */
686 *arrayptr = eltptr = g_malloc0(*alenptr * prop->arrayfieldsize);
687 for (i = 0; i < *alenptr; i++, eltptr += prop->arrayfieldsize) {
688 char *propname = g_strdup_printf("%s[%d]", arrayname, i);
689 ArrayElementProperty *arrayprop = g_new0(ArrayElementProperty, 1);
690 arrayprop->release = prop->arrayinfo->release;
691 arrayprop->propname = propname;
692 arrayprop->prop.info = prop->arrayinfo;
693 arrayprop->prop.name = propname;
694 /* This ugly piece of pointer arithmetic sets up the offset so
695 * that when the underlying get/set hooks call qdev_get_prop_ptr
696 * they get the right answer despite the array element not actually
697 * being inside the device struct.
698 */
699 arrayprop->prop.offset = eltptr - (void *)dev;
700 assert(qdev_get_prop_ptr(dev, &arrayprop->prop) == eltptr);
701 object_property_add(obj, propname,
702 arrayprop->prop.info->name,
703 arrayprop->prop.info->get,
704 arrayprop->prop.info->set,
705 array_element_release,
706 arrayprop);
707 }
708 }
709
710 const PropertyInfo qdev_prop_arraylen = {
711 .name = "uint32",
712 .get = get_uint32,
713 .set = set_prop_arraylen,
714 .set_default_value = qdev_propinfo_set_default_value_uint,
715 };
716
717 /* --- public helpers --- */
718
719 static Property *qdev_prop_walk(Property *props, const char *name)
720 {
721 if (!props) {
722 return NULL;
723 }
724 while (props->name) {
725 if (strcmp(props->name, name) == 0) {
726 return props;
727 }
728 props++;
729 }
730 return NULL;
731 }
732
733 static Property *qdev_prop_find(DeviceState *dev, const char *name)
734 {
735 ObjectClass *class;
736 Property *prop;
737
738 /* device properties */
739 class = object_get_class(OBJECT(dev));
740 do {
741 prop = qdev_prop_walk(DEVICE_CLASS(class)->props_, name);
742 if (prop) {
743 return prop;
744 }
745 class = object_class_get_parent(class);
746 } while (class != object_class_by_name(TYPE_DEVICE));
747
748 return NULL;
749 }
750
751 void error_set_from_qdev_prop_error(Error **errp, int ret, DeviceState *dev,
752 Property *prop, const char *value)
753 {
754 switch (ret) {
755 case -EEXIST:
756 error_setg(errp, "Property '%s.%s' can't take value '%s', it's in use",
757 object_get_typename(OBJECT(dev)), prop->name, value);
758 break;
759 default:
760 case -EINVAL:
761 error_setg(errp, QERR_PROPERTY_VALUE_BAD,
762 object_get_typename(OBJECT(dev)), prop->name, value);
763 break;
764 case -ENOENT:
765 error_setg(errp, "Property '%s.%s' can't find value '%s'",
766 object_get_typename(OBJECT(dev)), prop->name, value);
767 break;
768 case 0:
769 break;
770 }
771 }
772
773 void qdev_prop_set_bit(DeviceState *dev, const char *name, bool value)
774 {
775 object_property_set_bool(OBJECT(dev), name, value, &error_abort);
776 }
777
778 void qdev_prop_set_uint8(DeviceState *dev, const char *name, uint8_t value)
779 {
780 object_property_set_int(OBJECT(dev), name, value, &error_abort);
781 }
782
783 void qdev_prop_set_uint16(DeviceState *dev, const char *name, uint16_t value)
784 {
785 object_property_set_int(OBJECT(dev), name, value, &error_abort);
786 }
787
788 void qdev_prop_set_uint32(DeviceState *dev, const char *name, uint32_t value)
789 {
790 object_property_set_int(OBJECT(dev), name, value, &error_abort);
791 }
792
793 void qdev_prop_set_int32(DeviceState *dev, const char *name, int32_t value)
794 {
795 object_property_set_int(OBJECT(dev), name, value, &error_abort);
796 }
797
798 void qdev_prop_set_uint64(DeviceState *dev, const char *name, uint64_t value)
799 {
800 object_property_set_int(OBJECT(dev), name, value, &error_abort);
801 }
802
803 void qdev_prop_set_string(DeviceState *dev, const char *name, const char *value)
804 {
805 object_property_set_str(OBJECT(dev), name, value, &error_abort);
806 }
807
808 void qdev_prop_set_enum(DeviceState *dev, const char *name, int value)
809 {
810 Property *prop;
811
812 prop = qdev_prop_find(dev, name);
813 object_property_set_str(OBJECT(dev), name,
814 qapi_enum_lookup(prop->info->enum_table, value),
815 &error_abort);
816 }
817
818 static GPtrArray *global_props(void)
819 {
820 static GPtrArray *gp;
821
822 if (!gp) {
823 gp = g_ptr_array_new();
824 }
825
826 return gp;
827 }
828
829 void qdev_prop_register_global(GlobalProperty *prop)
830 {
831 g_ptr_array_add(global_props(), prop);
832 }
833
834 const GlobalProperty *qdev_find_global_prop(DeviceState *dev,
835 const char *name)
836 {
837 GPtrArray *props = global_props();
838 const GlobalProperty *p;
839 int i;
840
841 for (i = 0; i < props->len; i++) {
842 p = g_ptr_array_index(props, i);
843 if (object_dynamic_cast(OBJECT(dev), p->driver)
844 && !strcmp(p->property, name)) {
845 return p;
846 }
847 }
848 return NULL;
849 }
850
851 int qdev_prop_check_globals(void)
852 {
853 int i, ret = 0;
854
855 for (i = 0; i < global_props()->len; i++) {
856 GlobalProperty *prop;
857 ObjectClass *oc;
858 DeviceClass *dc;
859
860 prop = g_ptr_array_index(global_props(), i);
861 if (prop->used) {
862 continue;
863 }
864 oc = object_class_by_name(prop->driver);
865 oc = object_class_dynamic_cast(oc, TYPE_DEVICE);
866 if (!oc) {
867 warn_report("global %s.%s has invalid class name",
868 prop->driver, prop->property);
869 ret = 1;
870 continue;
871 }
872 dc = DEVICE_CLASS(oc);
873 if (!dc->hotpluggable && !prop->used) {
874 warn_report("global %s.%s=%s not used",
875 prop->driver, prop->property, prop->value);
876 ret = 1;
877 continue;
878 }
879 }
880 return ret;
881 }
882
883 void qdev_prop_set_globals(DeviceState *dev)
884 {
885 object_apply_global_props(OBJECT(dev), global_props(),
886 dev->hotplugged ? NULL : &error_fatal);
887 }
888
889 /* --- 64bit unsigned int 'size' type --- */
890
891 static void get_size(Object *obj, Visitor *v, const char *name, void *opaque,
892 Error **errp)
893 {
894 DeviceState *dev = DEVICE(obj);
895 Property *prop = opaque;
896 uint64_t *ptr = qdev_get_prop_ptr(dev, prop);
897
898 visit_type_size(v, name, ptr, errp);
899 }
900
901 static void set_size(Object *obj, Visitor *v, const char *name, void *opaque,
902 Error **errp)
903 {
904 DeviceState *dev = DEVICE(obj);
905 Property *prop = opaque;
906 uint64_t *ptr = qdev_get_prop_ptr(dev, prop);
907
908 visit_type_size(v, name, ptr, errp);
909 }
910
911 const PropertyInfo qdev_prop_size = {
912 .name = "size",
913 .get = get_size,
914 .set = set_size,
915 .set_default_value = qdev_propinfo_set_default_value_uint,
916 };
917
918 /* --- object link property --- */
919
920 static void create_link_property(ObjectClass *oc, Property *prop)
921 {
922 object_class_property_add_link(oc, prop->name, prop->link_type,
923 prop->offset,
924 qdev_prop_allow_set_link_before_realize,
925 OBJ_PROP_LINK_STRONG);
926 }
927
928 const PropertyInfo qdev_prop_link = {
929 .name = "link",
930 .create = create_link_property,
931 };