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 /* --- drive --- */
 197
 198 static int parse_drive(DeviceState *dev, Property *prop, const char *str)
 199 {
 200     DriveInfo **ptr = qdev_get_prop_ptr(dev, prop);
 201
 202     *ptr = drive_get_by_id(str);
 203     if (*ptr == NULL)
 204         return -1;
 205     return 0;
 206 }
 207
 208 static int print_drive(DeviceState *dev, Property *prop, char *dest, size_t len)
 209 {
 210     DriveInfo **ptr = qdev_get_prop_ptr(dev, prop);
 211     return snprintf(dest, len, "%s", (*ptr) ? (*ptr)->id : "<null>");
 212 }
 213
 214 PropertyInfo qdev_prop_drive = {
 215     .name  = "drive",
 216     .type  = PROP_TYPE_DRIVE,
 217     .size  = sizeof(DriveInfo*),
 218     .parse = parse_drive,
 219     .print = print_drive,
 220 };
 221
 222 /* --- character device --- */
 223
 224 static int parse_chr(DeviceState *dev, Property *prop, const char *str)
 225 {
 226     CharDriverState **ptr = qdev_get_prop_ptr(dev, prop);
 227
 228     *ptr = qemu_chr_find(str);
 229     if (*ptr == NULL)
 230         return -1;
 231     return 0;
 232 }
 233
 234 static int print_chr(DeviceState *dev, Property *prop, char *dest, size_t len)
 235 {
 236     CharDriverState **ptr = qdev_get_prop_ptr(dev, prop);
 237
 238     if (*ptr && (*ptr)->label) {
 239         return snprintf(dest, len, "%s", (*ptr)->label);
 240     } else {
 241         return snprintf(dest, len, "<null>");
 242     }
 243 }
 244
 245 PropertyInfo qdev_prop_chr = {
 246     .name  = "chr",
 247     .type  = PROP_TYPE_CHR,
 248     .size  = sizeof(CharDriverState*),
 249     .parse = parse_chr,
 250     .print = print_chr,
 251 };
 252
 253 /* --- pointer --- */
 254
 255 static int print_ptr(DeviceState *dev, Property *prop, char *dest, size_t len)
 256 {
 257     void **ptr = qdev_get_prop_ptr(dev, prop);
 258     return snprintf(dest, len, "<%p>", *ptr);
 259 }
 260
 261 PropertyInfo qdev_prop_ptr = {
 262     .name  = "ptr",
 263     .type  = PROP_TYPE_PTR,
 264     .size  = sizeof(void*),
 265     .print = print_ptr,
 266 };
 267
 268 /* --- mac address --- */
 269
 270 /*
 271  * accepted syntax versions:
 272  *   01:02:03:04:05:06
 273  *   01-02-03-04-05-06
 274  */
 275 static int parse_mac(DeviceState *dev, Property *prop, const char *str)
 276 {
 277     uint8_t *mac = qdev_get_prop_ptr(dev, prop);
 278     int i, pos;
 279     char *p;
 280
 281     for (i = 0, pos = 0; i < 6; i++, pos += 3) {
 282         if (!qemu_isxdigit(str[pos]))
 283             return -1;
 284         if (!qemu_isxdigit(str[pos+1]))
 285             return -1;
 286         if (i == 5 && str[pos+2] != '\0')
 287             return -1;
 288         if (str[pos+2] != ':' && str[pos+2] != '-')
 289             return -1;
 290         mac[i] = strtol(str+pos, &p, 16);
 291     }
 292     return 0;
 293 }
 294
 295 static int print_mac(DeviceState *dev, Property *prop, char *dest, size_t len)
 296 {
 297     uint8_t *mac = qdev_get_prop_ptr(dev, prop);
 298     return snprintf(dest, len, "%02x:%02x:%02x:%02x:%02x:%02x",
 299                     mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
 300 }
 301
 302 PropertyInfo qdev_prop_macaddr = {
 303     .name  = "mac-addr",
 304     .type  = PROP_TYPE_MACADDR,
 305     .size  = 6,
 306     .parse = parse_mac,
 307     .print = print_mac,
 308 };
 309
 310 /* --- pci address --- */
 311
 312 /*
 313  * bus-local address, i.e. "$slot" or "$slot.$fn"
 314  */
 315 static int parse_pci_devfn(DeviceState *dev, Property *prop, const char *str)
 316 {
 317     uint32_t *ptr = qdev_get_prop_ptr(dev, prop);
 318     unsigned int slot, fn, n;
 319
 320     if (sscanf(str, "%x.%x%n", &slot, &fn, &n) != 2) {
 321         fn = 0;
 322         if (sscanf(str, "%x%n", &slot, &n) != 1) {
 323             return -1;
 324         }
 325     }
 326     if (str[n] != '\0')
 327         return -1;
 328     if (fn > 7)
 329         return -1;
 330     *ptr = slot << 3 | fn;
 331     return 0;
 332 }
 333
 334 static int print_pci_devfn(DeviceState *dev, Property *prop, char *dest, size_t len)
 335 {
 336     uint32_t *ptr = qdev_get_prop_ptr(dev, prop);
 337
 338     if (*ptr == -1) {
 339         return snprintf(dest, len, "<unset>");
 340     } else {
 341         return snprintf(dest, len, "%02x.%x", *ptr >> 3, *ptr & 7);
 342     }
 343 }
 344
 345 PropertyInfo qdev_prop_pci_devfn = {
 346     .name  = "pci-devfn",
 347     .type  = PROP_TYPE_UINT32,
 348     .size  = sizeof(uint32_t),
 349     .parse = parse_pci_devfn,
 350     .print = print_pci_devfn,
 351 };
 352
 353 /* --- public helpers --- */
 354
 355 static Property *qdev_prop_walk(Property *props, const char *name)
 356 {
 357     if (!props)
 358         return NULL;
 359     while (props->name) {
 360         if (strcmp(props->name, name) == 0)
 361             return props;
 362         props++;
 363     }
 364     return NULL;
 365 }
 366
 367 static Property *qdev_prop_find(DeviceState *dev, const char *name)
 368 {
 369     Property *prop;
 370
 371     /* device properties */
 372     prop = qdev_prop_walk(dev->info->props, name);
 373     if (prop)
 374         return prop;
 375
 376     /* bus properties */
 377     prop = qdev_prop_walk(dev->parent_bus->info->props, name);
 378     if (prop)
 379         return prop;
 380
 381     return NULL;
 382 }
 383
 384 int qdev_prop_parse(DeviceState *dev, const char *name, const char *value)
 385 {
 386     Property *prop;
 387
 388     prop = qdev_prop_find(dev, name);
 389     if (!prop) {
 390         fprintf(stderr, "property \"%s.%s\" not found\n",
 391                 dev->info->name, name);
 392         return -1;
 393     }
 394     if (!prop->info->parse) {
 395         fprintf(stderr, "property \"%s.%s\" has no parser\n",
 396                 dev->info->name, name);
 397         return -1;
 398     }
 399     return prop->info->parse(dev, prop, value);
 400 }
 401
 402 void qdev_prop_set(DeviceState *dev, const char *name, void *src, enum PropertyType type)
 403 {
 404     Property *prop;
 405     void *dst;
 406
 407     prop = qdev_prop_find(dev, name);
 408     if (!prop) {
 409         fprintf(stderr, "%s: property \"%s.%s\" not found\n",
 410                 __FUNCTION__, dev->info->name, name);
 411         abort();
 412     }
 413     if (prop->info->type != type) {
 414         fprintf(stderr, "%s: property \"%s.%s\" type mismatch\n",
 415                 __FUNCTION__, dev->info->name, name);
 416         abort();
 417     }
 418     dst = qdev_get_prop_ptr(dev, prop);
 419     memcpy(dst, src, prop->info->size);
 420 }
 421
 422 void qdev_prop_set_uint8(DeviceState *dev, const char *name, uint8_t value)
 423 {
 424     qdev_prop_set(dev, name, &value, PROP_TYPE_UINT8);
 425 }
 426
 427 void qdev_prop_set_uint16(DeviceState *dev, const char *name, uint16_t value)
 428 {
 429     qdev_prop_set(dev, name, &value, PROP_TYPE_UINT16);
 430 }
 431
 432 void qdev_prop_set_uint32(DeviceState *dev, const char *name, uint32_t value)
 433 {
 434     qdev_prop_set(dev, name, &value, PROP_TYPE_UINT32);
 435 }
 436
 437 void qdev_prop_set_int32(DeviceState *dev, const char *name, int32_t value)
 438 {
 439     qdev_prop_set(dev, name, &value, PROP_TYPE_INT32);
 440 }
 441
 442 void qdev_prop_set_uint64(DeviceState *dev, const char *name, uint64_t value)
 443 {
 444     qdev_prop_set(dev, name, &value, PROP_TYPE_UINT64);
 445 }
 446
 447 void qdev_prop_set_drive(DeviceState *dev, const char *name, DriveInfo *value)
 448 {
 449     qdev_prop_set(dev, name, &value, PROP_TYPE_DRIVE);
 450 }
 451
 452 void qdev_prop_set_chr(DeviceState *dev, const char *name, CharDriverState *value)
 453 {
 454     qdev_prop_set(dev, name, &value, PROP_TYPE_CHR);
 455 }
 456
 457 void qdev_prop_set_ptr(DeviceState *dev, const char *name, void *value)
 458 {
 459     qdev_prop_set(dev, name, &value, PROP_TYPE_PTR);
 460 }
 461
 462 void qdev_prop_set_defaults(DeviceState *dev, Property *props)
 463 {
 464     char *dst;
 465
 466     if (!props)
 467         return;
 468     while (props->name) {
 469         if (props->defval) {
 470             dst = qdev_get_prop_ptr(dev, props);
 471             memcpy(dst, props->defval, props->info->size);
 472         }
 473         props++;
 474     }
 475 }
 476
 477 static CompatProperty *compat_props;
 478
 479 void qdev_prop_register_compat(CompatProperty *props)
 480 {
 481     compat_props = props;
 482 }
 483
 484 void qdev_prop_set_compat(DeviceState *dev)
 485 {
 486     CompatProperty *prop;
 487
 488     if (!compat_props) {
 489         return;
 490     }
 491     for (prop = compat_props; prop->driver != NULL; prop++) {
 492         if (strcmp(dev->info->name, prop->driver) != 0) {
 493             continue;
 494         }
 495         if (qdev_prop_parse(dev, prop->property, prop->value) != 0) {
 496             abort();
 497         }
 498     }
 499 }