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