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