hw/qdev-properties.c

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