]>
Commit | Line | Data |
---|---|---|
1 | #ifndef QDEV_CORE_H | |
2 | #define QDEV_CORE_H | |
3 | ||
4 | #include "qemu/queue.h" | |
5 | #include "qemu/bitmap.h" | |
6 | #include "qom/object.h" | |
7 | #include "hw/irq.h" | |
8 | #include "hw/hotplug.h" | |
9 | #include "sysemu/sysemu.h" | |
10 | ||
11 | enum { | |
12 | DEV_NVECTORS_UNSPECIFIED = -1, | |
13 | }; | |
14 | ||
15 | #define TYPE_DEVICE "device" | |
16 | #define DEVICE(obj) OBJECT_CHECK(DeviceState, (obj), TYPE_DEVICE) | |
17 | #define DEVICE_CLASS(klass) OBJECT_CLASS_CHECK(DeviceClass, (klass), TYPE_DEVICE) | |
18 | #define DEVICE_GET_CLASS(obj) OBJECT_GET_CLASS(DeviceClass, (obj), TYPE_DEVICE) | |
19 | ||
20 | typedef enum DeviceCategory { | |
21 | DEVICE_CATEGORY_BRIDGE, | |
22 | DEVICE_CATEGORY_USB, | |
23 | DEVICE_CATEGORY_STORAGE, | |
24 | DEVICE_CATEGORY_NETWORK, | |
25 | DEVICE_CATEGORY_INPUT, | |
26 | DEVICE_CATEGORY_DISPLAY, | |
27 | DEVICE_CATEGORY_SOUND, | |
28 | DEVICE_CATEGORY_MISC, | |
29 | DEVICE_CATEGORY_CPU, | |
30 | DEVICE_CATEGORY_MAX | |
31 | } DeviceCategory; | |
32 | ||
33 | typedef void (*DeviceRealize)(DeviceState *dev, Error **errp); | |
34 | typedef void (*DeviceUnrealize)(DeviceState *dev, Error **errp); | |
35 | typedef void (*DeviceReset)(DeviceState *dev); | |
36 | typedef void (*BusRealize)(BusState *bus, Error **errp); | |
37 | typedef void (*BusUnrealize)(BusState *bus, Error **errp); | |
38 | ||
39 | struct VMStateDescription; | |
40 | ||
41 | /** | |
42 | * DeviceClass: | |
43 | * @props: Properties accessing state fields. | |
44 | * @realize: Callback function invoked when the #DeviceState:realized | |
45 | * property is changed to %true. | |
46 | * @unrealize: Callback function invoked when the #DeviceState:realized | |
47 | * property is changed to %false. | |
48 | * @hotpluggable: indicates if #DeviceClass is hotpluggable, available | |
49 | * as readonly "hotpluggable" property of #DeviceState instance | |
50 | * | |
51 | * # Realization # | |
52 | * Devices are constructed in two stages, | |
53 | * 1) object instantiation via object_initialize() and | |
54 | * 2) device realization via #DeviceState:realized property. | |
55 | * The former may not fail (and must not abort or exit, since it is called | |
56 | * during device introspection already), and the latter may return error | |
57 | * information to the caller and must be re-entrant. | |
58 | * Trivial field initializations should go into #TypeInfo.instance_init. | |
59 | * Operations depending on @props static properties should go into @realize. | |
60 | * After successful realization, setting static properties will fail. | |
61 | * | |
62 | * As an interim step, the #DeviceState:realized property can also be | |
63 | * set with qdev_init_nofail(). | |
64 | * In the future, devices will propagate this state change to their children | |
65 | * and along busses they expose. | |
66 | * The point in time will be deferred to machine creation, so that values | |
67 | * set in @realize will not be introspectable beforehand. Therefore devices | |
68 | * must not create children during @realize; they should initialize them via | |
69 | * object_initialize() in their own #TypeInfo.instance_init and forward the | |
70 | * realization events appropriately. | |
71 | * | |
72 | * Any type may override the @realize and/or @unrealize callbacks but needs | |
73 | * to call the parent type's implementation if keeping their functionality | |
74 | * is desired. Refer to QOM documentation for further discussion and examples. | |
75 | * | |
76 | * <note> | |
77 | * <para> | |
78 | * Since TYPE_DEVICE doesn't implement @realize and @unrealize, types | |
79 | * derived directly from it need not call their parent's @realize and | |
80 | * @unrealize. | |
81 | * For other types consult the documentation and implementation of the | |
82 | * respective parent types. | |
83 | * </para> | |
84 | * </note> | |
85 | */ | |
86 | typedef struct DeviceClass { | |
87 | /*< private >*/ | |
88 | ObjectClass parent_class; | |
89 | /*< public >*/ | |
90 | ||
91 | DECLARE_BITMAP(categories, DEVICE_CATEGORY_MAX); | |
92 | const char *fw_name; | |
93 | const char *desc; | |
94 | Property *props; | |
95 | ||
96 | /* | |
97 | * Can this device be instantiated with -device / device_add? | |
98 | * All devices should support instantiation with device_add, and | |
99 | * this flag should not exist. But we're not there, yet. Some | |
100 | * devices fail to instantiate with cryptic error messages. | |
101 | * Others instantiate, but don't work. Exposing users to such | |
102 | * behavior would be cruel; clearing this flag will protect them. | |
103 | * It should never be cleared without a comment explaining why it | |
104 | * is cleared. | |
105 | * TODO remove once we're there | |
106 | */ | |
107 | bool user_creatable; | |
108 | bool hotpluggable; | |
109 | ||
110 | /* callbacks */ | |
111 | DeviceReset reset; | |
112 | DeviceRealize realize; | |
113 | DeviceUnrealize unrealize; | |
114 | ||
115 | /* device state */ | |
116 | const struct VMStateDescription *vmsd; | |
117 | ||
118 | /* Private to qdev / bus. */ | |
119 | const char *bus_type; | |
120 | } DeviceClass; | |
121 | ||
122 | typedef struct NamedGPIOList NamedGPIOList; | |
123 | ||
124 | struct NamedGPIOList { | |
125 | char *name; | |
126 | qemu_irq *in; | |
127 | int num_in; | |
128 | int num_out; | |
129 | QLIST_ENTRY(NamedGPIOList) node; | |
130 | }; | |
131 | ||
132 | /** | |
133 | * DeviceState: | |
134 | * @realized: Indicates whether the device has been fully constructed. | |
135 | * | |
136 | * This structure should not be accessed directly. We declare it here | |
137 | * so that it can be embedded in individual device state structures. | |
138 | */ | |
139 | struct DeviceState { | |
140 | /*< private >*/ | |
141 | Object parent_obj; | |
142 | /*< public >*/ | |
143 | ||
144 | const char *id; | |
145 | char *canonical_path; | |
146 | bool realized; | |
147 | bool pending_deleted_event; | |
148 | QemuOpts *opts; | |
149 | int hotplugged; | |
150 | BusState *parent_bus; | |
151 | QLIST_HEAD(, NamedGPIOList) gpios; | |
152 | QLIST_HEAD(, BusState) child_bus; | |
153 | int num_child_bus; | |
154 | int instance_id_alias; | |
155 | int alias_required_for_version; | |
156 | }; | |
157 | ||
158 | struct DeviceListener { | |
159 | void (*realize)(DeviceListener *listener, DeviceState *dev); | |
160 | void (*unrealize)(DeviceListener *listener, DeviceState *dev); | |
161 | QTAILQ_ENTRY(DeviceListener) link; | |
162 | }; | |
163 | ||
164 | #define TYPE_BUS "bus" | |
165 | #define BUS(obj) OBJECT_CHECK(BusState, (obj), TYPE_BUS) | |
166 | #define BUS_CLASS(klass) OBJECT_CLASS_CHECK(BusClass, (klass), TYPE_BUS) | |
167 | #define BUS_GET_CLASS(obj) OBJECT_GET_CLASS(BusClass, (obj), TYPE_BUS) | |
168 | ||
169 | struct BusClass { | |
170 | ObjectClass parent_class; | |
171 | ||
172 | /* FIXME first arg should be BusState */ | |
173 | void (*print_dev)(Monitor *mon, DeviceState *dev, int indent); | |
174 | char *(*get_dev_path)(DeviceState *dev); | |
175 | /* | |
176 | * This callback is used to create Open Firmware device path in accordance | |
177 | * with OF spec http://forthworks.com/standards/of1275.pdf. Individual bus | |
178 | * bindings can be found at http://playground.sun.com/1275/bindings/. | |
179 | */ | |
180 | char *(*get_fw_dev_path)(DeviceState *dev); | |
181 | void (*reset)(BusState *bus); | |
182 | BusRealize realize; | |
183 | BusUnrealize unrealize; | |
184 | ||
185 | /* maximum devices allowed on the bus, 0: no limit. */ | |
186 | int max_dev; | |
187 | /* number of automatically allocated bus ids (e.g. ide.0) */ | |
188 | int automatic_ids; | |
189 | }; | |
190 | ||
191 | typedef struct BusChild { | |
192 | DeviceState *child; | |
193 | int index; | |
194 | QTAILQ_ENTRY(BusChild) sibling; | |
195 | } BusChild; | |
196 | ||
197 | #define QDEV_HOTPLUG_HANDLER_PROPERTY "hotplug-handler" | |
198 | ||
199 | /** | |
200 | * BusState: | |
201 | * @hotplug_handler: link to a hotplug handler associated with bus. | |
202 | */ | |
203 | struct BusState { | |
204 | Object obj; | |
205 | DeviceState *parent; | |
206 | char *name; | |
207 | HotplugHandler *hotplug_handler; | |
208 | int max_index; | |
209 | bool realized; | |
210 | int num_children; | |
211 | QTAILQ_HEAD(, BusChild) children; | |
212 | QLIST_ENTRY(BusState) sibling; | |
213 | }; | |
214 | ||
215 | /** | |
216 | * Property: | |
217 | * @set_default: true if the default value should be set from @defval, | |
218 | * in which case @info->set_default_value must not be NULL | |
219 | * (if false then no default value is set by the property system | |
220 | * and the field retains whatever value it was given by instance_init). | |
221 | * @defval: default value for the property. This is used only if @set_default | |
222 | * is true. | |
223 | */ | |
224 | struct Property { | |
225 | const char *name; | |
226 | const PropertyInfo *info; | |
227 | ptrdiff_t offset; | |
228 | uint8_t bitnr; | |
229 | bool set_default; | |
230 | union { | |
231 | int64_t i; | |
232 | uint64_t u; | |
233 | } defval; | |
234 | int arrayoffset; | |
235 | const PropertyInfo *arrayinfo; | |
236 | int arrayfieldsize; | |
237 | const char *link_type; | |
238 | }; | |
239 | ||
240 | struct PropertyInfo { | |
241 | const char *name; | |
242 | const char *description; | |
243 | const QEnumLookup *enum_table; | |
244 | int (*print)(DeviceState *dev, Property *prop, char *dest, size_t len); | |
245 | void (*set_default_value)(Object *obj, const Property *prop); | |
246 | void (*create)(Object *obj, Property *prop, Error **errp); | |
247 | ObjectPropertyAccessor *get; | |
248 | ObjectPropertyAccessor *set; | |
249 | ObjectPropertyRelease *release; | |
250 | }; | |
251 | ||
252 | /** | |
253 | * GlobalProperty: | |
254 | * @used: Set to true if property was used when initializing a device. | |
255 | * | |
256 | * An error is fatal for non-hotplugged devices, when the global is applied. | |
257 | */ | |
258 | typedef struct GlobalProperty { | |
259 | const char *driver; | |
260 | const char *property; | |
261 | const char *value; | |
262 | bool used; | |
263 | } GlobalProperty; | |
264 | ||
265 | static inline void | |
266 | compat_props_add(GPtrArray *arr, | |
267 | GlobalProperty props[], size_t nelem) | |
268 | { | |
269 | int i; | |
270 | for (i = 0; i < nelem; i++) { | |
271 | g_ptr_array_add(arr, (void *)&props[i]); | |
272 | } | |
273 | } | |
274 | ||
275 | /*** Board API. This should go away once we have a machine config file. ***/ | |
276 | ||
277 | DeviceState *qdev_create(BusState *bus, const char *name); | |
278 | DeviceState *qdev_try_create(BusState *bus, const char *name); | |
279 | void qdev_init_nofail(DeviceState *dev); | |
280 | void qdev_set_legacy_instance_id(DeviceState *dev, int alias_id, | |
281 | int required_for_version); | |
282 | HotplugHandler *qdev_get_bus_hotplug_handler(DeviceState *dev); | |
283 | HotplugHandler *qdev_get_machine_hotplug_handler(DeviceState *dev); | |
284 | /** | |
285 | * qdev_get_hotplug_handler: Get handler responsible for device wiring | |
286 | * | |
287 | * Find HOTPLUG_HANDLER for @dev that provides [pre|un]plug callbacks for it. | |
288 | * | |
289 | * Note: in case @dev has a parent bus, it will be returned as handler unless | |
290 | * machine handler overrides it. | |
291 | * | |
292 | * Returns: pointer to object that implements TYPE_HOTPLUG_HANDLER interface | |
293 | * or NULL if there aren't any. | |
294 | */ | |
295 | HotplugHandler *qdev_get_hotplug_handler(DeviceState *dev); | |
296 | void qdev_unplug(DeviceState *dev, Error **errp); | |
297 | void qdev_simple_device_unplug_cb(HotplugHandler *hotplug_dev, | |
298 | DeviceState *dev, Error **errp); | |
299 | void qdev_machine_creation_done(void); | |
300 | bool qdev_machine_modified(void); | |
301 | ||
302 | qemu_irq qdev_get_gpio_in(DeviceState *dev, int n); | |
303 | qemu_irq qdev_get_gpio_in_named(DeviceState *dev, const char *name, int n); | |
304 | ||
305 | void qdev_connect_gpio_out(DeviceState *dev, int n, qemu_irq pin); | |
306 | void qdev_connect_gpio_out_named(DeviceState *dev, const char *name, int n, | |
307 | qemu_irq pin); | |
308 | qemu_irq qdev_get_gpio_out_connector(DeviceState *dev, const char *name, int n); | |
309 | qemu_irq qdev_intercept_gpio_out(DeviceState *dev, qemu_irq icpt, | |
310 | const char *name, int n); | |
311 | ||
312 | BusState *qdev_get_child_bus(DeviceState *dev, const char *name); | |
313 | ||
314 | /*** Device API. ***/ | |
315 | ||
316 | /* Register device properties. */ | |
317 | /* GPIO inputs also double as IRQ sinks. */ | |
318 | void qdev_init_gpio_in(DeviceState *dev, qemu_irq_handler handler, int n); | |
319 | void qdev_init_gpio_out(DeviceState *dev, qemu_irq *pins, int n); | |
320 | void qdev_init_gpio_out_named(DeviceState *dev, qemu_irq *pins, | |
321 | const char *name, int n); | |
322 | /** | |
323 | * qdev_init_gpio_in_named_with_opaque: create an array of input GPIO lines | |
324 | * for the specified device | |
325 | * | |
326 | * @dev: Device to create input GPIOs for | |
327 | * @handler: Function to call when GPIO line value is set | |
328 | * @opaque: Opaque data pointer to pass to @handler | |
329 | * @name: Name of the GPIO input (must be unique for this device) | |
330 | * @n: Number of GPIO lines in this input set | |
331 | */ | |
332 | void qdev_init_gpio_in_named_with_opaque(DeviceState *dev, | |
333 | qemu_irq_handler handler, | |
334 | void *opaque, | |
335 | const char *name, int n); | |
336 | ||
337 | /** | |
338 | * qdev_init_gpio_in_named: create an array of input GPIO lines | |
339 | * for the specified device | |
340 | * | |
341 | * Like qdev_init_gpio_in_named_with_opaque(), but the opaque pointer | |
342 | * passed to the handler is @dev (which is the most commonly desired behaviour). | |
343 | */ | |
344 | static inline void qdev_init_gpio_in_named(DeviceState *dev, | |
345 | qemu_irq_handler handler, | |
346 | const char *name, int n) | |
347 | { | |
348 | qdev_init_gpio_in_named_with_opaque(dev, handler, dev, name, n); | |
349 | } | |
350 | ||
351 | void qdev_pass_gpios(DeviceState *dev, DeviceState *container, | |
352 | const char *name); | |
353 | ||
354 | BusState *qdev_get_parent_bus(DeviceState *dev); | |
355 | ||
356 | /*** BUS API. ***/ | |
357 | ||
358 | DeviceState *qdev_find_recursive(BusState *bus, const char *id); | |
359 | ||
360 | /* Returns 0 to walk children, > 0 to skip walk, < 0 to terminate walk. */ | |
361 | typedef int (qbus_walkerfn)(BusState *bus, void *opaque); | |
362 | typedef int (qdev_walkerfn)(DeviceState *dev, void *opaque); | |
363 | ||
364 | void qbus_create_inplace(void *bus, size_t size, const char *typename, | |
365 | DeviceState *parent, const char *name); | |
366 | BusState *qbus_create(const char *typename, DeviceState *parent, const char *name); | |
367 | /* Returns > 0 if either devfn or busfn skip walk somewhere in cursion, | |
368 | * < 0 if either devfn or busfn terminate walk somewhere in cursion, | |
369 | * 0 otherwise. */ | |
370 | int qbus_walk_children(BusState *bus, | |
371 | qdev_walkerfn *pre_devfn, qbus_walkerfn *pre_busfn, | |
372 | qdev_walkerfn *post_devfn, qbus_walkerfn *post_busfn, | |
373 | void *opaque); | |
374 | int qdev_walk_children(DeviceState *dev, | |
375 | qdev_walkerfn *pre_devfn, qbus_walkerfn *pre_busfn, | |
376 | qdev_walkerfn *post_devfn, qbus_walkerfn *post_busfn, | |
377 | void *opaque); | |
378 | ||
379 | void qdev_reset_all(DeviceState *dev); | |
380 | void qdev_reset_all_fn(void *opaque); | |
381 | ||
382 | /** | |
383 | * @qbus_reset_all: | |
384 | * @bus: Bus to be reset. | |
385 | * | |
386 | * Reset @bus and perform a bus-level ("hard") reset of all devices connected | |
387 | * to it, including recursive processing of all buses below @bus itself. A | |
388 | * hard reset means that qbus_reset_all will reset all state of the device. | |
389 | * For PCI devices, for example, this will include the base address registers | |
390 | * or configuration space. | |
391 | */ | |
392 | void qbus_reset_all(BusState *bus); | |
393 | void qbus_reset_all_fn(void *opaque); | |
394 | ||
395 | /* This should go away once we get rid of the NULL bus hack */ | |
396 | BusState *sysbus_get_default(void); | |
397 | ||
398 | char *qdev_get_fw_dev_path(DeviceState *dev); | |
399 | char *qdev_get_own_fw_dev_path_from_handler(BusState *bus, DeviceState *dev); | |
400 | ||
401 | /** | |
402 | * @qdev_machine_init | |
403 | * | |
404 | * Initialize platform devices before machine init. This is a hack until full | |
405 | * support for composition is added. | |
406 | */ | |
407 | void qdev_machine_init(void); | |
408 | ||
409 | /** | |
410 | * @device_reset | |
411 | * | |
412 | * Reset a single device (by calling the reset method). | |
413 | */ | |
414 | void device_reset(DeviceState *dev); | |
415 | ||
416 | void device_class_set_parent_reset(DeviceClass *dc, | |
417 | DeviceReset dev_reset, | |
418 | DeviceReset *parent_reset); | |
419 | void device_class_set_parent_realize(DeviceClass *dc, | |
420 | DeviceRealize dev_realize, | |
421 | DeviceRealize *parent_realize); | |
422 | void device_class_set_parent_unrealize(DeviceClass *dc, | |
423 | DeviceUnrealize dev_unrealize, | |
424 | DeviceUnrealize *parent_unrealize); | |
425 | ||
426 | const struct VMStateDescription *qdev_get_vmsd(DeviceState *dev); | |
427 | ||
428 | const char *qdev_fw_name(DeviceState *dev); | |
429 | ||
430 | Object *qdev_get_machine(void); | |
431 | ||
432 | /* FIXME: make this a link<> */ | |
433 | void qdev_set_parent_bus(DeviceState *dev, BusState *bus); | |
434 | ||
435 | extern bool qdev_hotplug; | |
436 | extern bool qdev_hot_removed; | |
437 | ||
438 | char *qdev_get_dev_path(DeviceState *dev); | |
439 | ||
440 | GSList *qdev_build_hotpluggable_device_list(Object *peripheral); | |
441 | ||
442 | void qbus_set_hotplug_handler(BusState *bus, Object *handler, Error **errp); | |
443 | ||
444 | void qbus_set_bus_hotplug_handler(BusState *bus, Error **errp); | |
445 | ||
446 | static inline bool qbus_is_hotpluggable(BusState *bus) | |
447 | { | |
448 | return bus->hotplug_handler; | |
449 | } | |
450 | ||
451 | void device_listener_register(DeviceListener *listener); | |
452 | void device_listener_unregister(DeviceListener *listener); | |
453 | ||
454 | VMChangeStateEntry *qdev_add_vm_change_state_handler(DeviceState *dev, | |
455 | VMChangeStateHandler *cb, | |
456 | void *opaque); | |
457 | ||
458 | #endif |