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