hw/qdev-properties.c

   1 #include "sysemu.h"
   2 #include "qdev.h"
   3
   4 void *qdev_get_prop_ptr(DeviceState *dev, Property *prop)
   5 {
   6     void *ptr = dev;
   7     ptr += prop->offset;
   8     return ptr;
   9 }
  10
  11 /* --- 8bit integer --- */
  12
  13 static int parse_uint8(DeviceState *dev, Property *prop, const char *str)
  14 {
  15     uint8_t *ptr = qdev_get_prop_ptr(dev, prop);
  16     const char *fmt;
  17
  18     /* accept both hex and decimal */
  19     fmt = strncasecmp(str, "0x",2) == 0 ? "%" PRIx8 : "%" PRIu8;
  20     if (sscanf(str, fmt, ptr) != 1)
  21         return -1;
  22     return 0;
  23 }
  24
  25 static int print_uint8(DeviceState *dev, Property *prop, char *dest, size_t len)
  26 {
  27     uint8_t *ptr = qdev_get_prop_ptr(dev, prop);
  28     return snprintf(dest, len, "%" PRIu8, *ptr);
  29 }
  30
  31 PropertyInfo qdev_prop_uint8 = {
  32     .name  = "uint8",
  33     .type  = PROP_TYPE_UINT8,
  34     .size  = sizeof(uint8_t),
  35     .parse = parse_uint8,
  36     .print = print_uint8,
  37 };
  38
  39 /* --- 16bit integer --- */
  40
  41 static int parse_uint16(DeviceState *dev, Property *prop, const char *str)
  42 {
  43     uint16_t *ptr = qdev_get_prop_ptr(dev, prop);
  44     const char *fmt;
  45
  46     /* accept both hex and decimal */
  47     fmt = strncasecmp(str, "0x",2) == 0 ? "%" PRIx16 : "%" PRIu16;
  48     if (sscanf(str, fmt, ptr) != 1)
  49         return -1;
  50     return 0;
  51 }
  52
  53 static int print_uint16(DeviceState *dev, Property *prop, char *dest, size_t len)
  54 {
  55     uint16_t *ptr = qdev_get_prop_ptr(dev, prop);
  56     return snprintf(dest, len, "%" PRIu16, *ptr);
  57 }
  58
  59 PropertyInfo qdev_prop_uint16 = {
  60     .name  = "uint16",
  61     .type  = PROP_TYPE_UINT16,
  62     .size  = sizeof(uint16_t),
  63     .parse = parse_uint16,
  64     .print = print_uint16,
  65 };
  66
  67 /* --- 32bit integer --- */
  68
  69 static int parse_uint32(DeviceState *dev, Property *prop, const char *str)
  70 {
  71     uint32_t *ptr = qdev_get_prop_ptr(dev, prop);
  72     const char *fmt;
  73
  74     /* accept both hex and decimal */
  75     fmt = strncasecmp(str, "0x",2) == 0 ? "%" PRIx32 : "%" PRIu32;
  76     if (sscanf(str, fmt, ptr) != 1)
  77         return -1;
  78     return 0;
  79 }
  80
  81 static int print_uint32(DeviceState *dev, Property *prop, char *dest, size_t len)
  82 {
  83     uint32_t *ptr = qdev_get_prop_ptr(dev, prop);
  84     return snprintf(dest, len, "%" PRIu32, *ptr);
  85 }
  86
  87 PropertyInfo qdev_prop_uint32 = {
  88     .name  = "uint32",
  89     .type  = PROP_TYPE_UINT32,
  90     .size  = sizeof(uint32_t),
  91     .parse = parse_uint32,
  92     .print = print_uint32,
  93 };
  94
  95 static int parse_int32(DeviceState *dev, Property *prop, const char *str)
  96 {
  97     int32_t *ptr = qdev_get_prop_ptr(dev, prop);
  98
  99     if (sscanf(str, "%" PRId32, ptr) != 1)
 100         return -1;
 101     return 0;
 102 }
 103
 104 static int print_int32(DeviceState *dev, Property *prop, char *dest, size_t len)
 105 {
 106     int32_t *ptr = qdev_get_prop_ptr(dev, prop);
 107     return snprintf(dest, len, "%" PRId32, *ptr);
 108 }
 109
 110 PropertyInfo qdev_prop_int32 = {
 111     .name  = "int32",
 112     .type  = PROP_TYPE_INT32,
 113     .size  = sizeof(int32_t),
 114     .parse = parse_int32,
 115     .print = print_int32,
 116 };
 117
 118 /* --- 32bit hex value --- */
 119
 120 static int parse_hex32(DeviceState *dev, Property *prop, const char *str)
 121 {
 122     uint32_t *ptr = qdev_get_prop_ptr(dev, prop);
 123
 124     if (sscanf(str, "%" PRIx32, ptr) != 1)
 125         return -1;
 126     return 0;
 127 }
 128
 129 static int print_hex32(DeviceState *dev, Property *prop, char *dest, size_t len)
 130 {
 131     uint32_t *ptr = qdev_get_prop_ptr(dev, prop);
 132     return snprintf(dest, len, "0x%" PRIx32, *ptr);
 133 }
 134
 135 PropertyInfo qdev_prop_hex32 = {
 136     .name  = "hex32",
 137     .type  = PROP_TYPE_UINT32,
 138     .size  = sizeof(uint32_t),
 139     .parse = parse_hex32,
 140     .print = print_hex32,
 141 };
 142
 143 /* --- 64bit integer --- */
 144
 145 static int parse_uint64(DeviceState *dev, Property *prop, const char *str)
 146 {
 147     uint64_t *ptr = qdev_get_prop_ptr(dev, prop);
 148     const char *fmt;
 149
 150     /* accept both hex and decimal */
 151     fmt = strncasecmp(str, "0x",2) == 0 ? "%" PRIx64 : "%" PRIu64;
 152     if (sscanf(str, fmt, ptr) != 1)
 153         return -1;
 154     return 0;
 155 }
 156
 157 static int print_uint64(DeviceState *dev, Property *prop, char *dest, size_t len)
 158 {
 159     uint64_t *ptr = qdev_get_prop_ptr(dev, prop);
 160     return snprintf(dest, len, "%" PRIu64, *ptr);
 161 }
 162
 163 PropertyInfo qdev_prop_uint64 = {
 164     .name  = "uint64",
 165     .type  = PROP_TYPE_UINT64,
 166     .size  = sizeof(uint64_t),
 167     .parse = parse_uint64,
 168     .print = print_uint64,
 169 };
 170
 171 /* --- 64bit hex value --- */
 172
 173 static int parse_hex64(DeviceState *dev, Property *prop, const char *str)
 174 {
 175     uint64_t *ptr = qdev_get_prop_ptr(dev, prop);
 176
 177     if (sscanf(str, "%" PRIx64, ptr) != 1)
 178         return -1;
 179     return 0;
 180 }
 181
 182 static int print_hex64(DeviceState *dev, Property *prop, char *dest, size_t len)
 183 {
 184     uint64_t *ptr = qdev_get_prop_ptr(dev, prop);
 185     return snprintf(dest, len, "0x%" PRIx64, *ptr);
 186 }
 187
 188 PropertyInfo qdev_prop_hex64 = {
 189     .name  = "hex64",
 190     .type  = PROP_TYPE_UINT64,
 191     .size  = sizeof(uint64_t),
 192     .parse = parse_hex64,
 193     .print = print_hex64,
 194 };
 195
 196 /* --- string --- */
 197
 198 static int parse_string(DeviceState *dev, Property *prop, const char *str)
 199 {
 200     char **ptr = qdev_get_prop_ptr(dev, prop);
 201
 202     if (*ptr)
 203         qemu_free(*ptr);
 204     *ptr = qemu_strdup(str);
 205     return 0;
 206 }
 207
 208 static int print_string(DeviceState *dev, Property *prop, char *dest, size_t len)
 209 {
 210     char **ptr = qdev_get_prop_ptr(dev, prop);
 211     if (!*ptr)
 212         return snprintf(dest, len, "<null>");
 213     return snprintf(dest, len, "\"%s\"", *ptr);
 214 }
 215
 216 PropertyInfo qdev_prop_string = {
 217     .name  = "string",
 218     .type  = PROP_TYPE_STRING,
 219     .size  = sizeof(char*),
 220     .parse = parse_string,
 221     .print = print_string,
 222 };
 223
 224 /* --- drive --- */
 225
 226 static int parse_drive(DeviceState *dev, Property *prop, const char *str)
 227 {
 228     DriveInfo **ptr = qdev_get_prop_ptr(dev, prop);
 229
 230     *ptr = drive_get_by_id(str);
 231     if (*ptr == NULL)
 232         return -1;
 233     return 0;
 234 }
 235
 236 static int print_drive(DeviceState *dev, Property *prop, char *dest, size_t len)
 237 {
 238     DriveInfo **ptr = qdev_get_prop_ptr(dev, prop);
 239     return snprintf(dest, len, "%s", (*ptr) ? (*ptr)->id : "<null>");
 240 }
 241
 242 PropertyInfo qdev_prop_drive = {
 243     .name  = "drive",
 244     .type  = PROP_TYPE_DRIVE,
 245     .size  = sizeof(DriveInfo*),
 246     .parse = parse_drive,
 247     .print = print_drive,
 248 };
 249
 250 /* --- character device --- */
 251
 252 static int parse_chr(DeviceState *dev, Property *prop, const char *str)
 253 {
 254     CharDriverState **ptr = qdev_get_prop_ptr(dev, prop);
 255
 256     *ptr = qemu_chr_find(str);
 257     if (*ptr == NULL)
 258         return -1;
 259     return 0;
 260 }
 261
 262 static int print_chr(DeviceState *dev, Property *prop, char *dest, size_t len)
 263 {
 264     CharDriverState **ptr = qdev_get_prop_ptr(dev, prop);
 265
 266     if (*ptr && (*ptr)->label) {
 267         return snprintf(dest, len, "%s", (*ptr)->label);
 268     } else {
 269         return snprintf(dest, len, "<null>");
 270     }
 271 }
 272
 273 PropertyInfo qdev_prop_chr = {
 274     .name  = "chr",
 275     .type  = PROP_TYPE_CHR,
 276     .size  = sizeof(CharDriverState*),
 277     .parse = parse_chr,
 278     .print = print_chr,
 279 };
 280
 281 /* --- pointer --- */
 282
 283 static int print_ptr(DeviceState *dev, Property *prop, char *dest, size_t len)
 284 {
 285     void **ptr = qdev_get_prop_ptr(dev, prop);
 286     return snprintf(dest, len, "<%p>", *ptr);
 287 }
 288
 289 PropertyInfo qdev_prop_ptr = {
 290     .name  = "ptr",
 291     .type  = PROP_TYPE_PTR,
 292     .size  = sizeof(void*),
 293     .print = print_ptr,
 294 };
 295
 296 /* --- mac address --- */
 297
 298 /*
 299  * accepted syntax versions:
 300  *   01:02:03:04:05:06
 301  *   01-02-03-04-05-06
 302  */
 303 static int parse_mac(DeviceState *dev, Property *prop, const char *str)
 304 {
 305     uint8_t *mac = qdev_get_prop_ptr(dev, prop);
 306     int i, pos;
 307     char *p;
 308
 309     for (i = 0, pos = 0; i < 6; i++, pos += 3) {
 310         if (!qemu_isxdigit(str[pos]))
 311             return -1;
 312         if (!qemu_isxdigit(str[pos+1]))
 313             return -1;
 314         if (i == 5 && str[pos+2] != '\0')
 315             return -1;
 316         if (str[pos+2] != ':' && str[pos+2] != '-')
 317             return -1;
 318         mac[i] = strtol(str+pos, &p, 16);
 319     }
 320     return 0;
 321 }
 322
 323 static int print_mac(DeviceState *dev, Property *prop, char *dest, size_t len)
 324 {
 325     uint8_t *mac = qdev_get_prop_ptr(dev, prop);
 326     return snprintf(dest, len, "%02x:%02x:%02x:%02x:%02x:%02x",
 327                     mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
 328 }
 329
 330 PropertyInfo qdev_prop_macaddr = {
 331     .name  = "mac-addr",
 332     .type  = PROP_TYPE_MACADDR,
 333     .size  = 6,
 334     .parse = parse_mac,
 335     .print = print_mac,
 336 };
 337
 338 /* --- pci address --- */
 339
 340 /*
 341  * bus-local address, i.e. "$slot" or "$slot.$fn"
 342  */
 343 static int parse_pci_devfn(DeviceState *dev, Property *prop, const char *str)
 344 {
 345     uint32_t *ptr = qdev_get_prop_ptr(dev, prop);
 346     unsigned int slot, fn, n;
 347
 348     if (sscanf(str, "%x.%x%n", &slot, &fn, &n) != 2) {
 349         fn = 0;
 350         if (sscanf(str, "%x%n", &slot, &n) != 1) {
 351             return -1;
 352         }
 353     }
 354     if (str[n] != '\0')
 355         return -1;
 356     if (fn > 7)
 357         return -1;
 358     *ptr = slot << 3 | fn;
 359     return 0;
 360 }
 361
 362 static int print_pci_devfn(DeviceState *dev, Property *prop, char *dest, size_t len)
 363 {
 364     uint32_t *ptr = qdev_get_prop_ptr(dev, prop);
 365
 366     if (*ptr == -1) {
 367         return snprintf(dest, len, "<unset>");
 368     } else {
 369         return snprintf(dest, len, "%02x.%x", *ptr >> 3, *ptr & 7);
 370     }
 371 }
 372
 373 PropertyInfo qdev_prop_pci_devfn = {
 374     .name  = "pci-devfn",
 375     .type  = PROP_TYPE_UINT32,
 376     .size  = sizeof(uint32_t),
 377     .parse = parse_pci_devfn,
 378     .print = print_pci_devfn,
 379 };
 380
 381 /* --- public helpers --- */
 382
 383 static Property *qdev_prop_walk(Property *props, const char *name)
 384 {
 385     if (!props)
 386         return NULL;
 387     while (props->name) {
 388         if (strcmp(props->name, name) == 0)
 389             return props;
 390         props++;
 391     }
 392     return NULL;
 393 }
 394
 395 static Property *qdev_prop_find(DeviceState *dev, const char *name)
 396 {
 397     Property *prop;
 398
 399     /* device properties */
 400     prop = qdev_prop_walk(dev->info->props, name);
 401     if (prop)
 402         return prop;
 403
 404     /* bus properties */
 405     prop = qdev_prop_walk(dev->parent_bus->info->props, name);
 406     if (prop)
 407         return prop;
 408
 409     return NULL;
 410 }
 411
 412 int qdev_prop_parse(DeviceState *dev, const char *name, const char *value)
 413 {
 414     Property *prop;
 415
 416     prop = qdev_prop_find(dev, name);
 417     if (!prop) {
 418         fprintf(stderr, "property \"%s.%s\" not found\n",
 419                 dev->info->name, name);
 420         return -1;
 421     }
 422     if (!prop->info->parse) {
 423         fprintf(stderr, "property \"%s.%s\" has no parser\n",
 424                 dev->info->name, name);
 425         return -1;
 426     }
 427     return prop->info->parse(dev, prop, value);
 428 }
 429
 430 void qdev_prop_set(DeviceState *dev, const char *name, void *src, enum PropertyType type)
 431 {
 432     Property *prop;
 433     void *dst;
 434
 435     prop = qdev_prop_find(dev, name);
 436     if (!prop) {
 437         fprintf(stderr, "%s: property \"%s.%s\" not found\n",
 438                 __FUNCTION__, dev->info->name, name);
 439         abort();
 440     }
 441     if (prop->info->type != type) {
 442         fprintf(stderr, "%s: property \"%s.%s\" type mismatch\n",
 443                 __FUNCTION__, dev->info->name, name);
 444         abort();
 445     }
 446     dst = qdev_get_prop_ptr(dev, prop);
 447     memcpy(dst, src, prop->info->size);
 448 }
 449
 450 void qdev_prop_set_uint8(DeviceState *dev, const char *name, uint8_t value)
 451 {
 452     qdev_prop_set(dev, name, &value, PROP_TYPE_UINT8);
 453 }
 454
 455 void qdev_prop_set_uint16(DeviceState *dev, const char *name, uint16_t value)
 456 {
 457     qdev_prop_set(dev, name, &value, PROP_TYPE_UINT16);
 458 }
 459
 460 void qdev_prop_set_uint32(DeviceState *dev, const char *name, uint32_t value)
 461 {
 462     qdev_prop_set(dev, name, &value, PROP_TYPE_UINT32);
 463 }
 464
 465 void qdev_prop_set_int32(DeviceState *dev, const char *name, int32_t value)
 466 {
 467     qdev_prop_set(dev, name, &value, PROP_TYPE_INT32);
 468 }
 469
 470 void qdev_prop_set_uint64(DeviceState *dev, const char *name, uint64_t value)
 471 {
 472     qdev_prop_set(dev, name, &value, PROP_TYPE_UINT64);
 473 }
 474
 475 void qdev_prop_set_drive(DeviceState *dev, const char *name, DriveInfo *value)
 476 {
 477     qdev_prop_set(dev, name, &value, PROP_TYPE_DRIVE);
 478 }
 479
 480 void qdev_prop_set_chr(DeviceState *dev, const char *name, CharDriverState *value)
 481 {
 482     qdev_prop_set(dev, name, &value, PROP_TYPE_CHR);
 483 }
 484
 485 void qdev_prop_set_ptr(DeviceState *dev, const char *name, void *value)
 486 {
 487     qdev_prop_set(dev, name, &value, PROP_TYPE_PTR);
 488 }
 489
 490 void qdev_prop_set_defaults(DeviceState *dev, Property *props)
 491 {
 492     char *dst;
 493
 494     if (!props)
 495         return;
 496     while (props->name) {
 497         if (props->defval) {
 498             dst = qdev_get_prop_ptr(dev, props);
 499             memcpy(dst, props->defval, props->info->size);
 500         }
 501         props++;
 502     }
 503 }
 504
 505 static CompatProperty *compat_props;
 506
 507 void qdev_prop_register_compat(CompatProperty *props)
 508 {
 509     compat_props = props;
 510 }
 511
 512 void qdev_prop_set_compat(DeviceState *dev)
 513 {
 514     CompatProperty *prop;
 515
 516     if (!compat_props) {
 517         return;
 518     }
 519     for (prop = compat_props; prop->driver != NULL; prop++) {
 520         if (strcmp(dev->info->name, prop->driver) != 0) {
 521             continue;
 522         }
 523         if (qdev_prop_parse(dev, prop->property, prop->value) != 0) {
 524             abort();
 525         }
 526     }
 527 }