[qemu.git] / hw / qdev-properties.c

#include "sysemu.h"
#include "net.h"
#include "qdev.h"

void *qdev_get_prop_ptr(DeviceState *dev, Property *prop)
{
    void *ptr = dev;
    ptr += prop->offset;
    return ptr;
}

/* --- 8bit integer --- */

static int parse_uint8(DeviceState *dev, Property *prop, const char *str)
{
    uint8_t *ptr = qdev_get_prop_ptr(dev, prop);
    const char *fmt;

    /* accept both hex and decimal */
    fmt = strncasecmp(str, "0x",2) == 0 ? "%" PRIx8 : "%" PRIu8;
    if (sscanf(str, fmt, ptr) != 1)
        return -1;
    return 0;
}

static int print_uint8(DeviceState *dev, Property *prop, char *dest, size_t len)
{
    uint8_t *ptr = qdev_get_prop_ptr(dev, prop);
    return snprintf(dest, len, "%" PRIu8, *ptr);
}

PropertyInfo qdev_prop_uint8 = {
    .name  = "uint8",
    .type  = PROP_TYPE_UINT8,
    .size  = sizeof(uint8_t),
    .parse = parse_uint8,
    .print = print_uint8,
};

/* --- 16bit integer --- */

static int parse_uint16(DeviceState *dev, Property *prop, const char *str)
{
    uint16_t *ptr = qdev_get_prop_ptr(dev, prop);
    const char *fmt;

    /* accept both hex and decimal */
    fmt = strncasecmp(str, "0x",2) == 0 ? "%" PRIx16 : "%" PRIu16;
    if (sscanf(str, fmt, ptr) != 1)
        return -1;
    return 0;
}

static int print_uint16(DeviceState *dev, Property *prop, char *dest, size_t len)
{
    uint16_t *ptr = qdev_get_prop_ptr(dev, prop);
    return snprintf(dest, len, "%" PRIu16, *ptr);
}

PropertyInfo qdev_prop_uint16 = {
    .name  = "uint16",
    .type  = PROP_TYPE_UINT16,
    .size  = sizeof(uint16_t),
    .parse = parse_uint16,
    .print = print_uint16,
};

/* --- 32bit integer --- */

static int parse_uint32(DeviceState *dev, Property *prop, const char *str)
{
    uint32_t *ptr = qdev_get_prop_ptr(dev, prop);
    const char *fmt;

    /* accept both hex and decimal */
    fmt = strncasecmp(str, "0x",2) == 0 ? "%" PRIx32 : "%" PRIu32;
    if (sscanf(str, fmt, ptr) != 1)
        return -1;
    return 0;
}

static int print_uint32(DeviceState *dev, Property *prop, char *dest, size_t len)
{
    uint32_t *ptr = qdev_get_prop_ptr(dev, prop);
    return snprintf(dest, len, "%" PRIu32, *ptr);
}

PropertyInfo qdev_prop_uint32 = {
    .name  = "uint32",
    .type  = PROP_TYPE_UINT32,
    .size  = sizeof(uint32_t),
    .parse = parse_uint32,
    .print = print_uint32,
};

static int parse_int32(DeviceState *dev, Property *prop, const char *str)
{
    int32_t *ptr = qdev_get_prop_ptr(dev, prop);

    if (sscanf(str, "%" PRId32, ptr) != 1)
        return -1;
    return 0;
}

static int print_int32(DeviceState *dev, Property *prop, char *dest, size_t len)
{
    int32_t *ptr = qdev_get_prop_ptr(dev, prop);
    return snprintf(dest, len, "%" PRId32, *ptr);
}

PropertyInfo qdev_prop_int32 = {
    .name  = "int32",
    .type  = PROP_TYPE_INT32,
    .size  = sizeof(int32_t),
    .parse = parse_int32,
    .print = print_int32,
};

/* --- 32bit hex value --- */

static int parse_hex32(DeviceState *dev, Property *prop, const char *str)
{
    uint32_t *ptr = qdev_get_prop_ptr(dev, prop);

    if (sscanf(str, "%" PRIx32, ptr) != 1)
        return -1;
    return 0;
}

static int print_hex32(DeviceState *dev, Property *prop, char *dest, size_t len)
{
    uint32_t *ptr = qdev_get_prop_ptr(dev, prop);
    return snprintf(dest, len, "0x%" PRIx32, *ptr);
}

PropertyInfo qdev_prop_hex32 = {
    .name  = "hex32",
    .type  = PROP_TYPE_UINT32,
    .size  = sizeof(uint32_t),
    .parse = parse_hex32,
    .print = print_hex32,
};

/* --- 64bit integer --- */

static int parse_uint64(DeviceState *dev, Property *prop, const char *str)
{
    uint64_t *ptr = qdev_get_prop_ptr(dev, prop);
    const char *fmt;

    /* accept both hex and decimal */
    fmt = strncasecmp(str, "0x",2) == 0 ? "%" PRIx64 : "%" PRIu64;
    if (sscanf(str, fmt, ptr) != 1)
        return -1;
    return 0;
}

static int print_uint64(DeviceState *dev, Property *prop, char *dest, size_t len)
{
    uint64_t *ptr = qdev_get_prop_ptr(dev, prop);
    return snprintf(dest, len, "%" PRIu64, *ptr);
}

PropertyInfo qdev_prop_uint64 = {
    .name  = "uint64",
    .type  = PROP_TYPE_UINT64,
    .size  = sizeof(uint64_t),
    .parse = parse_uint64,
    .print = print_uint64,
};

/* --- 64bit hex value --- */

static int parse_hex64(DeviceState *dev, Property *prop, const char *str)
{
    uint64_t *ptr = qdev_get_prop_ptr(dev, prop);

    if (sscanf(str, "%" PRIx64, ptr) != 1)
        return -1;
    return 0;
}

static int print_hex64(DeviceState *dev, Property *prop, char *dest, size_t len)
{
    uint64_t *ptr = qdev_get_prop_ptr(dev, prop);
    return snprintf(dest, len, "0x%" PRIx64, *ptr);
}

PropertyInfo qdev_prop_hex64 = {
    .name  = "hex64",
    .type  = PROP_TYPE_UINT64,
    .size  = sizeof(uint64_t),
    .parse = parse_hex64,
    .print = print_hex64,
};

/* --- string --- */

static int parse_string(DeviceState *dev, Property *prop, const char *str)
{
    char **ptr = qdev_get_prop_ptr(dev, prop);

    if (*ptr)
        qemu_free(*ptr);
    *ptr = qemu_strdup(str);
    return 0;
}

static int print_string(DeviceState *dev, Property *prop, char *dest, size_t len)
{
    char **ptr = qdev_get_prop_ptr(dev, prop);
    if (!*ptr)
        return snprintf(dest, len, "<null>");
    return snprintf(dest, len, "\"%s\"", *ptr);
}

PropertyInfo qdev_prop_string = {
    .name  = "string",
    .type  = PROP_TYPE_STRING,
    .size  = sizeof(char*),
    .parse = parse_string,
    .print = print_string,
};

/* --- drive --- */

static int parse_drive(DeviceState *dev, Property *prop, const char *str)
{
    DriveInfo **ptr = qdev_get_prop_ptr(dev, prop);

    *ptr = drive_get_by_id(str);
    if (*ptr == NULL)
        return -1;
    return 0;
}

static int print_drive(DeviceState *dev, Property *prop, char *dest, size_t len)
{
    DriveInfo **ptr = qdev_get_prop_ptr(dev, prop);
    return snprintf(dest, len, "%s", (*ptr) ? (*ptr)->id : "<null>");
}

PropertyInfo qdev_prop_drive = {
    .name  = "drive",
    .type  = PROP_TYPE_DRIVE,
    .size  = sizeof(DriveInfo*),
    .parse = parse_drive,
    .print = print_drive,
};

/* --- character device --- */

static int parse_chr(DeviceState *dev, Property *prop, const char *str)
{
    CharDriverState **ptr = qdev_get_prop_ptr(dev, prop);

    *ptr = qemu_chr_find(str);
    if (*ptr == NULL)
        return -1;
    return 0;
}

static int print_chr(DeviceState *dev, Property *prop, char *dest, size_t len)
{
    CharDriverState **ptr = qdev_get_prop_ptr(dev, prop);

    if (*ptr && (*ptr)->label) {
        return snprintf(dest, len, "%s", (*ptr)->label);
    } else {
        return snprintf(dest, len, "<null>");
    }
}

PropertyInfo qdev_prop_chr = {
    .name  = "chr",
    .type  = PROP_TYPE_CHR,
    .size  = sizeof(CharDriverState*),
    .parse = parse_chr,
    .print = print_chr,
};

/* --- netdev device --- */

static int parse_netdev(DeviceState *dev, Property *prop, const char *str)
{
    VLANClientState **ptr = qdev_get_prop_ptr(dev, prop);

    *ptr = qemu_find_netdev(str);
    if (*ptr == NULL)
        return -1;
    return 0;
}

static int print_netdev(DeviceState *dev, Property *prop, char *dest, size_t len)
{
    VLANClientState **ptr = qdev_get_prop_ptr(dev, prop);

    if (*ptr && (*ptr)->name) {
        return snprintf(dest, len, "%s", (*ptr)->name);
    } else {
        return snprintf(dest, len, "<null>");
    }
}

PropertyInfo qdev_prop_netdev = {
    .name  = "netdev",
    .type  = PROP_TYPE_NETDEV,
    .size  = sizeof(VLANClientState*),
    .parse = parse_netdev,
    .print = print_netdev,
};

/* --- vlan --- */

static int parse_vlan(DeviceState *dev, Property *prop, const char *str)
{
    VLANState **ptr = qdev_get_prop_ptr(dev, prop);
    int id;

    if (sscanf(str, "%d", &id) != 1)
        return -1;
    *ptr = qemu_find_vlan(id, 1);
    if (*ptr == NULL)
        return -1;
    return 0;
}

static int print_vlan(DeviceState *dev, Property *prop, char *dest, size_t len)
{
    VLANState **ptr = qdev_get_prop_ptr(dev, prop);

    if (*ptr) {
        return snprintf(dest, len, "%d", (*ptr)->id);
    } else {
        return snprintf(dest, len, "<null>");
    }
}

PropertyInfo qdev_prop_vlan = {
    .name  = "vlan",
    .type  = PROP_TYPE_VLAN,
    .size  = sizeof(VLANClientState*),
    .parse = parse_vlan,
    .print = print_vlan,
};

/* --- pointer --- */

static int print_ptr(DeviceState *dev, Property *prop, char *dest, size_t len)
{
    void **ptr = qdev_get_prop_ptr(dev, prop);
    return snprintf(dest, len, "<%p>", *ptr);
}

PropertyInfo qdev_prop_ptr = {
    .name  = "ptr",
    .type  = PROP_TYPE_PTR,
    .size  = sizeof(void*),
    .print = print_ptr,
};

/* --- mac address --- */

/*
 * accepted syntax versions:
 *   01:02:03:04:05:06
 *   01-02-03-04-05-06
 */
static int parse_mac(DeviceState *dev, Property *prop, const char *str)
{
    MACAddr *mac = qdev_get_prop_ptr(dev, prop);
    int i, pos;
    char *p;

    for (i = 0, pos = 0; i < 6; i++, pos += 3) {
        if (!qemu_isxdigit(str[pos]))
            return -1;
        if (!qemu_isxdigit(str[pos+1]))
            return -1;
        if (i == 5) {
            if (str[pos+2] != '\0')
                return -1;
        } else {
            if (str[pos+2] != ':' && str[pos+2] != '-')
                return -1;
        }
        mac->a[i] = strtol(str+pos, &p, 16);
    }
    return 0;
}

static int print_mac(DeviceState *dev, Property *prop, char *dest, size_t len)
{
    MACAddr *mac = qdev_get_prop_ptr(dev, prop);

    return snprintf(dest, len, "%02x:%02x:%02x:%02x:%02x:%02x",
                    mac->a[0], mac->a[1], mac->a[2],
                    mac->a[3], mac->a[4], mac->a[5]);
}

PropertyInfo qdev_prop_macaddr = {
    .name  = "macaddr",
    .type  = PROP_TYPE_MACADDR,
    .size  = sizeof(MACAddr),
    .parse = parse_mac,
    .print = print_mac,
};

/* --- pci address --- */

/*
 * bus-local address, i.e. "$slot" or "$slot.$fn"
 */
static int parse_pci_devfn(DeviceState *dev, Property *prop, const char *str)
{
    uint32_t *ptr = qdev_get_prop_ptr(dev, prop);
    unsigned int slot, fn, n;

    if (sscanf(str, "%x.%x%n", &slot, &fn, &n) != 2) {
        fn = 0;
        if (sscanf(str, "%x%n", &slot, &n) != 1) {
            return -1;
        }
    }
    if (str[n] != '\0')
        return -1;
    if (fn > 7)
        return -1;
    *ptr = slot << 3 | fn;
    return 0;
}

static int print_pci_devfn(DeviceState *dev, Property *prop, char *dest, size_t len)
{
    uint32_t *ptr = qdev_get_prop_ptr(dev, prop);

    if (*ptr == -1) {
        return snprintf(dest, len, "<unset>");
    } else {
        return snprintf(dest, len, "%02x.%x", *ptr >> 3, *ptr & 7);
    }
}

PropertyInfo qdev_prop_pci_devfn = {
    .name  = "pci-devfn",
    .type  = PROP_TYPE_UINT32,
    .size  = sizeof(uint32_t),
    .parse = parse_pci_devfn,
    .print = print_pci_devfn,
};

/* --- public helpers --- */

static Property *qdev_prop_walk(Property *props, const char *name)
{
    if (!props)
        return NULL;
    while (props->name) {
        if (strcmp(props->name, name) == 0)
            return props;
        props++;
    }
    return NULL;
}

static Property *qdev_prop_find(DeviceState *dev, const char *name)
{
    Property *prop;

    /* device properties */
    prop = qdev_prop_walk(dev->info->props, name);
    if (prop)
        return prop;

    /* bus properties */
    prop = qdev_prop_walk(dev->parent_bus->info->props, name);
    if (prop)
        return prop;

    return NULL;
}

int qdev_prop_exists(DeviceState *dev, const char *name)
{
    return qdev_prop_find(dev, name) ? true : false;
}

int qdev_prop_parse(DeviceState *dev, const char *name, const char *value)
{
    Property *prop;

    prop = qdev_prop_find(dev, name);
    if (!prop) {
        fprintf(stderr, "property \"%s.%s\" not found\n",
                dev->info->name, name);
        return -1;
    }
    if (!prop->info->parse) {
        fprintf(stderr, "property \"%s.%s\" has no parser\n",
                dev->info->name, name);
        return -1;
    }
    if (prop->info->parse(dev, prop, value) != 0) {
        fprintf(stderr, "property \"%s.%s\": failed to parse \"%s\"\n",
                dev->info->name, name, value);
        return -1;
    }
    return 0;
}

void qdev_prop_set(DeviceState *dev, const char *name, void *src, enum PropertyType type)
{
    Property *prop;
    void *dst;

    prop = qdev_prop_find(dev, name);
    if (!prop) {
        fprintf(stderr, "%s: property \"%s.%s\" not found\n",
                __FUNCTION__, dev->info->name, name);
        abort();
    }
    if (prop->info->type != type) {
        fprintf(stderr, "%s: property \"%s.%s\" type mismatch\n",
                __FUNCTION__, dev->info->name, name);
        abort();
    }
    dst = qdev_get_prop_ptr(dev, prop);
    memcpy(dst, src, prop->info->size);
}

void qdev_prop_set_uint8(DeviceState *dev, const char *name, uint8_t value)
{
    qdev_prop_set(dev, name, &value, PROP_TYPE_UINT8);
}

void qdev_prop_set_uint16(DeviceState *dev, const char *name, uint16_t value)
{
    qdev_prop_set(dev, name, &value, PROP_TYPE_UINT16);
}

void qdev_prop_set_uint32(DeviceState *dev, const char *name, uint32_t value)
{
    qdev_prop_set(dev, name, &value, PROP_TYPE_UINT32);
}

void qdev_prop_set_int32(DeviceState *dev, const char *name, int32_t value)
{
    qdev_prop_set(dev, name, &value, PROP_TYPE_INT32);
}

void qdev_prop_set_uint64(DeviceState *dev, const char *name, uint64_t value)
{
    qdev_prop_set(dev, name, &value, PROP_TYPE_UINT64);
}

void qdev_prop_set_drive(DeviceState *dev, const char *name, DriveInfo *value)
{
    qdev_prop_set(dev, name, &value, PROP_TYPE_DRIVE);
}

void qdev_prop_set_chr(DeviceState *dev, const char *name, CharDriverState *value)
{
    qdev_prop_set(dev, name, &value, PROP_TYPE_CHR);
}

void qdev_prop_set_netdev(DeviceState *dev, const char *name, VLANClientState *value)
{
    qdev_prop_set(dev, name, &value, PROP_TYPE_NETDEV);
}

void qdev_prop_set_vlan(DeviceState *dev, const char *name, VLANState *value)
{
    qdev_prop_set(dev, name, &value, PROP_TYPE_VLAN);
}

void qdev_prop_set_macaddr(DeviceState *dev, const char *name, uint8_t *value)
{
    qdev_prop_set(dev, name, value, PROP_TYPE_MACADDR);
}

void qdev_prop_set_ptr(DeviceState *dev, const char *name, void *value)
{
    qdev_prop_set(dev, name, &value, PROP_TYPE_PTR);
}

void qdev_prop_set_defaults(DeviceState *dev, Property *props)
{
    char *dst;

    if (!props)
        return;
    while (props->name) {
        if (props->defval) {
            dst = qdev_get_prop_ptr(dev, props);
            memcpy(dst, props->defval, props->info->size);
        }
        props++;
    }
}

static QTAILQ_HEAD(, GlobalProperty) global_props = QTAILQ_HEAD_INITIALIZER(global_props);

void qdev_prop_register_global(GlobalProperty *prop)
{
    QTAILQ_INSERT_TAIL(&global_props, prop, next);
}

void qdev_prop_register_global_list(GlobalProperty *props)
{
    int i;

    for (i = 0; props[i].driver != NULL; i++) {
        qdev_prop_register_global(props+i);
    }
}

void qdev_prop_set_globals(DeviceState *dev)
{
    GlobalProperty *prop;

    QTAILQ_FOREACH(prop, &global_props, next) {
        if (strcmp(dev->info->name, prop->driver) != 0 &&
            strcmp(dev->info->bus_info->name, prop->driver) != 0) {
            continue;
        }
        if (qdev_prop_parse(dev, prop->property, prop->value) != 0) {
            exit(1);
        }
    }
}
Commit	Line	Data
14b41872	1	#include "sysemu.h"
1503fff3	2	#include "net.h"
ee6847d1 GH	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
c7cc172d JQ	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
ee6847d1 GH	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
316940b0 GH	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
ee6847d1 GH	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
5a053d1f BS	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
59419663 GH	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
14b41872 GH	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);
41b5e892	240	return snprintf(dest, len, "%s", (ptr) ? (ptr)->id : "<null>");
14b41872 GH	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
313feaab GH	251	/* --- character device --- */
313feaab GH	252
06113719 GH	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
313feaab GH	263	static int print_chr(DeviceState dev, Property prop, char *dest, size_t len)
	264	{
	265	CharDriverState **ptr = qdev_get_prop_ptr(dev, prop);
bc19fcaa BS	266
	267	if (ptr && (ptr)->label) {
	268	return snprintf(dest, len, "%s", (*ptr)->label);
	269	} else {
	270	return snprintf(dest, len, "<null>");
	271	}
313feaab GH	272	}
	273
	274	PropertyInfo qdev_prop_chr = {
	275	.name = "chr",
	276	.type = PROP_TYPE_CHR,
	277	.size = sizeof(CharDriverState*),
06113719	278	.parse = parse_chr,
313feaab GH	279	.print = print_chr,
	280	};
	281
2ef924b4 GH	282	/* --- netdev device --- */
	283
	284	static int parse_netdev(DeviceState dev, Property prop, const char *str)
	285	{
	286	VLANClientState **ptr = qdev_get_prop_ptr(dev, prop);
	287
	288	*ptr = qemu_find_netdev(str);
	289	if (*ptr == NULL)
	290	return -1;
	291	return 0;
	292	}
	293
	294	static int print_netdev(DeviceState dev, Property prop, char *dest, size_t len)
	295	{
	296	VLANClientState **ptr = qdev_get_prop_ptr(dev, prop);
	297
	298	if (ptr && (ptr)->name) {
	299	return snprintf(dest, len, "%s", (*ptr)->name);
	300	} else {
	301	return snprintf(dest, len, "<null>");
	302	}
	303	}
	304
	305	PropertyInfo qdev_prop_netdev = {
	306	.name = "netdev",
	307	.type = PROP_TYPE_NETDEV,
	308	.size = sizeof(VLANClientState*),
	309	.parse = parse_netdev,
	310	.print = print_netdev,
	311	};
	312
851bec09 GH	313	/* --- vlan --- */
	314
	315	static int parse_vlan(DeviceState dev, Property prop, const char *str)
	316	{
	317	VLANState **ptr = qdev_get_prop_ptr(dev, prop);
	318	int id;
	319
	320	if (sscanf(str, "%d", &id) != 1)
	321	return -1;
	322	*ptr = qemu_find_vlan(id, 1);
	323	if (*ptr == NULL)
	324	return -1;
	325	return 0;
	326	}
	327
	328	static int print_vlan(DeviceState dev, Property prop, char *dest, size_t len)
	329	{
	330	VLANState **ptr = qdev_get_prop_ptr(dev, prop);
	331
	332	if (*ptr) {
	333	return snprintf(dest, len, "%d", (*ptr)->id);
	334	} else {
	335	return snprintf(dest, len, "<null>");
	336	}
	337	}
	338
	339	PropertyInfo qdev_prop_vlan = {
	340	.name = "vlan",
	341	.type = PROP_TYPE_VLAN,
	342	.size = sizeof(VLANClientState*),
	343	.parse = parse_vlan,
	344	.print = print_vlan,
	345	};
	346
ee6847d1 GH	347	/* --- pointer --- */
	348
	349	static int print_ptr(DeviceState dev, Property prop, char *dest, size_t len)
	350	{
	351	void **ptr = qdev_get_prop_ptr(dev, prop);
	352	return snprintf(dest, len, "<%p>", *ptr);
	353	}
	354
	355	PropertyInfo qdev_prop_ptr = {
	356	.name = "ptr",
	357	.type = PROP_TYPE_PTR,
	358	.size = sizeof(void*),
	359	.print = print_ptr,
	360	};
	361
	362	/* --- mac address --- */
	363
	364	/*
	365	* accepted syntax versions:
	366	* 01:02:03:04:05:06
	367	* 01-02-03-04-05-06
	368	*/
	369	static int parse_mac(DeviceState dev, Property prop, const char *str)
	370	{
1503fff3	371	MACAddr *mac = qdev_get_prop_ptr(dev, prop);
ee6847d1 GH	372	int i, pos;
	373	char *p;
	374
	375	for (i = 0, pos = 0; i < 6; i++, pos += 3) {
88e150a5	376	if (!qemu_isxdigit(str[pos]))
ee6847d1	377	return -1;
88e150a5	378	if (!qemu_isxdigit(str[pos+1]))
ee6847d1	379	return -1;
1503fff3 GH	380	if (i == 5) {
	381	if (str[pos+2] != '\0')
	382	return -1;
	383	} else {
	384	if (str[pos+2] != ':' && str[pos+2] != '-')
	385	return -1;
	386	}
	387	mac->a[i] = strtol(str+pos, &p, 16);
ee6847d1 GH	388	}
	389	return 0;
	390	}
	391
	392	static int print_mac(DeviceState dev, Property prop, char *dest, size_t len)
	393	{
1503fff3 GH	394	MACAddr *mac = qdev_get_prop_ptr(dev, prop);
1503fff3 GH	395
ee6847d1	396	return snprintf(dest, len, "%02x:%02x:%02x:%02x:%02x:%02x",
1503fff3 GH	397	mac->a[0], mac->a[1], mac->a[2],
1503fff3 GH	398	mac->a[3], mac->a[4], mac->a[5]);
ee6847d1 GH	399	}
	400
	401	PropertyInfo qdev_prop_macaddr = {
1503fff3	402	.name = "macaddr",
ee6847d1	403	.type = PROP_TYPE_MACADDR,
1503fff3	404	.size = sizeof(MACAddr),
ee6847d1 GH	405	.parse = parse_mac,
	406	.print = print_mac,
	407	};
	408
05cb5fe4 GH	409	/* --- pci address --- */
	410
	411	/*
	412	* bus-local address, i.e. "$slot" or "$slot.$fn"
	413	*/
	414	static int parse_pci_devfn(DeviceState dev, Property prop, const char *str)
	415	{
	416	uint32_t *ptr = qdev_get_prop_ptr(dev, prop);
	417	unsigned int slot, fn, n;
	418
	419	if (sscanf(str, "%x.%x%n", &slot, &fn, &n) != 2) {
	420	fn = 0;
	421	if (sscanf(str, "%x%n", &slot, &n) != 1) {
	422	return -1;
	423	}
	424	}
	425	if (str[n] != '\0')
	426	return -1;
	427	if (fn > 7)
	428	return -1;
	429	*ptr = slot << 3 \| fn;
	430	return 0;
	431	}
	432
	433	static int print_pci_devfn(DeviceState dev, Property prop, char *dest, size_t len)
	434	{
	435	uint32_t *ptr = qdev_get_prop_ptr(dev, prop);
	436
73538c31	437	if (*ptr == -1) {
05cb5fe4 GH	438	return snprintf(dest, len, "<unset>");
	439	} else {
	440	return snprintf(dest, len, "%02x.%x", ptr >> 3, ptr & 7);
	441	}
	442	}
	443
	444	PropertyInfo qdev_prop_pci_devfn = {
	445	.name = "pci-devfn",
	446	.type = PROP_TYPE_UINT32,
	447	.size = sizeof(uint32_t),
	448	.parse = parse_pci_devfn,
	449	.print = print_pci_devfn,
	450	};
	451
ee6847d1 GH	452	/* --- public helpers --- */
	453
	454	static Property qdev_prop_walk(Property props, const char *name)
	455	{
	456	if (!props)
	457	return NULL;
	458	while (props->name) {
	459	if (strcmp(props->name, name) == 0)
	460	return props;
	461	props++;
	462	}
	463	return NULL;
	464	}
	465
	466	static Property qdev_prop_find(DeviceState dev, const char *name)
	467	{
	468	Property *prop;
	469
	470	/* device properties */
	471	prop = qdev_prop_walk(dev->info->props, name);
	472	if (prop)
	473	return prop;
	474
	475	/* bus properties */
	476	prop = qdev_prop_walk(dev->parent_bus->info->props, name);
	477	if (prop)
	478	return prop;
	479
	480	return NULL;
	481	}
	482
d8ed79ae GH	483	int qdev_prop_exists(DeviceState dev, const char name)
	484	{
	485	return qdev_prop_find(dev, name) ? true : false;
	486	}
	487
ee6847d1 GH	488	int qdev_prop_parse(DeviceState dev, const char name, const char *value)
	489	{
	490	Property *prop;
	491
	492	prop = qdev_prop_find(dev, name);
	493	if (!prop) {
	494	fprintf(stderr, "property \"%s.%s\" not found\n",
	495	dev->info->name, name);
	496	return -1;
	497	}
	498	if (!prop->info->parse) {
	499	fprintf(stderr, "property \"%s.%s\" has no parser\n",
	500	dev->info->name, name);
	501	return -1;
	502	}
9ef5c4bf GH	503	if (prop->info->parse(dev, prop, value) != 0) {
	504	fprintf(stderr, "property \"%s.%s\": failed to parse \"%s\"\n",
	505	dev->info->name, name, value);
	506	return -1;
	507	}
	508	return 0;
ee6847d1 GH	509	}
	510
	511	void qdev_prop_set(DeviceState dev, const char name, void *src, enum PropertyType type)
	512	{
	513	Property *prop;
	514	void *dst;
	515
	516	prop = qdev_prop_find(dev, name);
	517	if (!prop) {
	518	fprintf(stderr, "%s: property \"%s.%s\" not found\n",
	519	__FUNCTION__, dev->info->name, name);
	520	abort();
	521	}
	522	if (prop->info->type != type) {
	523	fprintf(stderr, "%s: property \"%s.%s\" type mismatch\n",
	524	__FUNCTION__, dev->info->name, name);
	525	abort();
	526	}
	527	dst = qdev_get_prop_ptr(dev, prop);
	528	memcpy(dst, src, prop->info->size);
	529	}
	530
c7cc172d JQ	531	void qdev_prop_set_uint8(DeviceState dev, const char name, uint8_t value)
	532	{
	533	qdev_prop_set(dev, name, &value, PROP_TYPE_UINT8);
	534	}
	535
ee6847d1 GH	536	void qdev_prop_set_uint16(DeviceState dev, const char name, uint16_t value)
	537	{
	538	qdev_prop_set(dev, name, &value, PROP_TYPE_UINT16);
	539	}
	540
	541	void qdev_prop_set_uint32(DeviceState dev, const char name, uint32_t value)
	542	{
	543	qdev_prop_set(dev, name, &value, PROP_TYPE_UINT32);
	544	}
	545
316940b0 GH	546	void qdev_prop_set_int32(DeviceState dev, const char name, int32_t value)
	547	{
	548	qdev_prop_set(dev, name, &value, PROP_TYPE_INT32);
	549	}
	550
5a053d1f BS	551	void qdev_prop_set_uint64(DeviceState dev, const char name, uint64_t value)
	552	{
	553	qdev_prop_set(dev, name, &value, PROP_TYPE_UINT64);
	554	}
	555
14b41872 GH	556	void qdev_prop_set_drive(DeviceState dev, const char name, DriveInfo *value)
	557	{
	558	qdev_prop_set(dev, name, &value, PROP_TYPE_DRIVE);
	559	}
	560
313feaab GH	561	void qdev_prop_set_chr(DeviceState dev, const char name, CharDriverState *value)
	562	{
	563	qdev_prop_set(dev, name, &value, PROP_TYPE_CHR);
	564	}
	565
2ef924b4 GH	566	void qdev_prop_set_netdev(DeviceState dev, const char name, VLANClientState *value)
	567	{
	568	qdev_prop_set(dev, name, &value, PROP_TYPE_NETDEV);
	569	}
	570
851bec09 GH	571	void qdev_prop_set_vlan(DeviceState dev, const char name, VLANState *value)
	572	{
	573	qdev_prop_set(dev, name, &value, PROP_TYPE_VLAN);
	574	}
	575
1503fff3 GH	576	void qdev_prop_set_macaddr(DeviceState dev, const char name, uint8_t *value)
	577	{
	578	qdev_prop_set(dev, name, value, PROP_TYPE_MACADDR);
	579	}
	580
ee6847d1 GH	581	void qdev_prop_set_ptr(DeviceState dev, const char name, void *value)
	582	{
	583	qdev_prop_set(dev, name, &value, PROP_TYPE_PTR);
	584	}
	585
	586	void qdev_prop_set_defaults(DeviceState dev, Property props)
	587	{
	588	char *dst;
	589
	590	if (!props)
	591	return;
	592	while (props->name) {
	593	if (props->defval) {
	594	dst = qdev_get_prop_ptr(dev, props);
	595	memcpy(dst, props->defval, props->info->size);
	596	}
	597	props++;
	598	}
	599	}
	600
458fb679	601	static QTAILQ_HEAD(, GlobalProperty) global_props = QTAILQ_HEAD_INITIALIZER(global_props);
b6b61144	602
458fb679	603	void qdev_prop_register_global(GlobalProperty *prop)
b6b61144	604	{
458fb679	605	QTAILQ_INSERT_TAIL(&global_props, prop, next);
b6b61144 GH	606	}
b6b61144 GH	607
458fb679	608	void qdev_prop_register_global_list(GlobalProperty *props)
b6b61144	609	{
458fb679	610	int i;
b6b61144	611
458fb679 GH	612	for (i = 0; props[i].driver != NULL; i++) {
458fb679 GH	613	qdev_prop_register_global(props+i);
b6b61144	614	}
458fb679 GH	615	}
	616
	617	void qdev_prop_set_globals(DeviceState *dev)
	618	{
	619	GlobalProperty *prop;
	620
	621	QTAILQ_FOREACH(prop, &global_props, next) {
07a8de35 GH	622	if (strcmp(dev->info->name, prop->driver) != 0 &&
07a8de35 GH	623	strcmp(dev->info->bus_info->name, prop->driver) != 0) {
b6b61144 GH	624	continue;
	625	}
	626	if (qdev_prop_parse(dev, prop->property, prop->value) != 0) {
9ef5c4bf	627	exit(1);
b6b61144 GH	628	}
	629	}
	630	}