]>
Commit | Line | Data |
---|---|---|
14b41872 | 1 | #include "sysemu.h" |
ee6847d1 GH |
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 | ||
c7cc172d JQ |
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 | ||
ee6847d1 GH |
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 | ||
316940b0 GH |
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 | ||
ee6847d1 GH |
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 | ||
5a053d1f BS |
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 | ||
14b41872 GH |
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); | |
41b5e892 | 211 | return snprintf(dest, len, "%s", (*ptr) ? (*ptr)->id : "<null>"); |
14b41872 GH |
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 | ||
313feaab GH |
222 | /* --- character device --- */ |
223 | ||
06113719 GH |
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 | ||
313feaab GH |
234 | static int print_chr(DeviceState *dev, Property *prop, char *dest, size_t len) |
235 | { | |
236 | CharDriverState **ptr = qdev_get_prop_ptr(dev, prop); | |
bc19fcaa BS |
237 | |
238 | if (*ptr && (*ptr)->label) { | |
239 | return snprintf(dest, len, "%s", (*ptr)->label); | |
240 | } else { | |
241 | return snprintf(dest, len, "<null>"); | |
242 | } | |
313feaab GH |
243 | } |
244 | ||
245 | PropertyInfo qdev_prop_chr = { | |
246 | .name = "chr", | |
247 | .type = PROP_TYPE_CHR, | |
248 | .size = sizeof(CharDriverState*), | |
06113719 | 249 | .parse = parse_chr, |
313feaab GH |
250 | .print = print_chr, |
251 | }; | |
252 | ||
ee6847d1 GH |
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) { | |
88e150a5 | 282 | if (!qemu_isxdigit(str[pos])) |
ee6847d1 | 283 | return -1; |
88e150a5 | 284 | if (!qemu_isxdigit(str[pos+1])) |
ee6847d1 GH |
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 | ||
05cb5fe4 GH |
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 | ||
73538c31 | 338 | if (*ptr == -1) { |
05cb5fe4 GH |
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 | ||
ee6847d1 GH |
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 | ||
c7cc172d JQ |
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 | ||
ee6847d1 GH |
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 | ||
316940b0 GH |
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 | ||
5a053d1f BS |
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 | ||
14b41872 GH |
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 | ||
313feaab GH |
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 | ||
ee6847d1 GH |
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 | ||
b6b61144 GH |
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 | } |