2 * qdev property parsing
3 * (parts specific for qemu-system-*)
5 * This file is based on code from hw/qdev-properties.c from
6 * commit 074a86fccd185616469dfcdc0e157f438aebba18,
7 * Copyright (c) Gerd Hoffmann <kraxel@redhat.com> and other contributors.
9 * This work is licensed under the terms of the GNU GPL, version 2 or later.
10 * See the COPYING file in the top-level directory.
13 #include "qemu/osdep.h"
14 #include "hw/qdev-properties.h"
15 #include "qapi/error.h"
16 #include "qapi/visitor.h"
17 #include "qapi/qapi-types-block.h"
18 #include "qapi/qapi-types-machine.h"
19 #include "qapi/qapi-types-migration.h"
20 #include "qapi/qmp/qerror.h"
21 #include "qemu/ctype.h"
22 #include "qemu/cutils.h"
23 #include "qemu/units.h"
24 #include "qemu/error-report.h"
25 #include "qdev-prop-internal.h"
27 #include "audio/audio.h"
28 #include "chardev/char-fe.h"
29 #include "sysemu/block-backend.h"
30 #include "sysemu/blockdev.h"
32 #include "hw/pci/pci.h"
33 #include "util/block-helpers.h"
35 static bool check_prop_still_unset(DeviceState
*dev
, const char *name
,
36 const void *old_val
, const char *new_val
,
39 const GlobalProperty
*prop
= qdev_find_global_prop(dev
, name
);
46 error_setg(errp
, "-global %s.%s=... conflicts with %s=%s",
47 prop
->driver
, prop
->property
, name
, new_val
);
49 /* Error message is vague, but a better one would be hard */
50 error_setg(errp
, "%s=%s conflicts, and override is not implemented",
59 static void get_drive(Object
*obj
, Visitor
*v
, const char *name
, void *opaque
,
62 DeviceState
*dev
= DEVICE(obj
);
63 Property
*prop
= opaque
;
64 void **ptr
= qdev_get_prop_ptr(dev
, prop
);
69 value
= blk_name(*ptr
);
71 BlockDriverState
*bs
= blk_bs(*ptr
);
73 value
= bdrv_get_node_name(bs
);
81 visit_type_str(v
, name
, &p
, errp
);
85 static void set_drive_helper(Object
*obj
, Visitor
*v
, const char *name
,
86 void *opaque
, bool iothread
, Error
**errp
)
88 DeviceState
*dev
= DEVICE(obj
);
89 Property
*prop
= opaque
;
90 void **ptr
= qdev_get_prop_ptr(dev
, prop
);
93 bool blk_created
= false;
97 qdev_prop_set_after_realize(dev
, name
, errp
);
101 if (!visit_type_str(v
, name
, &str
, errp
)) {
106 * TODO Should this really be an error? If no, the old value
107 * needs to be released before we store the new one.
109 if (!check_prop_still_unset(dev
, name
, *ptr
, str
, errp
)) {
119 blk
= blk_by_name(str
);
121 BlockDriverState
*bs
= bdrv_lookup_bs(NULL
, str
, NULL
);
124 * If the device supports iothreads, it will make sure to move the
125 * block node to the right AioContext if necessary (or fail if this
126 * isn't possible because of other users). Devices that are not
127 * aware of iothreads require their BlockBackends to be in the main
130 AioContext
*ctx
= iothread
? bdrv_get_aio_context(bs
) :
131 qemu_get_aio_context();
132 blk
= blk_new(ctx
, 0, BLK_PERM_ALL
);
135 ret
= blk_insert_bs(blk
, bs
, errp
);
142 error_setg(errp
, "Property '%s.%s' can't find value '%s'",
143 object_get_typename(OBJECT(dev
)), prop
->name
, str
);
146 if (blk_attach_dev(blk
, dev
) < 0) {
147 DriveInfo
*dinfo
= blk_legacy_dinfo(blk
);
149 if (dinfo
&& dinfo
->type
!= IF_NONE
) {
150 error_setg(errp
, "Drive '%s' is already in use because "
151 "it has been automatically connected to another "
152 "device (did you need 'if=none' in the drive options?)",
155 error_setg(errp
, "Drive '%s' is already in use by another device",
165 /* If we need to keep a reference, blk_attach_dev() took it */
172 static void set_drive(Object
*obj
, Visitor
*v
, const char *name
, void *opaque
,
175 set_drive_helper(obj
, v
, name
, opaque
, false, errp
);
178 static void set_drive_iothread(Object
*obj
, Visitor
*v
, const char *name
,
179 void *opaque
, Error
**errp
)
181 set_drive_helper(obj
, v
, name
, opaque
, true, errp
);
184 static void release_drive(Object
*obj
, const char *name
, void *opaque
)
186 DeviceState
*dev
= DEVICE(obj
);
187 Property
*prop
= opaque
;
188 BlockBackend
**ptr
= qdev_get_prop_ptr(dev
, prop
);
191 AioContext
*ctx
= blk_get_aio_context(*ptr
);
193 aio_context_acquire(ctx
);
194 blockdev_auto_del(*ptr
);
195 blk_detach_dev(*ptr
, dev
);
196 aio_context_release(ctx
);
200 const PropertyInfo qdev_prop_drive
= {
202 .description
= "Node name or ID of a block device to use as a backend",
205 .release
= release_drive
,
208 const PropertyInfo qdev_prop_drive_iothread
= {
210 .description
= "Node name or ID of a block device to use as a backend",
212 .set
= set_drive_iothread
,
213 .release
= release_drive
,
216 /* --- character device --- */
218 static void get_chr(Object
*obj
, Visitor
*v
, const char *name
, void *opaque
,
221 DeviceState
*dev
= DEVICE(obj
);
222 CharBackend
*be
= qdev_get_prop_ptr(dev
, opaque
);
225 p
= g_strdup(be
->chr
&& be
->chr
->label
? be
->chr
->label
: "");
226 visit_type_str(v
, name
, &p
, errp
);
230 static void set_chr(Object
*obj
, Visitor
*v
, const char *name
, void *opaque
,
233 DeviceState
*dev
= DEVICE(obj
);
234 Property
*prop
= opaque
;
235 CharBackend
*be
= qdev_get_prop_ptr(dev
, prop
);
240 qdev_prop_set_after_realize(dev
, name
, errp
);
244 if (!visit_type_str(v
, name
, &str
, errp
)) {
249 * TODO Should this really be an error? If no, the old value
250 * needs to be released before we store the new one.
252 if (!check_prop_still_unset(dev
, name
, be
->chr
, str
, errp
)) {
262 s
= qemu_chr_find(str
);
264 error_setg(errp
, "Property '%s.%s' can't find value '%s'",
265 object_get_typename(obj
), prop
->name
, str
);
266 } else if (!qemu_chr_fe_init(be
, s
, errp
)) {
267 error_prepend(errp
, "Property '%s.%s' can't take value '%s': ",
268 object_get_typename(obj
), prop
->name
, str
);
273 static void release_chr(Object
*obj
, const char *name
, void *opaque
)
275 DeviceState
*dev
= DEVICE(obj
);
276 Property
*prop
= opaque
;
277 CharBackend
*be
= qdev_get_prop_ptr(dev
, prop
);
279 qemu_chr_fe_deinit(be
, false);
282 const PropertyInfo qdev_prop_chr
= {
284 .description
= "ID of a chardev to use as a backend",
287 .release
= release_chr
,
290 /* --- mac address --- */
293 * accepted syntax versions:
297 static void get_mac(Object
*obj
, Visitor
*v
, const char *name
, void *opaque
,
300 DeviceState
*dev
= DEVICE(obj
);
301 Property
*prop
= opaque
;
302 MACAddr
*mac
= qdev_get_prop_ptr(dev
, prop
);
303 char buffer
[2 * 6 + 5 + 1];
306 snprintf(buffer
, sizeof(buffer
), "%02x:%02x:%02x:%02x:%02x:%02x",
307 mac
->a
[0], mac
->a
[1], mac
->a
[2],
308 mac
->a
[3], mac
->a
[4], mac
->a
[5]);
310 visit_type_str(v
, name
, &p
, errp
);
313 static void set_mac(Object
*obj
, Visitor
*v
, const char *name
, void *opaque
,
316 DeviceState
*dev
= DEVICE(obj
);
317 Property
*prop
= opaque
;
318 MACAddr
*mac
= qdev_get_prop_ptr(dev
, prop
);
324 qdev_prop_set_after_realize(dev
, name
, errp
);
328 if (!visit_type_str(v
, name
, &str
, errp
)) {
332 for (i
= 0, pos
= 0; i
< 6; i
++, pos
+= 3) {
335 if (!qemu_isxdigit(str
[pos
])) {
338 if (!qemu_isxdigit(str
[pos
+ 1])) {
342 if (str
[pos
+ 2] != '\0') {
346 if (str
[pos
+ 2] != ':' && str
[pos
+ 2] != '-') {
350 if (qemu_strtol(str
+ pos
, &p
, 16, &val
) < 0 || val
> 0xff) {
359 error_set_from_qdev_prop_error(errp
, EINVAL
, dev
, prop
, str
);
363 const PropertyInfo qdev_prop_macaddr
= {
365 .description
= "Ethernet 6-byte MAC Address, example: 52:54:00:12:34:56",
370 void qdev_prop_set_macaddr(DeviceState
*dev
, const char *name
,
371 const uint8_t *value
)
373 char str
[2 * 6 + 5 + 1];
374 snprintf(str
, sizeof(str
), "%02x:%02x:%02x:%02x:%02x:%02x",
375 value
[0], value
[1], value
[2], value
[3], value
[4], value
[5]);
377 object_property_set_str(OBJECT(dev
), name
, str
, &error_abort
);
380 /* --- netdev device --- */
381 static void get_netdev(Object
*obj
, Visitor
*v
, const char *name
,
382 void *opaque
, Error
**errp
)
384 DeviceState
*dev
= DEVICE(obj
);
385 Property
*prop
= opaque
;
386 NICPeers
*peers_ptr
= qdev_get_prop_ptr(dev
, prop
);
387 char *p
= g_strdup(peers_ptr
->ncs
[0] ? peers_ptr
->ncs
[0]->name
: "");
389 visit_type_str(v
, name
, &p
, errp
);
393 static void set_netdev(Object
*obj
, Visitor
*v
, const char *name
,
394 void *opaque
, Error
**errp
)
396 DeviceState
*dev
= DEVICE(obj
);
397 Property
*prop
= opaque
;
398 NICPeers
*peers_ptr
= qdev_get_prop_ptr(dev
, prop
);
399 NetClientState
**ncs
= peers_ptr
->ncs
;
400 NetClientState
*peers
[MAX_QUEUE_NUM
];
401 int queues
, err
= 0, i
= 0;
405 qdev_prop_set_after_realize(dev
, name
, errp
);
409 if (!visit_type_str(v
, name
, &str
, errp
)) {
413 queues
= qemu_find_net_clients_except(str
, peers
,
414 NET_CLIENT_DRIVER_NIC
,
421 if (queues
> MAX_QUEUE_NUM
) {
422 error_setg(errp
, "queues of backend '%s'(%d) exceeds QEMU limitation(%d)",
423 str
, queues
, MAX_QUEUE_NUM
);
427 for (i
= 0; i
< queues
; i
++) {
428 if (peers
[i
]->peer
) {
434 * TODO Should this really be an error? If no, the old value
435 * needs to be released before we store the new one.
437 if (!check_prop_still_unset(dev
, name
, ncs
[i
], str
, errp
)) {
442 ncs
[i
]->queue_index
= i
;
445 peers_ptr
->queues
= queues
;
448 error_set_from_qdev_prop_error(errp
, err
, dev
, prop
, str
);
452 const PropertyInfo qdev_prop_netdev
= {
454 .description
= "ID of a netdev to use as a backend",
460 /* --- audiodev --- */
461 static void get_audiodev(Object
*obj
, Visitor
*v
, const char* name
,
462 void *opaque
, Error
**errp
)
464 DeviceState
*dev
= DEVICE(obj
);
465 Property
*prop
= opaque
;
466 QEMUSoundCard
*card
= qdev_get_prop_ptr(dev
, prop
);
467 char *p
= g_strdup(audio_get_id(card
));
469 visit_type_str(v
, name
, &p
, errp
);
473 static void set_audiodev(Object
*obj
, Visitor
*v
, const char* name
,
474 void *opaque
, Error
**errp
)
476 DeviceState
*dev
= DEVICE(obj
);
477 Property
*prop
= opaque
;
478 QEMUSoundCard
*card
= qdev_get_prop_ptr(dev
, prop
);
484 qdev_prop_set_after_realize(dev
, name
, errp
);
488 if (!visit_type_str(v
, name
, &str
, errp
)) {
492 state
= audio_state_by_name(str
);
501 error_set_from_qdev_prop_error(errp
, err
, dev
, prop
, str
);
505 const PropertyInfo qdev_prop_audiodev
= {
507 .description
= "ID of an audiodev to use as a backend",
508 /* release done on shutdown */
513 bool qdev_prop_set_drive_err(DeviceState
*dev
, const char *name
,
514 BlockBackend
*value
, Error
**errp
)
516 const char *ref
= "";
519 ref
= blk_name(value
);
521 const BlockDriverState
*bs
= blk_bs(value
);
523 ref
= bdrv_get_node_name(bs
);
528 return object_property_set_str(OBJECT(dev
), name
, ref
, errp
);
531 void qdev_prop_set_drive(DeviceState
*dev
, const char *name
,
534 qdev_prop_set_drive_err(dev
, name
, value
, &error_abort
);
537 void qdev_prop_set_chr(DeviceState
*dev
, const char *name
,
540 assert(!value
|| value
->label
);
541 object_property_set_str(OBJECT(dev
), name
, value
? value
->label
: "",
545 void qdev_prop_set_netdev(DeviceState
*dev
, const char *name
,
546 NetClientState
*value
)
548 assert(!value
|| value
->name
);
549 object_property_set_str(OBJECT(dev
), name
, value
? value
->name
: "",
553 void qdev_set_nic_properties(DeviceState
*dev
, NICInfo
*nd
)
555 qdev_prop_set_macaddr(dev
, "mac", nd
->macaddr
.a
);
557 qdev_prop_set_netdev(dev
, "netdev", nd
->netdev
);
559 if (nd
->nvectors
!= DEV_NVECTORS_UNSPECIFIED
&&
560 object_property_find(OBJECT(dev
), "vectors")) {
561 qdev_prop_set_uint32(dev
, "vectors", nd
->nvectors
);
563 nd
->instantiated
= 1;
566 /* --- lost tick policy --- */
568 QEMU_BUILD_BUG_ON(sizeof(LostTickPolicy
) != sizeof(int));
570 const PropertyInfo qdev_prop_losttickpolicy
= {
571 .name
= "LostTickPolicy",
572 .enum_table
= &LostTickPolicy_lookup
,
573 .get
= qdev_propinfo_get_enum
,
574 .set
= qdev_propinfo_set_enum
,
575 .set_default_value
= qdev_propinfo_set_default_value_enum
,
578 /* --- blocksize --- */
580 static void set_blocksize(Object
*obj
, Visitor
*v
, const char *name
,
581 void *opaque
, Error
**errp
)
583 DeviceState
*dev
= DEVICE(obj
);
584 Property
*prop
= opaque
;
585 uint32_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
587 Error
*local_err
= NULL
;
590 qdev_prop_set_after_realize(dev
, name
, errp
);
594 if (!visit_type_size(v
, name
, &value
, errp
)) {
597 check_block_size(dev
->id
? : "", name
, value
, &local_err
);
599 error_propagate(errp
, local_err
);
605 const PropertyInfo qdev_prop_blocksize
= {
607 .description
= "A power of two between " MIN_BLOCK_SIZE_STR
608 " and " MAX_BLOCK_SIZE_STR
,
609 .get
= qdev_propinfo_get_size32
,
610 .set
= set_blocksize
,
611 .set_default_value
= qdev_propinfo_set_default_value_uint
,
614 /* --- Block device error handling policy --- */
616 QEMU_BUILD_BUG_ON(sizeof(BlockdevOnError
) != sizeof(int));
618 const PropertyInfo qdev_prop_blockdev_on_error
= {
619 .name
= "BlockdevOnError",
620 .description
= "Error handling policy, "
621 "report/ignore/enospc/stop/auto",
622 .enum_table
= &BlockdevOnError_lookup
,
623 .get
= qdev_propinfo_get_enum
,
624 .set
= qdev_propinfo_set_enum
,
625 .set_default_value
= qdev_propinfo_set_default_value_enum
,
628 /* --- BIOS CHS translation */
630 QEMU_BUILD_BUG_ON(sizeof(BiosAtaTranslation
) != sizeof(int));
632 const PropertyInfo qdev_prop_bios_chs_trans
= {
633 .name
= "BiosAtaTranslation",
634 .description
= "Logical CHS translation algorithm, "
635 "auto/none/lba/large/rechs",
636 .enum_table
= &BiosAtaTranslation_lookup
,
637 .get
= qdev_propinfo_get_enum
,
638 .set
= qdev_propinfo_set_enum
,
639 .set_default_value
= qdev_propinfo_set_default_value_enum
,
642 /* --- FDC default drive types */
644 const PropertyInfo qdev_prop_fdc_drive_type
= {
645 .name
= "FdcDriveType",
646 .description
= "FDC drive type, "
647 "144/288/120/none/auto",
648 .enum_table
= &FloppyDriveType_lookup
,
649 .get
= qdev_propinfo_get_enum
,
650 .set
= qdev_propinfo_set_enum
,
651 .set_default_value
= qdev_propinfo_set_default_value_enum
,
654 /* --- MultiFDCompression --- */
656 const PropertyInfo qdev_prop_multifd_compression
= {
657 .name
= "MultiFDCompression",
658 .description
= "multifd_compression values, "
660 .enum_table
= &MultiFDCompression_lookup
,
661 .get
= qdev_propinfo_get_enum
,
662 .set
= qdev_propinfo_set_enum
,
663 .set_default_value
= qdev_propinfo_set_default_value_enum
,
666 /* --- Reserved Region --- */
670 * <low address>:<high address>:<type>
671 * where low/high addresses are uint64_t in hexadecimal
672 * and type is a non-negative decimal integer
674 static void get_reserved_region(Object
*obj
, Visitor
*v
, const char *name
,
675 void *opaque
, Error
**errp
)
677 DeviceState
*dev
= DEVICE(obj
);
678 Property
*prop
= opaque
;
679 ReservedRegion
*rr
= qdev_get_prop_ptr(dev
, prop
);
684 rc
= snprintf(buffer
, sizeof(buffer
), "0x%"PRIx64
":0x%"PRIx64
":%u",
685 rr
->low
, rr
->high
, rr
->type
);
686 assert(rc
< sizeof(buffer
));
688 visit_type_str(v
, name
, &p
, errp
);
691 static void set_reserved_region(Object
*obj
, Visitor
*v
, const char *name
,
692 void *opaque
, Error
**errp
)
694 DeviceState
*dev
= DEVICE(obj
);
695 Property
*prop
= opaque
;
696 ReservedRegion
*rr
= qdev_get_prop_ptr(dev
, prop
);
697 Error
*local_err
= NULL
;
703 qdev_prop_set_after_realize(dev
, name
, errp
);
707 visit_type_str(v
, name
, &str
, &local_err
);
709 error_propagate(errp
, local_err
);
713 ret
= qemu_strtou64(str
, &endptr
, 16, &rr
->low
);
715 error_setg(errp
, "start address of '%s'"
716 " must be a hexadecimal integer", name
);
719 if (*endptr
!= ':') {
720 goto separator_error
;
723 ret
= qemu_strtou64(endptr
+ 1, &endptr
, 16, &rr
->high
);
725 error_setg(errp
, "end address of '%s'"
726 " must be a hexadecimal integer", name
);
729 if (*endptr
!= ':') {
730 goto separator_error
;
733 ret
= qemu_strtoui(endptr
+ 1, &endptr
, 10, &rr
->type
);
735 error_setg(errp
, "type of '%s'"
736 " must be a non-negative decimal integer", name
);
741 error_setg(errp
, "reserved region fields must be separated with ':'");
747 const PropertyInfo qdev_prop_reserved_region
= {
748 .name
= "reserved_region",
749 .description
= "Reserved Region, example: 0xFEE00000:0xFEEFFFFF:0",
750 .get
= get_reserved_region
,
751 .set
= set_reserved_region
,
754 /* --- pci address --- */
757 * bus-local address, i.e. "$slot" or "$slot.$fn"
759 static void set_pci_devfn(Object
*obj
, Visitor
*v
, const char *name
,
760 void *opaque
, Error
**errp
)
762 DeviceState
*dev
= DEVICE(obj
);
763 Property
*prop
= opaque
;
764 int32_t value
, *ptr
= qdev_get_prop_ptr(dev
, prop
);
765 unsigned int slot
, fn
, n
;
769 qdev_prop_set_after_realize(dev
, name
, errp
);
773 if (!visit_type_str(v
, name
, &str
, NULL
)) {
774 if (!visit_type_int32(v
, name
, &value
, errp
)) {
777 if (value
< -1 || value
> 255) {
778 error_setg(errp
, QERR_INVALID_PARAMETER_VALUE
,
779 name
? name
: "null", "pci_devfn");
786 if (sscanf(str
, "%x.%x%n", &slot
, &fn
, &n
) != 2) {
788 if (sscanf(str
, "%x%n", &slot
, &n
) != 1) {
792 if (str
[n
] != '\0' || fn
> 7 || slot
> 31) {
795 *ptr
= slot
<< 3 | fn
;
800 error_set_from_qdev_prop_error(errp
, EINVAL
, dev
, prop
, str
);
804 static int print_pci_devfn(DeviceState
*dev
, Property
*prop
, char *dest
,
807 int32_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
810 return snprintf(dest
, len
, "<unset>");
812 return snprintf(dest
, len
, "%02x.%x", *ptr
>> 3, *ptr
& 7);
816 const PropertyInfo qdev_prop_pci_devfn
= {
818 .description
= "Slot and optional function number, example: 06.0 or 06",
819 .print
= print_pci_devfn
,
820 .get
= qdev_propinfo_get_int32
,
821 .set
= set_pci_devfn
,
822 .set_default_value
= qdev_propinfo_set_default_value_int
,
825 /* --- pci host address --- */
827 static void get_pci_host_devaddr(Object
*obj
, Visitor
*v
, const char *name
,
828 void *opaque
, Error
**errp
)
830 DeviceState
*dev
= DEVICE(obj
);
831 Property
*prop
= opaque
;
832 PCIHostDeviceAddress
*addr
= qdev_get_prop_ptr(dev
, prop
);
833 char buffer
[] = "ffff:ff:ff.f";
838 * Catch "invalid" device reference from vfio-pci and allow the
839 * default buffer representing the non-existent device to be used.
841 if (~addr
->domain
|| ~addr
->bus
|| ~addr
->slot
|| ~addr
->function
) {
842 rc
= snprintf(buffer
, sizeof(buffer
), "%04x:%02x:%02x.%0d",
843 addr
->domain
, addr
->bus
, addr
->slot
, addr
->function
);
844 assert(rc
== sizeof(buffer
) - 1);
847 visit_type_str(v
, name
, &p
, errp
);
851 * Parse [<domain>:]<bus>:<slot>.<func>
852 * if <domain> is not supplied, it's assumed to be 0.
854 static void set_pci_host_devaddr(Object
*obj
, Visitor
*v
, const char *name
,
855 void *opaque
, Error
**errp
)
857 DeviceState
*dev
= DEVICE(obj
);
858 Property
*prop
= opaque
;
859 PCIHostDeviceAddress
*addr
= qdev_get_prop_ptr(dev
, prop
);
863 unsigned long dom
= 0, bus
= 0;
864 unsigned int slot
= 0, func
= 0;
867 qdev_prop_set_after_realize(dev
, name
, errp
);
871 if (!visit_type_str(v
, name
, &str
, errp
)) {
876 if (qemu_strtoul(p
, &e
, 16, &val
) < 0 || val
> 0xffff || e
== p
) {
885 if (qemu_strtoul(p
, &e
, 16, &val
) < 0 || val
> 0x1f || e
== p
) {
892 if (qemu_strtoul(p
, &e
, 16, &val
) < 0 || val
> 0x1f || e
== p
) {
902 if (qemu_strtoul(p
, &e
, 10, &val
) < 0 || val
> 7 || e
== p
) {
918 addr
->function
= func
;
924 error_set_from_qdev_prop_error(errp
, EINVAL
, dev
, prop
, str
);
928 const PropertyInfo qdev_prop_pci_host_devaddr
= {
930 .description
= "Address (bus/device/function) of "
931 "the host device, example: 04:10.0",
932 .get
= get_pci_host_devaddr
,
933 .set
= set_pci_host_devaddr
,
936 /* --- OffAutoPCIBAR off/auto/bar0/bar1/bar2/bar3/bar4/bar5 --- */
938 const PropertyInfo qdev_prop_off_auto_pcibar
= {
939 .name
= "OffAutoPCIBAR",
940 .description
= "off/auto/bar0/bar1/bar2/bar3/bar4/bar5",
941 .enum_table
= &OffAutoPCIBAR_lookup
,
942 .get
= qdev_propinfo_get_enum
,
943 .set
= qdev_propinfo_set_enum
,
944 .set_default_value
= qdev_propinfo_set_default_value_enum
,
947 /* --- PCIELinkSpeed 2_5/5/8/16 -- */
949 static void get_prop_pcielinkspeed(Object
*obj
, Visitor
*v
, const char *name
,
950 void *opaque
, Error
**errp
)
952 DeviceState
*dev
= DEVICE(obj
);
953 Property
*prop
= opaque
;
954 PCIExpLinkSpeed
*p
= qdev_get_prop_ptr(dev
, prop
);
958 case QEMU_PCI_EXP_LNK_2_5GT
:
959 speed
= PCIE_LINK_SPEED_2_5
;
961 case QEMU_PCI_EXP_LNK_5GT
:
962 speed
= PCIE_LINK_SPEED_5
;
964 case QEMU_PCI_EXP_LNK_8GT
:
965 speed
= PCIE_LINK_SPEED_8
;
967 case QEMU_PCI_EXP_LNK_16GT
:
968 speed
= PCIE_LINK_SPEED_16
;
975 visit_type_enum(v
, prop
->name
, &speed
, prop
->info
->enum_table
, errp
);
978 static void set_prop_pcielinkspeed(Object
*obj
, Visitor
*v
, const char *name
,
979 void *opaque
, Error
**errp
)
981 DeviceState
*dev
= DEVICE(obj
);
982 Property
*prop
= opaque
;
983 PCIExpLinkSpeed
*p
= qdev_get_prop_ptr(dev
, prop
);
987 qdev_prop_set_after_realize(dev
, name
, errp
);
991 if (!visit_type_enum(v
, prop
->name
, &speed
, prop
->info
->enum_table
,
997 case PCIE_LINK_SPEED_2_5
:
998 *p
= QEMU_PCI_EXP_LNK_2_5GT
;
1000 case PCIE_LINK_SPEED_5
:
1001 *p
= QEMU_PCI_EXP_LNK_5GT
;
1003 case PCIE_LINK_SPEED_8
:
1004 *p
= QEMU_PCI_EXP_LNK_8GT
;
1006 case PCIE_LINK_SPEED_16
:
1007 *p
= QEMU_PCI_EXP_LNK_16GT
;
1015 const PropertyInfo qdev_prop_pcie_link_speed
= {
1016 .name
= "PCIELinkSpeed",
1017 .description
= "2_5/5/8/16",
1018 .enum_table
= &PCIELinkSpeed_lookup
,
1019 .get
= get_prop_pcielinkspeed
,
1020 .set
= set_prop_pcielinkspeed
,
1021 .set_default_value
= qdev_propinfo_set_default_value_enum
,
1024 /* --- PCIELinkWidth 1/2/4/8/12/16/32 -- */
1026 static void get_prop_pcielinkwidth(Object
*obj
, Visitor
*v
, const char *name
,
1027 void *opaque
, Error
**errp
)
1029 DeviceState
*dev
= DEVICE(obj
);
1030 Property
*prop
= opaque
;
1031 PCIExpLinkWidth
*p
= qdev_get_prop_ptr(dev
, prop
);
1035 case QEMU_PCI_EXP_LNK_X1
:
1036 width
= PCIE_LINK_WIDTH_1
;
1038 case QEMU_PCI_EXP_LNK_X2
:
1039 width
= PCIE_LINK_WIDTH_2
;
1041 case QEMU_PCI_EXP_LNK_X4
:
1042 width
= PCIE_LINK_WIDTH_4
;
1044 case QEMU_PCI_EXP_LNK_X8
:
1045 width
= PCIE_LINK_WIDTH_8
;
1047 case QEMU_PCI_EXP_LNK_X12
:
1048 width
= PCIE_LINK_WIDTH_12
;
1050 case QEMU_PCI_EXP_LNK_X16
:
1051 width
= PCIE_LINK_WIDTH_16
;
1053 case QEMU_PCI_EXP_LNK_X32
:
1054 width
= PCIE_LINK_WIDTH_32
;
1061 visit_type_enum(v
, prop
->name
, &width
, prop
->info
->enum_table
, errp
);
1064 static void set_prop_pcielinkwidth(Object
*obj
, Visitor
*v
, const char *name
,
1065 void *opaque
, Error
**errp
)
1067 DeviceState
*dev
= DEVICE(obj
);
1068 Property
*prop
= opaque
;
1069 PCIExpLinkWidth
*p
= qdev_get_prop_ptr(dev
, prop
);
1072 if (dev
->realized
) {
1073 qdev_prop_set_after_realize(dev
, name
, errp
);
1077 if (!visit_type_enum(v
, prop
->name
, &width
, prop
->info
->enum_table
,
1083 case PCIE_LINK_WIDTH_1
:
1084 *p
= QEMU_PCI_EXP_LNK_X1
;
1086 case PCIE_LINK_WIDTH_2
:
1087 *p
= QEMU_PCI_EXP_LNK_X2
;
1089 case PCIE_LINK_WIDTH_4
:
1090 *p
= QEMU_PCI_EXP_LNK_X4
;
1092 case PCIE_LINK_WIDTH_8
:
1093 *p
= QEMU_PCI_EXP_LNK_X8
;
1095 case PCIE_LINK_WIDTH_12
:
1096 *p
= QEMU_PCI_EXP_LNK_X12
;
1098 case PCIE_LINK_WIDTH_16
:
1099 *p
= QEMU_PCI_EXP_LNK_X16
;
1101 case PCIE_LINK_WIDTH_32
:
1102 *p
= QEMU_PCI_EXP_LNK_X32
;
1110 const PropertyInfo qdev_prop_pcie_link_width
= {
1111 .name
= "PCIELinkWidth",
1112 .description
= "1/2/4/8/12/16/32",
1113 .enum_table
= &PCIELinkWidth_lookup
,
1114 .get
= get_prop_pcielinkwidth
,
1115 .set
= set_prop_pcielinkwidth
,
1116 .set_default_value
= qdev_propinfo_set_default_value_enum
,