]>
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 --- */ |
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 | ||
ee6847d1 GH |
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 | { | |
1503fff3 | 306 | MACAddr *mac = qdev_get_prop_ptr(dev, prop); |
ee6847d1 GH |
307 | int i, pos; |
308 | char *p; | |
309 | ||
310 | for (i = 0, pos = 0; i < 6; i++, pos += 3) { | |
88e150a5 | 311 | if (!qemu_isxdigit(str[pos])) |
ee6847d1 | 312 | return -1; |
88e150a5 | 313 | if (!qemu_isxdigit(str[pos+1])) |
ee6847d1 | 314 | return -1; |
1503fff3 GH |
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); | |
ee6847d1 GH |
323 | } |
324 | return 0; | |
325 | } | |
326 | ||
327 | static int print_mac(DeviceState *dev, Property *prop, char *dest, size_t len) | |
328 | { | |
1503fff3 GH |
329 | MACAddr *mac = qdev_get_prop_ptr(dev, prop); |
330 | ||
ee6847d1 | 331 | return snprintf(dest, len, "%02x:%02x:%02x:%02x:%02x:%02x", |
1503fff3 GH |
332 | mac->a[0], mac->a[1], mac->a[2], |
333 | mac->a[3], mac->a[4], mac->a[5]); | |
ee6847d1 GH |
334 | } |
335 | ||
336 | PropertyInfo qdev_prop_macaddr = { | |
1503fff3 | 337 | .name = "macaddr", |
ee6847d1 | 338 | .type = PROP_TYPE_MACADDR, |
1503fff3 | 339 | .size = sizeof(MACAddr), |
ee6847d1 GH |
340 | .parse = parse_mac, |
341 | .print = print_mac, | |
342 | }; | |
343 | ||
05cb5fe4 GH |
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 | ||
73538c31 | 372 | if (*ptr == -1) { |
05cb5fe4 GH |
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 | ||
ee6847d1 GH |
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 | ||
c7cc172d JQ |
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 | ||
ee6847d1 GH |
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 | ||
316940b0 GH |
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 | ||
5a053d1f BS |
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 | ||
14b41872 GH |
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 | ||
313feaab GH |
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 | ||
1503fff3 GH |
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 | ||
ee6847d1 GH |
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 | ||
b6b61144 GH |
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 | } |