hw/core/qdev-properties.c

   1 #include "qemu/osdep.h"
   2 #include "net/net.h"
   3 #include "hw/qdev-properties.h"
   4 #include "qapi/error.h"
   5 #include "hw/pci/pci.h"
   6 #include "qapi/qapi-types-block.h"
   7 #include "qapi/qapi-types-misc.h"
   8 #include "qapi/qmp/qerror.h"
   9 #include "qemu/ctype.h"
  10 #include "qemu/error-report.h"
  11 #include "qapi/qapi-types-migration.h"
  12 #include "hw/block/block.h"
  13 #include "net/hub.h"
  14 #include "qapi/visitor.h"
  15 #include "chardev/char.h"
  16 #include "qemu/uuid.h"
  17 #include "qemu/units.h"
  18 #include "qemu/cutils.h"
  19
  20 void qdev_prop_set_after_realize(DeviceState *dev, const char *name,
  21                                   Error **errp)
  22 {
  23     if (dev->id) {
  24         error_setg(errp, "Attempt to set property '%s' on device '%s' "
  25                    "(type '%s') after it was realized", name, dev->id,
  26                    object_get_typename(OBJECT(dev)));
  27     } else {
  28         error_setg(errp, "Attempt to set property '%s' on anonymous device "
  29                    "(type '%s') after it was realized", name,
  30                    object_get_typename(OBJECT(dev)));
  31     }
  32 }
  33
  34 void qdev_prop_allow_set_link_before_realize(const Object *obj,
  35                                              const char *name,
  36                                              Object *val, Error **errp)
  37 {
  38     DeviceState *dev = DEVICE(obj);
  39
  40     if (dev->realized) {
  41         error_setg(errp, "Attempt to set link property '%s' on device '%s' "
  42                    "(type '%s') after it was realized",
  43                    name, dev->id, object_get_typename(obj));
  44     }
  45 }
  46
  47 void *qdev_get_prop_ptr(DeviceState *dev, Property *prop)
  48 {
  49     void *ptr = dev;
  50     ptr += prop->offset;
  51     return ptr;
  52 }
  53
  54 static void get_enum(Object *obj, Visitor *v, const char *name, void *opaque,
  55                      Error **errp)
  56 {
  57     DeviceState *dev = DEVICE(obj);
  58     Property *prop = opaque;
  59     int *ptr = qdev_get_prop_ptr(dev, prop);
  60
  61     visit_type_enum(v, prop->name, ptr, prop->info->enum_table, errp);
  62 }
  63
  64 static void set_enum(Object *obj, Visitor *v, const char *name, void *opaque,
  65                      Error **errp)
  66 {
  67     DeviceState *dev = DEVICE(obj);
  68     Property *prop = opaque;
  69     int *ptr = qdev_get_prop_ptr(dev, prop);
  70
  71     if (dev->realized) {
  72         qdev_prop_set_after_realize(dev, name, errp);
  73         return;
  74     }
  75
  76     visit_type_enum(v, prop->name, ptr, prop->info->enum_table, errp);
  77 }
  78
  79 static void set_default_value_enum(ObjectProperty *op, const Property *prop)
  80 {
  81     object_property_set_default_str(op,
  82         qapi_enum_lookup(prop->info->enum_table, prop->defval.i));
  83 }
  84
  85 /* Bit */
  86
  87 static uint32_t qdev_get_prop_mask(Property *prop)
  88 {
  89     assert(prop->info == &qdev_prop_bit);
  90     return 0x1 << prop->bitnr;
  91 }
  92
  93 static void bit_prop_set(DeviceState *dev, Property *props, bool val)
  94 {
  95     uint32_t *p = qdev_get_prop_ptr(dev, props);
  96     uint32_t mask = qdev_get_prop_mask(props);
  97     if (val) {
  98         *p |= mask;
  99     } else {
 100         *p &= ~mask;
 101     }
 102 }
 103
 104 static void prop_get_bit(Object *obj, Visitor *v, const char *name,
 105                          void *opaque, Error **errp)
 106 {
 107     DeviceState *dev = DEVICE(obj);
 108     Property *prop = opaque;
 109     uint32_t *p = qdev_get_prop_ptr(dev, prop);
 110     bool value = (*p & qdev_get_prop_mask(prop)) != 0;
 111
 112     visit_type_bool(v, name, &value, errp);
 113 }
 114
 115 static void prop_set_bit(Object *obj, Visitor *v, const char *name,
 116                          void *opaque, Error **errp)
 117 {
 118     DeviceState *dev = DEVICE(obj);
 119     Property *prop = opaque;
 120     bool value;
 121
 122     if (dev->realized) {
 123         qdev_prop_set_after_realize(dev, name, errp);
 124         return;
 125     }
 126
 127     if (!visit_type_bool(v, name, &value, errp)) {
 128         return;
 129     }
 130     bit_prop_set(dev, prop, value);
 131 }
 132
 133 static void set_default_value_bool(ObjectProperty *op, const Property *prop)
 134 {
 135     object_property_set_default_bool(op, prop->defval.u);
 136 }
 137
 138 const PropertyInfo qdev_prop_bit = {
 139     .name  = "bool",
 140     .description = "on/off",
 141     .get   = prop_get_bit,
 142     .set   = prop_set_bit,
 143     .set_default_value = set_default_value_bool,
 144 };
 145
 146 /* Bit64 */
 147
 148 static uint64_t qdev_get_prop_mask64(Property *prop)
 149 {
 150     assert(prop->info == &qdev_prop_bit64);
 151     return 0x1ull << prop->bitnr;
 152 }
 153
 154 static void bit64_prop_set(DeviceState *dev, Property *props, bool val)
 155 {
 156     uint64_t *p = qdev_get_prop_ptr(dev, props);
 157     uint64_t mask = qdev_get_prop_mask64(props);
 158     if (val) {
 159         *p |= mask;
 160     } else {
 161         *p &= ~mask;
 162     }
 163 }
 164
 165 static void prop_get_bit64(Object *obj, Visitor *v, const char *name,
 166                            void *opaque, Error **errp)
 167 {
 168     DeviceState *dev = DEVICE(obj);
 169     Property *prop = opaque;
 170     uint64_t *p = qdev_get_prop_ptr(dev, prop);
 171     bool value = (*p & qdev_get_prop_mask64(prop)) != 0;
 172
 173     visit_type_bool(v, name, &value, errp);
 174 }
 175
 176 static void prop_set_bit64(Object *obj, Visitor *v, const char *name,
 177                            void *opaque, Error **errp)
 178 {
 179     DeviceState *dev = DEVICE(obj);
 180     Property *prop = opaque;
 181     bool value;
 182
 183     if (dev->realized) {
 184         qdev_prop_set_after_realize(dev, name, errp);
 185         return;
 186     }
 187
 188     if (!visit_type_bool(v, name, &value, errp)) {
 189         return;
 190     }
 191     bit64_prop_set(dev, prop, value);
 192 }
 193
 194 const PropertyInfo qdev_prop_bit64 = {
 195     .name  = "bool",
 196     .description = "on/off",
 197     .get   = prop_get_bit64,
 198     .set   = prop_set_bit64,
 199     .set_default_value = set_default_value_bool,
 200 };
 201
 202 /* --- bool --- */
 203
 204 static void get_bool(Object *obj, Visitor *v, const char *name, void *opaque,
 205                      Error **errp)
 206 {
 207     DeviceState *dev = DEVICE(obj);
 208     Property *prop = opaque;
 209     bool *ptr = qdev_get_prop_ptr(dev, prop);
 210
 211     visit_type_bool(v, name, ptr, errp);
 212 }
 213
 214 static void set_bool(Object *obj, Visitor *v, const char *name, void *opaque,
 215                      Error **errp)
 216 {
 217     DeviceState *dev = DEVICE(obj);
 218     Property *prop = opaque;
 219     bool *ptr = qdev_get_prop_ptr(dev, prop);
 220
 221     if (dev->realized) {
 222         qdev_prop_set_after_realize(dev, name, errp);
 223         return;
 224     }
 225
 226     visit_type_bool(v, name, ptr, errp);
 227 }
 228
 229 const PropertyInfo qdev_prop_bool = {
 230     .name  = "bool",
 231     .get   = get_bool,
 232     .set   = set_bool,
 233     .set_default_value = set_default_value_bool,
 234 };
 235
 236 /* --- 8bit integer --- */
 237
 238 static void get_uint8(Object *obj, Visitor *v, const char *name, void *opaque,
 239                       Error **errp)
 240 {
 241     DeviceState *dev = DEVICE(obj);
 242     Property *prop = opaque;
 243     uint8_t *ptr = qdev_get_prop_ptr(dev, prop);
 244
 245     visit_type_uint8(v, name, ptr, errp);
 246 }
 247
 248 static void set_uint8(Object *obj, Visitor *v, const char *name, void *opaque,
 249                       Error **errp)
 250 {
 251     DeviceState *dev = DEVICE(obj);
 252     Property *prop = opaque;
 253     uint8_t *ptr = qdev_get_prop_ptr(dev, prop);
 254
 255     if (dev->realized) {
 256         qdev_prop_set_after_realize(dev, name, errp);
 257         return;
 258     }
 259
 260     visit_type_uint8(v, name, ptr, errp);
 261 }
 262
 263 static void set_default_value_int(ObjectProperty *op, const Property *prop)
 264 {
 265     object_property_set_default_int(op, prop->defval.i);
 266 }
 267
 268 static void set_default_value_uint(ObjectProperty *op, const Property *prop)
 269 {
 270     object_property_set_default_uint(op, prop->defval.u);
 271 }
 272
 273 const PropertyInfo qdev_prop_uint8 = {
 274     .name  = "uint8",
 275     .get   = get_uint8,
 276     .set   = set_uint8,
 277     .set_default_value = set_default_value_uint,
 278 };
 279
 280 /* --- 16bit integer --- */
 281
 282 static void get_uint16(Object *obj, Visitor *v, const char *name,
 283                        void *opaque, Error **errp)
 284 {
 285     DeviceState *dev = DEVICE(obj);
 286     Property *prop = opaque;
 287     uint16_t *ptr = qdev_get_prop_ptr(dev, prop);
 288
 289     visit_type_uint16(v, name, ptr, errp);
 290 }
 291
 292 static void set_uint16(Object *obj, Visitor *v, const char *name,
 293                        void *opaque, Error **errp)
 294 {
 295     DeviceState *dev = DEVICE(obj);
 296     Property *prop = opaque;
 297     uint16_t *ptr = qdev_get_prop_ptr(dev, prop);
 298
 299     if (dev->realized) {
 300         qdev_prop_set_after_realize(dev, name, errp);
 301         return;
 302     }
 303
 304     visit_type_uint16(v, name, ptr, errp);
 305 }
 306
 307 const PropertyInfo qdev_prop_uint16 = {
 308     .name  = "uint16",
 309     .get   = get_uint16,
 310     .set   = set_uint16,
 311     .set_default_value = set_default_value_uint,
 312 };
 313
 314 /* --- 32bit integer --- */
 315
 316 static void get_uint32(Object *obj, Visitor *v, const char *name,
 317                        void *opaque, Error **errp)
 318 {
 319     DeviceState *dev = DEVICE(obj);
 320     Property *prop = opaque;
 321     uint32_t *ptr = qdev_get_prop_ptr(dev, prop);
 322
 323     visit_type_uint32(v, name, ptr, errp);
 324 }
 325
 326 static void set_uint32(Object *obj, Visitor *v, const char *name,
 327                        void *opaque, Error **errp)
 328 {
 329     DeviceState *dev = DEVICE(obj);
 330     Property *prop = opaque;
 331     uint32_t *ptr = qdev_get_prop_ptr(dev, prop);
 332
 333     if (dev->realized) {
 334         qdev_prop_set_after_realize(dev, name, errp);
 335         return;
 336     }
 337
 338     visit_type_uint32(v, name, ptr, errp);
 339 }
 340
 341 static void get_int32(Object *obj, Visitor *v, const char *name, void *opaque,
 342                       Error **errp)
 343 {
 344     DeviceState *dev = DEVICE(obj);
 345     Property *prop = opaque;
 346     int32_t *ptr = qdev_get_prop_ptr(dev, prop);
 347
 348     visit_type_int32(v, name, ptr, errp);
 349 }
 350
 351 static void set_int32(Object *obj, Visitor *v, const char *name, void *opaque,
 352                       Error **errp)
 353 {
 354     DeviceState *dev = DEVICE(obj);
 355     Property *prop = opaque;
 356     int32_t *ptr = qdev_get_prop_ptr(dev, prop);
 357
 358     if (dev->realized) {
 359         qdev_prop_set_after_realize(dev, name, errp);
 360         return;
 361     }
 362
 363     visit_type_int32(v, name, ptr, errp);
 364 }
 365
 366 const PropertyInfo qdev_prop_uint32 = {
 367     .name  = "uint32",
 368     .get   = get_uint32,
 369     .set   = set_uint32,
 370     .set_default_value = set_default_value_uint,
 371 };
 372
 373 const PropertyInfo qdev_prop_int32 = {
 374     .name  = "int32",
 375     .get   = get_int32,
 376     .set   = set_int32,
 377     .set_default_value = set_default_value_int,
 378 };
 379
 380 /* --- 64bit integer --- */
 381
 382 static void get_uint64(Object *obj, Visitor *v, const char *name,
 383                        void *opaque, Error **errp)
 384 {
 385     DeviceState *dev = DEVICE(obj);
 386     Property *prop = opaque;
 387     uint64_t *ptr = qdev_get_prop_ptr(dev, prop);
 388
 389     visit_type_uint64(v, name, ptr, errp);
 390 }
 391
 392 static void set_uint64(Object *obj, Visitor *v, const char *name,
 393                        void *opaque, Error **errp)
 394 {
 395     DeviceState *dev = DEVICE(obj);
 396     Property *prop = opaque;
 397     uint64_t *ptr = qdev_get_prop_ptr(dev, prop);
 398
 399     if (dev->realized) {
 400         qdev_prop_set_after_realize(dev, name, errp);
 401         return;
 402     }
 403
 404     visit_type_uint64(v, name, ptr, errp);
 405 }
 406
 407 static void get_int64(Object *obj, Visitor *v, const char *name,
 408                       void *opaque, Error **errp)
 409 {
 410     DeviceState *dev = DEVICE(obj);
 411     Property *prop = opaque;
 412     int64_t *ptr = qdev_get_prop_ptr(dev, prop);
 413
 414     visit_type_int64(v, name, ptr, errp);
 415 }
 416
 417 static void set_int64(Object *obj, Visitor *v, const char *name,
 418                       void *opaque, Error **errp)
 419 {
 420     DeviceState *dev = DEVICE(obj);
 421     Property *prop = opaque;
 422     int64_t *ptr = qdev_get_prop_ptr(dev, prop);
 423
 424     if (dev->realized) {
 425         qdev_prop_set_after_realize(dev, name, errp);
 426         return;
 427     }
 428
 429     visit_type_int64(v, name, ptr, errp);
 430 }
 431
 432 const PropertyInfo qdev_prop_uint64 = {
 433     .name  = "uint64",
 434     .get   = get_uint64,
 435     .set   = set_uint64,
 436     .set_default_value = set_default_value_uint,
 437 };
 438
 439 const PropertyInfo qdev_prop_int64 = {
 440     .name  = "int64",
 441     .get   = get_int64,
 442     .set   = set_int64,
 443     .set_default_value = set_default_value_int,
 444 };
 445
 446 /* --- string --- */
 447
 448 static void release_string(Object *obj, const char *name, void *opaque)
 449 {
 450     Property *prop = opaque;
 451     g_free(*(char **)qdev_get_prop_ptr(DEVICE(obj), prop));
 452 }
 453
 454 static void get_string(Object *obj, Visitor *v, const char *name,
 455                        void *opaque, Error **errp)
 456 {
 457     DeviceState *dev = DEVICE(obj);
 458     Property *prop = opaque;
 459     char **ptr = qdev_get_prop_ptr(dev, prop);
 460
 461     if (!*ptr) {
 462         char *str = (char *)"";
 463         visit_type_str(v, name, &str, errp);
 464     } else {
 465         visit_type_str(v, name, ptr, errp);
 466     }
 467 }
 468
 469 static void set_string(Object *obj, Visitor *v, const char *name,
 470                        void *opaque, Error **errp)
 471 {
 472     DeviceState *dev = DEVICE(obj);
 473     Property *prop = opaque;
 474     char **ptr = qdev_get_prop_ptr(dev, prop);
 475     char *str;
 476
 477     if (dev->realized) {
 478         qdev_prop_set_after_realize(dev, name, errp);
 479         return;
 480     }
 481
 482     if (!visit_type_str(v, name, &str, errp)) {
 483         return;
 484     }
 485     g_free(*ptr);
 486     *ptr = str;
 487 }
 488
 489 const PropertyInfo qdev_prop_string = {
 490     .name  = "str",
 491     .release = release_string,
 492     .get   = get_string,
 493     .set   = set_string,
 494 };
 495
 496 /* --- mac address --- */
 497
 498 /*
 499  * accepted syntax versions:
 500  *   01:02:03:04:05:06
 501  *   01-02-03-04-05-06
 502  */
 503 static void get_mac(Object *obj, Visitor *v, const char *name, void *opaque,
 504                     Error **errp)
 505 {
 506     DeviceState *dev = DEVICE(obj);
 507     Property *prop = opaque;
 508     MACAddr *mac = qdev_get_prop_ptr(dev, prop);
 509     char buffer[2 * 6 + 5 + 1];
 510     char *p = buffer;
 511
 512     snprintf(buffer, sizeof(buffer), "%02x:%02x:%02x:%02x:%02x:%02x",
 513              mac->a[0], mac->a[1], mac->a[2],
 514              mac->a[3], mac->a[4], mac->a[5]);
 515
 516     visit_type_str(v, name, &p, errp);
 517 }
 518
 519 static void set_mac(Object *obj, Visitor *v, const char *name, void *opaque,
 520                     Error **errp)
 521 {
 522     DeviceState *dev = DEVICE(obj);
 523     Property *prop = opaque;
 524     MACAddr *mac = qdev_get_prop_ptr(dev, prop);
 525     int i, pos;
 526     char *str, *p;
 527
 528     if (dev->realized) {
 529         qdev_prop_set_after_realize(dev, name, errp);
 530         return;
 531     }
 532
 533     if (!visit_type_str(v, name, &str, errp)) {
 534         return;
 535     }
 536
 537     for (i = 0, pos = 0; i < 6; i++, pos += 3) {
 538         if (!qemu_isxdigit(str[pos])) {
 539             goto inval;
 540         }
 541         if (!qemu_isxdigit(str[pos+1])) {
 542             goto inval;
 543         }
 544         if (i == 5) {
 545             if (str[pos+2] != '\0') {
 546                 goto inval;
 547             }
 548         } else {
 549             if (str[pos+2] != ':' && str[pos+2] != '-') {
 550                 goto inval;
 551             }
 552         }
 553         mac->a[i] = strtol(str+pos, &p, 16);
 554     }
 555     g_free(str);
 556     return;
 557
 558 inval:
 559     error_set_from_qdev_prop_error(errp, EINVAL, dev, prop, str);
 560     g_free(str);
 561 }
 562
 563 const PropertyInfo qdev_prop_macaddr = {
 564     .name  = "str",
 565     .description = "Ethernet 6-byte MAC Address, example: 52:54:00:12:34:56",
 566     .get   = get_mac,
 567     .set   = set_mac,
 568 };
 569
 570 /* --- Reserved Region --- */
 571
 572 /*
 573  * Accepted syntax:
 574  *   <low address>:<high address>:<type>
 575  *   where low/high addresses are uint64_t in hexadecimal
 576  *   and type is a non-negative decimal integer
 577  */
 578 static void get_reserved_region(Object *obj, Visitor *v, const char *name,
 579                                 void *opaque, Error **errp)
 580 {
 581     DeviceState *dev = DEVICE(obj);
 582     Property *prop = opaque;
 583     ReservedRegion *rr = qdev_get_prop_ptr(dev, prop);
 584     char buffer[64];
 585     char *p = buffer;
 586     int rc;
 587
 588     rc = snprintf(buffer, sizeof(buffer), "0x%"PRIx64":0x%"PRIx64":%u",
 589                   rr->low, rr->high, rr->type);
 590     assert(rc < sizeof(buffer));
 591
 592     visit_type_str(v, name, &p, errp);
 593 }
 594
 595 static void set_reserved_region(Object *obj, Visitor *v, const char *name,
 596                                 void *opaque, Error **errp)
 597 {
 598     DeviceState *dev = DEVICE(obj);
 599     Property *prop = opaque;
 600     ReservedRegion *rr = qdev_get_prop_ptr(dev, prop);
 601     Error *local_err = NULL;
 602     const char *endptr;
 603     char *str;
 604     int ret;
 605
 606     if (dev->realized) {
 607         qdev_prop_set_after_realize(dev, name, errp);
 608         return;
 609     }
 610
 611     visit_type_str(v, name, &str, &local_err);
 612     if (local_err) {
 613         error_propagate(errp, local_err);
 614         return;
 615     }
 616
 617     ret = qemu_strtou64(str, &endptr, 16, &rr->low);
 618     if (ret) {
 619         error_setg(errp, "start address of '%s'"
 620                    " must be a hexadecimal integer", name);
 621         goto out;
 622     }
 623     if (*endptr != ':') {
 624         goto separator_error;
 625     }
 626
 627     ret = qemu_strtou64(endptr + 1, &endptr, 16, &rr->high);
 628     if (ret) {
 629         error_setg(errp, "end address of '%s'"
 630                    " must be a hexadecimal integer", name);
 631         goto out;
 632     }
 633     if (*endptr != ':') {
 634         goto separator_error;
 635     }
 636
 637     ret = qemu_strtoui(endptr + 1, &endptr, 10, &rr->type);
 638     if (ret) {
 639         error_setg(errp, "type of '%s'"
 640                    " must be a non-negative decimal integer", name);
 641     }
 642     goto out;
 643
 644 separator_error:
 645     error_setg(errp, "reserved region fields must be separated with ':'");
 646 out:
 647     g_free(str);
 648     return;
 649 }
 650
 651 const PropertyInfo qdev_prop_reserved_region = {
 652     .name  = "reserved_region",
 653     .description = "Reserved Region, example: 0xFEE00000:0xFEEFFFFF:0",
 654     .get   = get_reserved_region,
 655     .set   = set_reserved_region,
 656 };
 657
 658 /* --- on/off/auto --- */
 659
 660 const PropertyInfo qdev_prop_on_off_auto = {
 661     .name = "OnOffAuto",
 662     .description = "on/off/auto",
 663     .enum_table = &OnOffAuto_lookup,
 664     .get = get_enum,
 665     .set = set_enum,
 666     .set_default_value = set_default_value_enum,
 667 };
 668
 669 /* --- lost tick policy --- */
 670
 671 QEMU_BUILD_BUG_ON(sizeof(LostTickPolicy) != sizeof(int));
 672
 673 const PropertyInfo qdev_prop_losttickpolicy = {
 674     .name  = "LostTickPolicy",
 675     .enum_table  = &LostTickPolicy_lookup,
 676     .get   = get_enum,
 677     .set   = set_enum,
 678     .set_default_value = set_default_value_enum,
 679 };
 680
 681 /* --- Block device error handling policy --- */
 682
 683 QEMU_BUILD_BUG_ON(sizeof(BlockdevOnError) != sizeof(int));
 684
 685 const PropertyInfo qdev_prop_blockdev_on_error = {
 686     .name = "BlockdevOnError",
 687     .description = "Error handling policy, "
 688                    "report/ignore/enospc/stop/auto",
 689     .enum_table = &BlockdevOnError_lookup,
 690     .get = get_enum,
 691     .set = set_enum,
 692     .set_default_value = set_default_value_enum,
 693 };
 694
 695 /* --- BIOS CHS translation */
 696
 697 QEMU_BUILD_BUG_ON(sizeof(BiosAtaTranslation) != sizeof(int));
 698
 699 const PropertyInfo qdev_prop_bios_chs_trans = {
 700     .name = "BiosAtaTranslation",
 701     .description = "Logical CHS translation algorithm, "
 702                    "auto/none/lba/large/rechs",
 703     .enum_table = &BiosAtaTranslation_lookup,
 704     .get = get_enum,
 705     .set = set_enum,
 706     .set_default_value = set_default_value_enum,
 707 };
 708
 709 /* --- FDC default drive types */
 710
 711 const PropertyInfo qdev_prop_fdc_drive_type = {
 712     .name = "FdcDriveType",
 713     .description = "FDC drive type, "
 714                    "144/288/120/none/auto",
 715     .enum_table = &FloppyDriveType_lookup,
 716     .get = get_enum,
 717     .set = set_enum,
 718     .set_default_value = set_default_value_enum,
 719 };
 720
 721 /* --- MultiFDCompression --- */
 722
 723 const PropertyInfo qdev_prop_multifd_compression = {
 724     .name = "MultiFDCompression",
 725     .description = "multifd_compression values, "
 726                    "none/zlib/zstd",
 727     .enum_table = &MultiFDCompression_lookup,
 728     .get = get_enum,
 729     .set = set_enum,
 730     .set_default_value = set_default_value_enum,
 731 };
 732
 733 /* --- pci address --- */
 734
 735 /*
 736  * bus-local address, i.e. "$slot" or "$slot.$fn"
 737  */
 738 static void set_pci_devfn(Object *obj, Visitor *v, const char *name,
 739                           void *opaque, Error **errp)
 740 {
 741     DeviceState *dev = DEVICE(obj);
 742     Property *prop = opaque;
 743     int32_t value, *ptr = qdev_get_prop_ptr(dev, prop);
 744     unsigned int slot, fn, n;
 745     char *str;
 746
 747     if (dev->realized) {
 748         qdev_prop_set_after_realize(dev, name, errp);
 749         return;
 750     }
 751
 752     if (!visit_type_str(v, name, &str, NULL)) {
 753         if (!visit_type_int32(v, name, &value, errp)) {
 754             return;
 755         }
 756         if (value < -1 || value > 255) {
 757             error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
 758                        name ? name : "null", "pci_devfn");
 759             return;
 760         }
 761         *ptr = value;
 762         return;
 763     }
 764
 765     if (sscanf(str, "%x.%x%n", &slot, &fn, &n) != 2) {
 766         fn = 0;
 767         if (sscanf(str, "%x%n", &slot, &n) != 1) {
 768             goto invalid;
 769         }
 770     }
 771     if (str[n] != '\0' || fn > 7 || slot > 31) {
 772         goto invalid;
 773     }
 774     *ptr = slot << 3 | fn;
 775     g_free(str);
 776     return;
 777
 778 invalid:
 779     error_set_from_qdev_prop_error(errp, EINVAL, dev, prop, str);
 780     g_free(str);
 781 }
 782
 783 static int print_pci_devfn(DeviceState *dev, Property *prop, char *dest,
 784                            size_t len)
 785 {
 786     int32_t *ptr = qdev_get_prop_ptr(dev, prop);
 787
 788     if (*ptr == -1) {
 789         return snprintf(dest, len, "<unset>");
 790     } else {
 791         return snprintf(dest, len, "%02x.%x", *ptr >> 3, *ptr & 7);
 792     }
 793 }
 794
 795 const PropertyInfo qdev_prop_pci_devfn = {
 796     .name  = "int32",
 797     .description = "Slot and optional function number, example: 06.0 or 06",
 798     .print = print_pci_devfn,
 799     .get   = get_int32,
 800     .set   = set_pci_devfn,
 801     .set_default_value = set_default_value_int,
 802 };
 803
 804 /* --- 32bit unsigned int 'size' type --- */
 805
 806 static void get_size32(Object *obj, Visitor *v, const char *name, void *opaque,
 807                        Error **errp)
 808 {
 809     DeviceState *dev = DEVICE(obj);
 810     Property *prop = opaque;
 811     uint32_t *ptr = qdev_get_prop_ptr(dev, prop);
 812     uint64_t value = *ptr;
 813
 814     visit_type_size(v, name, &value, errp);
 815 }
 816
 817 static void set_size32(Object *obj, Visitor *v, const char *name, void *opaque,
 818                        Error **errp)
 819 {
 820     DeviceState *dev = DEVICE(obj);
 821     Property *prop = opaque;
 822     uint32_t *ptr = qdev_get_prop_ptr(dev, prop);
 823     uint64_t value;
 824
 825     if (dev->realized) {
 826         qdev_prop_set_after_realize(dev, name, errp);
 827         return;
 828     }
 829
 830     if (!visit_type_size(v, name, &value, errp)) {
 831         return;
 832     }
 833
 834     if (value > UINT32_MAX) {
 835         error_setg(errp,
 836                    "Property %s.%s doesn't take value %" PRIu64
 837                    " (maximum: %u)",
 838                    dev->id ? : "", name, value, UINT32_MAX);
 839         return;
 840     }
 841
 842     *ptr = value;
 843 }
 844
 845 const PropertyInfo qdev_prop_size32 = {
 846     .name  = "size",
 847     .get = get_size32,
 848     .set = set_size32,
 849     .set_default_value = set_default_value_uint,
 850 };
 851
 852 /* --- blocksize --- */
 853
 854 /* lower limit is sector size */
 855 #define MIN_BLOCK_SIZE          512
 856 #define MIN_BLOCK_SIZE_STR      "512 B"
 857 /*
 858  * upper limit is arbitrary, 2 MiB looks sufficient for all sensible uses, and
 859  * matches qcow2 cluster size limit
 860  */
 861 #define MAX_BLOCK_SIZE          (2 * MiB)
 862 #define MAX_BLOCK_SIZE_STR      "2 MiB"
 863
 864 static void set_blocksize(Object *obj, Visitor *v, const char *name,
 865                           void *opaque, Error **errp)
 866 {
 867     DeviceState *dev = DEVICE(obj);
 868     Property *prop = opaque;
 869     uint32_t *ptr = qdev_get_prop_ptr(dev, prop);
 870     uint64_t value;
 871
 872     if (dev->realized) {
 873         qdev_prop_set_after_realize(dev, name, errp);
 874         return;
 875     }
 876
 877     if (!visit_type_size(v, name, &value, errp)) {
 878         return;
 879     }
 880     /* value of 0 means "unset" */
 881     if (value && (value < MIN_BLOCK_SIZE || value > MAX_BLOCK_SIZE)) {
 882         error_setg(errp,
 883                    "Property %s.%s doesn't take value %" PRIu64
 884                    " (minimum: " MIN_BLOCK_SIZE_STR
 885                    ", maximum: " MAX_BLOCK_SIZE_STR ")",
 886                    dev->id ? : "", name, value);
 887         return;
 888     }
 889
 890     /* We rely on power-of-2 blocksizes for bitmasks */
 891     if ((value & (value - 1)) != 0) {
 892         error_setg(errp,
 893                   "Property %s.%s doesn't take value '%" PRId64 "', it's not a power of 2",
 894                   dev->id ?: "", name, (int64_t)value);
 895         return;
 896     }
 897
 898     *ptr = value;
 899 }
 900
 901 const PropertyInfo qdev_prop_blocksize = {
 902     .name  = "size",
 903     .description = "A power of two between " MIN_BLOCK_SIZE_STR
 904                    " and " MAX_BLOCK_SIZE_STR,
 905     .get   = get_size32,
 906     .set   = set_blocksize,
 907     .set_default_value = set_default_value_uint,
 908 };
 909
 910 /* --- pci host address --- */
 911
 912 static void get_pci_host_devaddr(Object *obj, Visitor *v, const char *name,
 913                                  void *opaque, Error **errp)
 914 {
 915     DeviceState *dev = DEVICE(obj);
 916     Property *prop = opaque;
 917     PCIHostDeviceAddress *addr = qdev_get_prop_ptr(dev, prop);
 918     char buffer[] = "ffff:ff:ff.f";
 919     char *p = buffer;
 920     int rc = 0;
 921
 922     /*
 923      * Catch "invalid" device reference from vfio-pci and allow the
 924      * default buffer representing the non-existent device to be used.
 925      */
 926     if (~addr->domain || ~addr->bus || ~addr->slot || ~addr->function) {
 927         rc = snprintf(buffer, sizeof(buffer), "%04x:%02x:%02x.%0d",
 928                       addr->domain, addr->bus, addr->slot, addr->function);
 929         assert(rc == sizeof(buffer) - 1);
 930     }
 931
 932     visit_type_str(v, name, &p, errp);
 933 }
 934
 935 /*
 936  * Parse [<domain>:]<bus>:<slot>.<func>
 937  *   if <domain> is not supplied, it's assumed to be 0.
 938  */
 939 static void set_pci_host_devaddr(Object *obj, Visitor *v, const char *name,
 940                                  void *opaque, Error **errp)
 941 {
 942     DeviceState *dev = DEVICE(obj);
 943     Property *prop = opaque;
 944     PCIHostDeviceAddress *addr = qdev_get_prop_ptr(dev, prop);
 945     char *str, *p;
 946     char *e;
 947     unsigned long val;
 948     unsigned long dom = 0, bus = 0;
 949     unsigned int slot = 0, func = 0;
 950
 951     if (dev->realized) {
 952         qdev_prop_set_after_realize(dev, name, errp);
 953         return;
 954     }
 955
 956     if (!visit_type_str(v, name, &str, errp)) {
 957         return;
 958     }
 959
 960     p = str;
 961     val = strtoul(p, &e, 16);
 962     if (e == p || *e != ':') {
 963         goto inval;
 964     }
 965     bus = val;
 966
 967     p = e + 1;
 968     val = strtoul(p, &e, 16);
 969     if (e == p) {
 970         goto inval;
 971     }
 972     if (*e == ':') {
 973         dom = bus;
 974         bus = val;
 975         p = e + 1;
 976         val = strtoul(p, &e, 16);
 977         if (e == p) {
 978             goto inval;
 979         }
 980     }
 981     slot = val;
 982
 983     if (*e != '.') {
 984         goto inval;
 985     }
 986     p = e + 1;
 987     val = strtoul(p, &e, 10);
 988     if (e == p) {
 989         goto inval;
 990     }
 991     func = val;
 992
 993     if (dom > 0xffff || bus > 0xff || slot > 0x1f || func > 7) {
 994         goto inval;
 995     }
 996
 997     if (*e) {
 998         goto inval;
 999     }
1000
1001     addr->domain = dom;
1002     addr->bus = bus;
1003     addr->slot = slot;
1004     addr->function = func;
1005
1006     g_free(str);
1007     return;
1008
1009 inval:
1010     error_set_from_qdev_prop_error(errp, EINVAL, dev, prop, str);
1011     g_free(str);
1012 }
1013
1014 const PropertyInfo qdev_prop_pci_host_devaddr = {
1015     .name = "str",
1016     .description = "Address (bus/device/function) of "
1017                    "the host device, example: 04:10.0",
1018     .get = get_pci_host_devaddr,
1019     .set = set_pci_host_devaddr,
1020 };
1021
1022 /* --- UUID --- */
1023
1024 static void get_uuid(Object *obj, Visitor *v, const char *name, void *opaque,
1025                      Error **errp)
1026 {
1027     DeviceState *dev = DEVICE(obj);
1028     Property *prop = opaque;
1029     QemuUUID *uuid = qdev_get_prop_ptr(dev, prop);
1030     char buffer[UUID_FMT_LEN + 1];
1031     char *p = buffer;
1032
1033     qemu_uuid_unparse(uuid, buffer);
1034
1035     visit_type_str(v, name, &p, errp);
1036 }
1037
1038 #define UUID_VALUE_AUTO        "auto"
1039
1040 static void set_uuid(Object *obj, Visitor *v, const char *name, void *opaque,
1041                     Error **errp)
1042 {
1043     DeviceState *dev = DEVICE(obj);
1044     Property *prop = opaque;
1045     QemuUUID *uuid = qdev_get_prop_ptr(dev, prop);
1046     char *str;
1047
1048     if (dev->realized) {
1049         qdev_prop_set_after_realize(dev, name, errp);
1050         return;
1051     }
1052
1053     if (!visit_type_str(v, name, &str, errp)) {
1054         return;
1055     }
1056
1057     if (!strcmp(str, UUID_VALUE_AUTO)) {
1058         qemu_uuid_generate(uuid);
1059     } else if (qemu_uuid_parse(str, uuid) < 0) {
1060         error_set_from_qdev_prop_error(errp, EINVAL, dev, prop, str);
1061     }
1062     g_free(str);
1063 }
1064
1065 static void set_default_uuid_auto(ObjectProperty *op, const Property *prop)
1066 {
1067     object_property_set_default_str(op, UUID_VALUE_AUTO);
1068 }
1069
1070 const PropertyInfo qdev_prop_uuid = {
1071     .name  = "str",
1072     .description = "UUID (aka GUID) or \"" UUID_VALUE_AUTO
1073         "\" for random value (default)",
1074     .get   = get_uuid,
1075     .set   = set_uuid,
1076     .set_default_value = set_default_uuid_auto,
1077 };
1078
1079 /* --- support for array properties --- */
1080
1081 /* Used as an opaque for the object properties we add for each
1082  * array element. Note that the struct Property must be first
1083  * in the struct so that a pointer to this works as the opaque
1084  * for the underlying element's property hooks as well as for
1085  * our own release callback.
1086  */
1087 typedef struct {
1088     struct Property prop;
1089     char *propname;
1090     ObjectPropertyRelease *release;
1091 } ArrayElementProperty;
1092
1093 /* object property release callback for array element properties:
1094  * we call the underlying element's property release hook, and
1095  * then free the memory we allocated when we added the property.
1096  */
1097 static void array_element_release(Object *obj, const char *name, void *opaque)
1098 {
1099     ArrayElementProperty *p = opaque;
1100     if (p->release) {
1101         p->release(obj, name, opaque);
1102     }
1103     g_free(p->propname);
1104     g_free(p);
1105 }
1106
1107 static void set_prop_arraylen(Object *obj, Visitor *v, const char *name,
1108                               void *opaque, Error **errp)
1109 {
1110     /* Setter for the property which defines the length of a
1111      * variable-sized property array. As well as actually setting the
1112      * array-length field in the device struct, we have to create the
1113      * array itself and dynamically add the corresponding properties.
1114      */
1115     DeviceState *dev = DEVICE(obj);
1116     Property *prop = opaque;
1117     uint32_t *alenptr = qdev_get_prop_ptr(dev, prop);
1118     void **arrayptr = (void *)dev + prop->arrayoffset;
1119     void *eltptr;
1120     const char *arrayname;
1121     int i;
1122
1123     if (dev->realized) {
1124         qdev_prop_set_after_realize(dev, name, errp);
1125         return;
1126     }
1127     if (*alenptr) {
1128         error_setg(errp, "array size property %s may not be set more than once",
1129                    name);
1130         return;
1131     }
1132     if (!visit_type_uint32(v, name, alenptr, errp)) {
1133         return;
1134     }
1135     if (!*alenptr) {
1136         return;
1137     }
1138
1139     /* DEFINE_PROP_ARRAY guarantees that name should start with this prefix;
1140      * strip it off so we can get the name of the array itself.
1141      */
1142     assert(strncmp(name, PROP_ARRAY_LEN_PREFIX,
1143                    strlen(PROP_ARRAY_LEN_PREFIX)) == 0);
1144     arrayname = name + strlen(PROP_ARRAY_LEN_PREFIX);
1145
1146     /* Note that it is the responsibility of the individual device's deinit
1147      * to free the array proper.
1148      */
1149     *arrayptr = eltptr = g_malloc0(*alenptr * prop->arrayfieldsize);
1150     for (i = 0; i < *alenptr; i++, eltptr += prop->arrayfieldsize) {
1151         char *propname = g_strdup_printf("%s[%d]", arrayname, i);
1152         ArrayElementProperty *arrayprop = g_new0(ArrayElementProperty, 1);
1153         arrayprop->release = prop->arrayinfo->release;
1154         arrayprop->propname = propname;
1155         arrayprop->prop.info = prop->arrayinfo;
1156         arrayprop->prop.name = propname;
1157         /* This ugly piece of pointer arithmetic sets up the offset so
1158          * that when the underlying get/set hooks call qdev_get_prop_ptr
1159          * they get the right answer despite the array element not actually
1160          * being inside the device struct.
1161          */
1162         arrayprop->prop.offset = eltptr - (void *)dev;
1163         assert(qdev_get_prop_ptr(dev, &arrayprop->prop) == eltptr);
1164         object_property_add(obj, propname,
1165                             arrayprop->prop.info->name,
1166                             arrayprop->prop.info->get,
1167                             arrayprop->prop.info->set,
1168                             array_element_release,
1169                             arrayprop);
1170     }
1171 }
1172
1173 const PropertyInfo qdev_prop_arraylen = {
1174     .name = "uint32",
1175     .get = get_uint32,
1176     .set = set_prop_arraylen,
1177     .set_default_value = set_default_value_uint,
1178 };
1179
1180 /* --- public helpers --- */
1181
1182 static Property *qdev_prop_walk(Property *props, const char *name)
1183 {
1184     if (!props) {
1185         return NULL;
1186     }
1187     while (props->name) {
1188         if (strcmp(props->name, name) == 0) {
1189             return props;
1190         }
1191         props++;
1192     }
1193     return NULL;
1194 }
1195
1196 static Property *qdev_prop_find(DeviceState *dev, const char *name)
1197 {
1198     ObjectClass *class;
1199     Property *prop;
1200
1201     /* device properties */
1202     class = object_get_class(OBJECT(dev));
1203     do {
1204         prop = qdev_prop_walk(DEVICE_CLASS(class)->props_, name);
1205         if (prop) {
1206             return prop;
1207         }
1208         class = object_class_get_parent(class);
1209     } while (class != object_class_by_name(TYPE_DEVICE));
1210
1211     return NULL;
1212 }
1213
1214 void error_set_from_qdev_prop_error(Error **errp, int ret, DeviceState *dev,
1215                                     Property *prop, const char *value)
1216 {
1217     switch (ret) {
1218     case -EEXIST:
1219         error_setg(errp, "Property '%s.%s' can't take value '%s', it's in use",
1220                   object_get_typename(OBJECT(dev)), prop->name, value);
1221         break;
1222     default:
1223     case -EINVAL:
1224         error_setg(errp, QERR_PROPERTY_VALUE_BAD,
1225                    object_get_typename(OBJECT(dev)), prop->name, value);
1226         break;
1227     case -ENOENT:
1228         error_setg(errp, "Property '%s.%s' can't find value '%s'",
1229                   object_get_typename(OBJECT(dev)), prop->name, value);
1230         break;
1231     case 0:
1232         break;
1233     }
1234 }
1235
1236 void qdev_prop_set_bit(DeviceState *dev, const char *name, bool value)
1237 {
1238     object_property_set_bool(OBJECT(dev), name, value, &error_abort);
1239 }
1240
1241 void qdev_prop_set_uint8(DeviceState *dev, const char *name, uint8_t value)
1242 {
1243     object_property_set_int(OBJECT(dev), name, value, &error_abort);
1244 }
1245
1246 void qdev_prop_set_uint16(DeviceState *dev, const char *name, uint16_t value)
1247 {
1248     object_property_set_int(OBJECT(dev), name, value, &error_abort);
1249 }
1250
1251 void qdev_prop_set_uint32(DeviceState *dev, const char *name, uint32_t value)
1252 {
1253     object_property_set_int(OBJECT(dev), name, value, &error_abort);
1254 }
1255
1256 void qdev_prop_set_int32(DeviceState *dev, const char *name, int32_t value)
1257 {
1258     object_property_set_int(OBJECT(dev), name, value, &error_abort);
1259 }
1260
1261 void qdev_prop_set_uint64(DeviceState *dev, const char *name, uint64_t value)
1262 {
1263     object_property_set_int(OBJECT(dev), name, value, &error_abort);
1264 }
1265
1266 void qdev_prop_set_string(DeviceState *dev, const char *name, const char *value)
1267 {
1268     object_property_set_str(OBJECT(dev), name, value, &error_abort);
1269 }
1270
1271 void qdev_prop_set_macaddr(DeviceState *dev, const char *name,
1272                            const uint8_t *value)
1273 {
1274     char str[2 * 6 + 5 + 1];
1275     snprintf(str, sizeof(str), "%02x:%02x:%02x:%02x:%02x:%02x",
1276              value[0], value[1], value[2], value[3], value[4], value[5]);
1277
1278     object_property_set_str(OBJECT(dev), name, str, &error_abort);
1279 }
1280
1281 void qdev_prop_set_enum(DeviceState *dev, const char *name, int value)
1282 {
1283     Property *prop;
1284
1285     prop = qdev_prop_find(dev, name);
1286     object_property_set_str(OBJECT(dev), name,
1287                             qapi_enum_lookup(prop->info->enum_table, value),
1288                             &error_abort);
1289 }
1290
1291 static GPtrArray *global_props(void)
1292 {
1293     static GPtrArray *gp;
1294
1295     if (!gp) {
1296         gp = g_ptr_array_new();
1297     }
1298
1299     return gp;
1300 }
1301
1302 void qdev_prop_register_global(GlobalProperty *prop)
1303 {
1304     g_ptr_array_add(global_props(), prop);
1305 }
1306
1307 const GlobalProperty *qdev_find_global_prop(DeviceState *dev,
1308                                             const char *name)
1309 {
1310     GPtrArray *props = global_props();
1311     const GlobalProperty *p;
1312     int i;
1313
1314     for (i = 0; i < props->len; i++) {
1315         p = g_ptr_array_index(props, i);
1316         if (object_dynamic_cast(OBJECT(dev), p->driver)
1317             && !strcmp(p->property, name)) {
1318             return p;
1319         }
1320     }
1321     return NULL;
1322 }
1323
1324 int qdev_prop_check_globals(void)
1325 {
1326     int i, ret = 0;
1327
1328     for (i = 0; i < global_props()->len; i++) {
1329         GlobalProperty *prop;
1330         ObjectClass *oc;
1331         DeviceClass *dc;
1332
1333         prop = g_ptr_array_index(global_props(), i);
1334         if (prop->used) {
1335             continue;
1336         }
1337         oc = object_class_by_name(prop->driver);
1338         oc = object_class_dynamic_cast(oc, TYPE_DEVICE);
1339         if (!oc) {
1340             warn_report("global %s.%s has invalid class name",
1341                         prop->driver, prop->property);
1342             ret = 1;
1343             continue;
1344         }
1345         dc = DEVICE_CLASS(oc);
1346         if (!dc->hotpluggable && !prop->used) {
1347             warn_report("global %s.%s=%s not used",
1348                         prop->driver, prop->property, prop->value);
1349             ret = 1;
1350             continue;
1351         }
1352     }
1353     return ret;
1354 }
1355
1356 void qdev_prop_set_globals(DeviceState *dev)
1357 {
1358     object_apply_global_props(OBJECT(dev), global_props(),
1359                               dev->hotplugged ? NULL : &error_fatal);
1360 }
1361
1362 /* --- 64bit unsigned int 'size' type --- */
1363
1364 static void get_size(Object *obj, Visitor *v, const char *name, void *opaque,
1365                      Error **errp)
1366 {
1367     DeviceState *dev = DEVICE(obj);
1368     Property *prop = opaque;
1369     uint64_t *ptr = qdev_get_prop_ptr(dev, prop);
1370
1371     visit_type_size(v, name, ptr, errp);
1372 }
1373
1374 static void set_size(Object *obj, Visitor *v, const char *name, void *opaque,
1375                      Error **errp)
1376 {
1377     DeviceState *dev = DEVICE(obj);
1378     Property *prop = opaque;
1379     uint64_t *ptr = qdev_get_prop_ptr(dev, prop);
1380
1381     visit_type_size(v, name, ptr, errp);
1382 }
1383
1384 const PropertyInfo qdev_prop_size = {
1385     .name  = "size",
1386     .get = get_size,
1387     .set = set_size,
1388     .set_default_value = set_default_value_uint,
1389 };
1390
1391 /* --- object link property --- */
1392
1393 static void create_link_property(ObjectClass *oc, Property *prop)
1394 {
1395     object_class_property_add_link(oc, prop->name, prop->link_type,
1396                                    prop->offset,
1397                                    qdev_prop_allow_set_link_before_realize,
1398                                    OBJ_PROP_LINK_STRONG);
1399 }
1400
1401 const PropertyInfo qdev_prop_link = {
1402     .name = "link",
1403     .create = create_link_property,
1404 };
1405
1406 /* --- OffAutoPCIBAR off/auto/bar0/bar1/bar2/bar3/bar4/bar5 --- */
1407
1408 const PropertyInfo qdev_prop_off_auto_pcibar = {
1409     .name = "OffAutoPCIBAR",
1410     .description = "off/auto/bar0/bar1/bar2/bar3/bar4/bar5",
1411     .enum_table = &OffAutoPCIBAR_lookup,
1412     .get = get_enum,
1413     .set = set_enum,
1414     .set_default_value = set_default_value_enum,
1415 };
1416
1417 /* --- PCIELinkSpeed 2_5/5/8/16 -- */
1418
1419 static void get_prop_pcielinkspeed(Object *obj, Visitor *v, const char *name,
1420                                    void *opaque, Error **errp)
1421 {
1422     DeviceState *dev = DEVICE(obj);
1423     Property *prop = opaque;
1424     PCIExpLinkSpeed *p = qdev_get_prop_ptr(dev, prop);
1425     int speed;
1426
1427     switch (*p) {
1428     case QEMU_PCI_EXP_LNK_2_5GT:
1429         speed = PCIE_LINK_SPEED_2_5;
1430         break;
1431     case QEMU_PCI_EXP_LNK_5GT:
1432         speed = PCIE_LINK_SPEED_5;
1433         break;
1434     case QEMU_PCI_EXP_LNK_8GT:
1435         speed = PCIE_LINK_SPEED_8;
1436         break;
1437     case QEMU_PCI_EXP_LNK_16GT:
1438         speed = PCIE_LINK_SPEED_16;
1439         break;
1440     default:
1441         /* Unreachable */
1442         abort();
1443     }
1444
1445     visit_type_enum(v, prop->name, &speed, prop->info->enum_table, errp);
1446 }
1447
1448 static void set_prop_pcielinkspeed(Object *obj, Visitor *v, const char *name,
1449                                    void *opaque, Error **errp)
1450 {
1451     DeviceState *dev = DEVICE(obj);
1452     Property *prop = opaque;
1453     PCIExpLinkSpeed *p = qdev_get_prop_ptr(dev, prop);
1454     int speed;
1455
1456     if (dev->realized) {
1457         qdev_prop_set_after_realize(dev, name, errp);
1458         return;
1459     }
1460
1461     if (!visit_type_enum(v, prop->name, &speed, prop->info->enum_table,
1462                          errp)) {
1463         return;
1464     }
1465
1466     switch (speed) {
1467     case PCIE_LINK_SPEED_2_5:
1468         *p = QEMU_PCI_EXP_LNK_2_5GT;
1469         break;
1470     case PCIE_LINK_SPEED_5:
1471         *p = QEMU_PCI_EXP_LNK_5GT;
1472         break;
1473     case PCIE_LINK_SPEED_8:
1474         *p = QEMU_PCI_EXP_LNK_8GT;
1475         break;
1476     case PCIE_LINK_SPEED_16:
1477         *p = QEMU_PCI_EXP_LNK_16GT;
1478         break;
1479     default:
1480         /* Unreachable */
1481         abort();
1482     }
1483 }
1484
1485 const PropertyInfo qdev_prop_pcie_link_speed = {
1486     .name = "PCIELinkSpeed",
1487     .description = "2_5/5/8/16",
1488     .enum_table = &PCIELinkSpeed_lookup,
1489     .get = get_prop_pcielinkspeed,
1490     .set = set_prop_pcielinkspeed,
1491     .set_default_value = set_default_value_enum,
1492 };
1493
1494 /* --- PCIELinkWidth 1/2/4/8/12/16/32 -- */
1495
1496 static void get_prop_pcielinkwidth(Object *obj, Visitor *v, const char *name,
1497                                    void *opaque, Error **errp)
1498 {
1499     DeviceState *dev = DEVICE(obj);
1500     Property *prop = opaque;
1501     PCIExpLinkWidth *p = qdev_get_prop_ptr(dev, prop);
1502     int width;
1503
1504     switch (*p) {
1505     case QEMU_PCI_EXP_LNK_X1:
1506         width = PCIE_LINK_WIDTH_1;
1507         break;
1508     case QEMU_PCI_EXP_LNK_X2:
1509         width = PCIE_LINK_WIDTH_2;
1510         break;
1511     case QEMU_PCI_EXP_LNK_X4:
1512         width = PCIE_LINK_WIDTH_4;
1513         break;
1514     case QEMU_PCI_EXP_LNK_X8:
1515         width = PCIE_LINK_WIDTH_8;
1516         break;
1517     case QEMU_PCI_EXP_LNK_X12:
1518         width = PCIE_LINK_WIDTH_12;
1519         break;
1520     case QEMU_PCI_EXP_LNK_X16:
1521         width = PCIE_LINK_WIDTH_16;
1522         break;
1523     case QEMU_PCI_EXP_LNK_X32:
1524         width = PCIE_LINK_WIDTH_32;
1525         break;
1526     default:
1527         /* Unreachable */
1528         abort();
1529     }
1530
1531     visit_type_enum(v, prop->name, &width, prop->info->enum_table, errp);
1532 }
1533
1534 static void set_prop_pcielinkwidth(Object *obj, Visitor *v, const char *name,
1535                                    void *opaque, Error **errp)
1536 {
1537     DeviceState *dev = DEVICE(obj);
1538     Property *prop = opaque;
1539     PCIExpLinkWidth *p = qdev_get_prop_ptr(dev, prop);
1540     int width;
1541
1542     if (dev->realized) {
1543         qdev_prop_set_after_realize(dev, name, errp);
1544         return;
1545     }
1546
1547     if (!visit_type_enum(v, prop->name, &width, prop->info->enum_table,
1548                          errp)) {
1549         return;
1550     }
1551
1552     switch (width) {
1553     case PCIE_LINK_WIDTH_1:
1554         *p = QEMU_PCI_EXP_LNK_X1;
1555         break;
1556     case PCIE_LINK_WIDTH_2:
1557         *p = QEMU_PCI_EXP_LNK_X2;
1558         break;
1559     case PCIE_LINK_WIDTH_4:
1560         *p = QEMU_PCI_EXP_LNK_X4;
1561         break;
1562     case PCIE_LINK_WIDTH_8:
1563         *p = QEMU_PCI_EXP_LNK_X8;
1564         break;
1565     case PCIE_LINK_WIDTH_12:
1566         *p = QEMU_PCI_EXP_LNK_X12;
1567         break;
1568     case PCIE_LINK_WIDTH_16:
1569         *p = QEMU_PCI_EXP_LNK_X16;
1570         break;
1571     case PCIE_LINK_WIDTH_32:
1572         *p = QEMU_PCI_EXP_LNK_X32;
1573         break;
1574     default:
1575         /* Unreachable */
1576         abort();
1577     }
1578 }
1579
1580 const PropertyInfo qdev_prop_pcie_link_width = {
1581     .name = "PCIELinkWidth",
1582     .description = "1/2/4/8/12/16/32",
1583     .enum_table = &PCIELinkWidth_lookup,
1584     .get = get_prop_pcielinkwidth,
1585     .set = set_prop_pcielinkwidth,
1586     .set_default_value = set_default_value_enum,
1587 };