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