]>
Commit | Line | Data |
---|---|---|
074a86fc AL |
1 | #ifndef QDEV_CORE_H |
2 | #define QDEV_CORE_H | |
3 | ||
1de7afc9 | 4 | #include "qemu/queue.h" |
949fc823 | 5 | #include "qemu/bitmap.h" |
14cccb61 | 6 | #include "qom/object.h" |
0ee4de6c | 7 | #include "hw/hotplug.h" |
c11256aa | 8 | #include "hw/resettable.h" |
074a86fc | 9 | |
074a86fc AL |
10 | enum { |
11 | DEV_NVECTORS_UNSPECIFIED = -1, | |
12 | }; | |
13 | ||
14 | #define TYPE_DEVICE "device" | |
15 | #define DEVICE(obj) OBJECT_CHECK(DeviceState, (obj), TYPE_DEVICE) | |
16 | #define DEVICE_CLASS(klass) OBJECT_CLASS_CHECK(DeviceClass, (klass), TYPE_DEVICE) | |
17 | #define DEVICE_GET_CLASS(obj) OBJECT_GET_CLASS(DeviceClass, (obj), TYPE_DEVICE) | |
18 | ||
3d1237fb MA |
19 | typedef enum DeviceCategory { |
20 | DEVICE_CATEGORY_BRIDGE, | |
21 | DEVICE_CATEGORY_USB, | |
22 | DEVICE_CATEGORY_STORAGE, | |
23 | DEVICE_CATEGORY_NETWORK, | |
24 | DEVICE_CATEGORY_INPUT, | |
25 | DEVICE_CATEGORY_DISPLAY, | |
26 | DEVICE_CATEGORY_SOUND, | |
27 | DEVICE_CATEGORY_MISC, | |
ba31cc72 | 28 | DEVICE_CATEGORY_CPU, |
3d1237fb MA |
29 | DEVICE_CATEGORY_MAX |
30 | } DeviceCategory; | |
31 | ||
249d4172 | 32 | typedef void (*DeviceRealize)(DeviceState *dev, Error **errp); |
b69c3c21 | 33 | typedef void (*DeviceUnrealize)(DeviceState *dev); |
b850f664 | 34 | typedef void (*DeviceReset)(DeviceState *dev); |
02e7f85d | 35 | typedef void (*BusRealize)(BusState *bus, Error **errp); |
b69c3c21 | 36 | typedef void (*BusUnrealize)(BusState *bus); |
074a86fc | 37 | |
249d4172 AF |
38 | /** |
39 | * DeviceClass: | |
40 | * @props: Properties accessing state fields. | |
41 | * @realize: Callback function invoked when the #DeviceState:realized | |
ff46d9d4 | 42 | * property is changed to %true. |
249d4172 AF |
43 | * @unrealize: Callback function invoked when the #DeviceState:realized |
44 | * property is changed to %false. | |
1a37eca1 IM |
45 | * @hotpluggable: indicates if #DeviceClass is hotpluggable, available |
46 | * as readonly "hotpluggable" property of #DeviceState instance | |
249d4172 AF |
47 | * |
48 | * # Realization # | |
49 | * Devices are constructed in two stages, | |
50 | * 1) object instantiation via object_initialize() and | |
51 | * 2) device realization via #DeviceState:realized property. | |
6038f989 TH |
52 | * The former may not fail (and must not abort or exit, since it is called |
53 | * during device introspection already), and the latter may return error | |
54 | * information to the caller and must be re-entrant. | |
249d4172 AF |
55 | * Trivial field initializations should go into #TypeInfo.instance_init. |
56 | * Operations depending on @props static properties should go into @realize. | |
57 | * After successful realization, setting static properties will fail. | |
58 | * | |
daeba969 MA |
59 | * As an interim step, the #DeviceState:realized property can also be |
60 | * set with qdev_init_nofail(). | |
249d4172 AF |
61 | * In the future, devices will propagate this state change to their children |
62 | * and along busses they expose. | |
63 | * The point in time will be deferred to machine creation, so that values | |
64 | * set in @realize will not be introspectable beforehand. Therefore devices | |
65 | * must not create children during @realize; they should initialize them via | |
66 | * object_initialize() in their own #TypeInfo.instance_init and forward the | |
67 | * realization events appropriately. | |
68 | * | |
249d4172 | 69 | * Any type may override the @realize and/or @unrealize callbacks but needs |
782beb52 AF |
70 | * to call the parent type's implementation if keeping their functionality |
71 | * is desired. Refer to QOM documentation for further discussion and examples. | |
72 | * | |
73 | * <note> | |
74 | * <para> | |
ff46d9d4 PMD |
75 | * Since TYPE_DEVICE doesn't implement @realize and @unrealize, types |
76 | * derived directly from it need not call their parent's @realize and | |
77 | * @unrealize. | |
782beb52 AF |
78 | * For other types consult the documentation and implementation of the |
79 | * respective parent types. | |
80 | * </para> | |
81 | * </note> | |
f3a85056 JF |
82 | * |
83 | * # Hiding a device # | |
84 | * To hide a device, a DeviceListener function should_be_hidden() needs to | |
85 | * be registered. | |
86 | * It can be used to defer adding a device and therefore hide it from the | |
87 | * guest. The handler registering to this DeviceListener can save the QOpts | |
88 | * passed to it for re-using it later and must return that it wants the device | |
89 | * to be/remain hidden or not. When the handler function decides the device | |
90 | * shall not be hidden it will be added in qdev_device_add() and | |
91 | * realized as any other device. Otherwise qdev_device_add() will return early | |
92 | * without adding the device. The guest will not see a "hidden" device | |
93 | * until it was marked don't hide and qdev_device_add called again. | |
94 | * | |
249d4172 | 95 | */ |
074a86fc | 96 | typedef struct DeviceClass { |
249d4172 | 97 | /*< private >*/ |
074a86fc | 98 | ObjectClass parent_class; |
249d4172 | 99 | /*< public >*/ |
074a86fc | 100 | |
3d1237fb | 101 | DECLARE_BITMAP(categories, DEVICE_CATEGORY_MAX); |
074a86fc AL |
102 | const char *fw_name; |
103 | const char *desc; | |
385d8f22 PB |
104 | |
105 | /* | |
106 | * The underscore at the end ensures a compile-time error if someone | |
107 | * assigns to dc->props instead of using device_class_set_props. | |
108 | */ | |
109 | Property *props_; | |
efec3dd6 MA |
110 | |
111 | /* | |
e90f2a8c | 112 | * Can this device be instantiated with -device / device_add? |
efec3dd6 MA |
113 | * All devices should support instantiation with device_add, and |
114 | * this flag should not exist. But we're not there, yet. Some | |
115 | * devices fail to instantiate with cryptic error messages. | |
116 | * Others instantiate, but don't work. Exposing users to such | |
e90f2a8c EH |
117 | * behavior would be cruel; clearing this flag will protect them. |
118 | * It should never be cleared without a comment explaining why it | |
119 | * is cleared. | |
efec3dd6 MA |
120 | * TODO remove once we're there |
121 | */ | |
e90f2a8c | 122 | bool user_creatable; |
1a37eca1 | 123 | bool hotpluggable; |
074a86fc AL |
124 | |
125 | /* callbacks */ | |
c11256aa DH |
126 | /* |
127 | * Reset method here is deprecated and replaced by methods in the | |
128 | * resettable class interface to implement a multi-phase reset. | |
129 | * TODO: remove once every reset callback is unused | |
130 | */ | |
b850f664 | 131 | DeviceReset reset; |
249d4172 AF |
132 | DeviceRealize realize; |
133 | DeviceUnrealize unrealize; | |
074a86fc AL |
134 | |
135 | /* device state */ | |
8a9358cc | 136 | const VMStateDescription *vmsd; |
074a86fc AL |
137 | |
138 | /* Private to qdev / bus. */ | |
074a86fc AL |
139 | const char *bus_type; |
140 | } DeviceClass; | |
141 | ||
a5f54290 PC |
142 | typedef struct NamedGPIOList NamedGPIOList; |
143 | ||
144 | struct NamedGPIOList { | |
145 | char *name; | |
146 | qemu_irq *in; | |
147 | int num_in; | |
a5f54290 PC |
148 | int num_out; |
149 | QLIST_ENTRY(NamedGPIOList) node; | |
150 | }; | |
151 | ||
0e6934f2 DH |
152 | typedef struct Clock Clock; |
153 | typedef struct NamedClockList NamedClockList; | |
154 | ||
155 | struct NamedClockList { | |
156 | char *name; | |
157 | Clock *clock; | |
158 | bool output; | |
159 | bool alias; | |
160 | QLIST_ENTRY(NamedClockList) node; | |
161 | }; | |
162 | ||
7983c8a3 AF |
163 | /** |
164 | * DeviceState: | |
165 | * @realized: Indicates whether the device has been fully constructed. | |
c11256aa | 166 | * @reset: ResettableState for the device; handled by Resettable interface. |
7983c8a3 AF |
167 | * |
168 | * This structure should not be accessed directly. We declare it here | |
169 | * so that it can be embedded in individual device state structures. | |
170 | */ | |
074a86fc | 171 | struct DeviceState { |
7983c8a3 | 172 | /*< private >*/ |
074a86fc | 173 | Object parent_obj; |
7983c8a3 | 174 | /*< public >*/ |
074a86fc AL |
175 | |
176 | const char *id; | |
04162f8f | 177 | char *canonical_path; |
7983c8a3 | 178 | bool realized; |
352e8da7 | 179 | bool pending_deleted_event; |
074a86fc AL |
180 | QemuOpts *opts; |
181 | int hotplugged; | |
a1190ab6 | 182 | bool allow_unplug_during_migration; |
074a86fc | 183 | BusState *parent_bus; |
a5f54290 | 184 | QLIST_HEAD(, NamedGPIOList) gpios; |
0e6934f2 | 185 | QLIST_HEAD(, NamedClockList) clocks; |
074a86fc AL |
186 | QLIST_HEAD(, BusState) child_bus; |
187 | int num_child_bus; | |
188 | int instance_id_alias; | |
189 | int alias_required_for_version; | |
c11256aa | 190 | ResettableState reset; |
074a86fc AL |
191 | }; |
192 | ||
707ff800 PD |
193 | struct DeviceListener { |
194 | void (*realize)(DeviceListener *listener, DeviceState *dev); | |
195 | void (*unrealize)(DeviceListener *listener, DeviceState *dev); | |
f3a85056 JF |
196 | /* |
197 | * This callback is called upon init of the DeviceState and allows to | |
198 | * inform qdev that a device should be hidden, depending on the device | |
199 | * opts, for example, to hide a standby device. | |
200 | */ | |
201 | int (*should_be_hidden)(DeviceListener *listener, QemuOpts *device_opts); | |
707ff800 PD |
202 | QTAILQ_ENTRY(DeviceListener) link; |
203 | }; | |
204 | ||
074a86fc AL |
205 | #define TYPE_BUS "bus" |
206 | #define BUS(obj) OBJECT_CHECK(BusState, (obj), TYPE_BUS) | |
207 | #define BUS_CLASS(klass) OBJECT_CLASS_CHECK(BusClass, (klass), TYPE_BUS) | |
208 | #define BUS_GET_CLASS(obj) OBJECT_GET_CLASS(BusClass, (obj), TYPE_BUS) | |
209 | ||
210 | struct BusClass { | |
211 | ObjectClass parent_class; | |
212 | ||
213 | /* FIXME first arg should be BusState */ | |
214 | void (*print_dev)(Monitor *mon, DeviceState *dev, int indent); | |
215 | char *(*get_dev_path)(DeviceState *dev); | |
216 | /* | |
217 | * This callback is used to create Open Firmware device path in accordance | |
218 | * with OF spec http://forthworks.com/standards/of1275.pdf. Individual bus | |
219 | * bindings can be found at http://playground.sun.com/1275/bindings/. | |
220 | */ | |
221 | char *(*get_fw_dev_path)(DeviceState *dev); | |
dcc20931 | 222 | void (*reset)(BusState *bus); |
02e7f85d BD |
223 | BusRealize realize; |
224 | BusUnrealize unrealize; | |
225 | ||
1395af6f FK |
226 | /* maximum devices allowed on the bus, 0: no limit. */ |
227 | int max_dev; | |
61de3676 AG |
228 | /* number of automatically allocated bus ids (e.g. ide.0) */ |
229 | int automatic_ids; | |
074a86fc AL |
230 | }; |
231 | ||
232 | typedef struct BusChild { | |
233 | DeviceState *child; | |
234 | int index; | |
235 | QTAILQ_ENTRY(BusChild) sibling; | |
236 | } BusChild; | |
237 | ||
0ee4de6c IM |
238 | #define QDEV_HOTPLUG_HANDLER_PROPERTY "hotplug-handler" |
239 | ||
074a86fc AL |
240 | /** |
241 | * BusState: | |
27c6ef1b | 242 | * @hotplug_handler: link to a hotplug handler associated with bus. |
c11256aa | 243 | * @reset: ResettableState for the bus; handled by Resettable interface. |
074a86fc AL |
244 | */ |
245 | struct BusState { | |
246 | Object obj; | |
247 | DeviceState *parent; | |
f73480c3 | 248 | char *name; |
0ee4de6c | 249 | HotplugHandler *hotplug_handler; |
074a86fc | 250 | int max_index; |
02e7f85d | 251 | bool realized; |
12b2e9f3 | 252 | int num_children; |
eae3eb3e | 253 | QTAILQ_HEAD(, BusChild) children; |
074a86fc | 254 | QLIST_ENTRY(BusState) sibling; |
c11256aa | 255 | ResettableState reset; |
074a86fc AL |
256 | }; |
257 | ||
5cc56cc6 PM |
258 | /** |
259 | * Property: | |
260 | * @set_default: true if the default value should be set from @defval, | |
261 | * in which case @info->set_default_value must not be NULL | |
262 | * (if false then no default value is set by the property system | |
263 | * and the field retains whatever value it was given by instance_init). | |
264 | * @defval: default value for the property. This is used only if @set_default | |
265 | * is true. | |
266 | */ | |
074a86fc AL |
267 | struct Property { |
268 | const char *name; | |
1b6b7d10 | 269 | const PropertyInfo *info; |
3b6ca402 | 270 | ptrdiff_t offset; |
074a86fc | 271 | uint8_t bitnr; |
5cc56cc6 | 272 | bool set_default; |
76318657 MAL |
273 | union { |
274 | int64_t i; | |
3fb2111f | 275 | uint64_t u; |
76318657 | 276 | } defval; |
0be6bfac | 277 | int arrayoffset; |
1b6b7d10 | 278 | const PropertyInfo *arrayinfo; |
0be6bfac | 279 | int arrayfieldsize; |
5b4ff3c6 | 280 | const char *link_type; |
074a86fc AL |
281 | }; |
282 | ||
283 | struct PropertyInfo { | |
284 | const char *name; | |
51b2e8c3 | 285 | const char *description; |
f7abe0ec | 286 | const QEnumLookup *enum_table; |
074a86fc | 287 | int (*print)(DeviceState *dev, Property *prop, char *dest, size_t len); |
77b06bba | 288 | void (*set_default_value)(ObjectProperty *op, const Property *prop); |
40c2281c | 289 | void (*create)(ObjectClass *oc, Property *prop); |
074a86fc AL |
290 | ObjectPropertyAccessor *get; |
291 | ObjectPropertyAccessor *set; | |
292 | ObjectPropertyRelease *release; | |
293 | }; | |
294 | ||
9f9260a3 DS |
295 | /** |
296 | * GlobalProperty: | |
b3ce84fe | 297 | * @used: Set to true if property was used when initializing a device. |
92fd453c DDAG |
298 | * @optional: If set to true, GlobalProperty will be skipped without errors |
299 | * if the property doesn't exist. | |
cff8b715 MAL |
300 | * |
301 | * An error is fatal for non-hotplugged devices, when the global is applied. | |
9f9260a3 | 302 | */ |
074a86fc AL |
303 | typedef struct GlobalProperty { |
304 | const char *driver; | |
305 | const char *property; | |
306 | const char *value; | |
b3ce84fe | 307 | bool used; |
92fd453c | 308 | bool optional; |
074a86fc AL |
309 | } GlobalProperty; |
310 | ||
ea9ce893 MAL |
311 | static inline void |
312 | compat_props_add(GPtrArray *arr, | |
313 | GlobalProperty props[], size_t nelem) | |
314 | { | |
315 | int i; | |
316 | for (i = 0; i < nelem; i++) { | |
317 | g_ptr_array_add(arr, (void *)&props[i]); | |
318 | } | |
319 | } | |
320 | ||
074a86fc AL |
321 | /*** Board API. This should go away once we have a machine config file. ***/ |
322 | ||
323 | DeviceState *qdev_create(BusState *bus, const char *name); | |
324 | DeviceState *qdev_try_create(BusState *bus, const char *name); | |
074a86fc AL |
325 | void qdev_init_nofail(DeviceState *dev); |
326 | void qdev_set_legacy_instance_id(DeviceState *dev, int alias_id, | |
327 | int required_for_version); | |
14405c27 | 328 | HotplugHandler *qdev_get_bus_hotplug_handler(DeviceState *dev); |
03fcbd9d | 329 | HotplugHandler *qdev_get_machine_hotplug_handler(DeviceState *dev); |
d2321d31 | 330 | bool qdev_hotplug_allowed(DeviceState *dev, Error **errp); |
17cc0128 IM |
331 | /** |
332 | * qdev_get_hotplug_handler: Get handler responsible for device wiring | |
333 | * | |
334 | * Find HOTPLUG_HANDLER for @dev that provides [pre|un]plug callbacks for it. | |
335 | * | |
336 | * Note: in case @dev has a parent bus, it will be returned as handler unless | |
337 | * machine handler overrides it. | |
338 | * | |
339 | * Returns: pointer to object that implements TYPE_HOTPLUG_HANDLER interface | |
340 | * or NULL if there aren't any. | |
341 | */ | |
c06b2ffb | 342 | HotplugHandler *qdev_get_hotplug_handler(DeviceState *dev); |
074a86fc | 343 | void qdev_unplug(DeviceState *dev, Error **errp); |
014176f9 IM |
344 | void qdev_simple_device_unplug_cb(HotplugHandler *hotplug_dev, |
345 | DeviceState *dev, Error **errp); | |
074a86fc AL |
346 | void qdev_machine_creation_done(void); |
347 | bool qdev_machine_modified(void); | |
348 | ||
349 | qemu_irq qdev_get_gpio_in(DeviceState *dev, int n); | |
a5f54290 PC |
350 | qemu_irq qdev_get_gpio_in_named(DeviceState *dev, const char *name, int n); |
351 | ||
074a86fc | 352 | void qdev_connect_gpio_out(DeviceState *dev, int n, qemu_irq pin); |
a5f54290 PC |
353 | void qdev_connect_gpio_out_named(DeviceState *dev, const char *name, int n, |
354 | qemu_irq pin); | |
b7973186 | 355 | qemu_irq qdev_get_gpio_out_connector(DeviceState *dev, const char *name, int n); |
0c24db2b PC |
356 | qemu_irq qdev_intercept_gpio_out(DeviceState *dev, qemu_irq icpt, |
357 | const char *name, int n); | |
074a86fc AL |
358 | |
359 | BusState *qdev_get_child_bus(DeviceState *dev, const char *name); | |
360 | ||
361 | /*** Device API. ***/ | |
362 | ||
363 | /* Register device properties. */ | |
364 | /* GPIO inputs also double as IRQ sinks. */ | |
365 | void qdev_init_gpio_in(DeviceState *dev, qemu_irq_handler handler, int n); | |
366 | void qdev_init_gpio_out(DeviceState *dev, qemu_irq *pins, int n); | |
a5f54290 PC |
367 | void qdev_init_gpio_out_named(DeviceState *dev, qemu_irq *pins, |
368 | const char *name, int n); | |
4a151677 PM |
369 | /** |
370 | * qdev_init_gpio_in_named_with_opaque: create an array of input GPIO lines | |
371 | * for the specified device | |
372 | * | |
373 | * @dev: Device to create input GPIOs for | |
374 | * @handler: Function to call when GPIO line value is set | |
375 | * @opaque: Opaque data pointer to pass to @handler | |
376 | * @name: Name of the GPIO input (must be unique for this device) | |
377 | * @n: Number of GPIO lines in this input set | |
378 | */ | |
379 | void qdev_init_gpio_in_named_with_opaque(DeviceState *dev, | |
380 | qemu_irq_handler handler, | |
381 | void *opaque, | |
382 | const char *name, int n); | |
383 | ||
384 | /** | |
385 | * qdev_init_gpio_in_named: create an array of input GPIO lines | |
386 | * for the specified device | |
387 | * | |
388 | * Like qdev_init_gpio_in_named_with_opaque(), but the opaque pointer | |
389 | * passed to the handler is @dev (which is the most commonly desired behaviour). | |
390 | */ | |
391 | static inline void qdev_init_gpio_in_named(DeviceState *dev, | |
392 | qemu_irq_handler handler, | |
393 | const char *name, int n) | |
394 | { | |
395 | qdev_init_gpio_in_named_with_opaque(dev, handler, dev, name, n); | |
396 | } | |
074a86fc | 397 | |
17a96a14 PC |
398 | void qdev_pass_gpios(DeviceState *dev, DeviceState *container, |
399 | const char *name); | |
400 | ||
074a86fc AL |
401 | BusState *qdev_get_parent_bus(DeviceState *dev); |
402 | ||
403 | /*** BUS API. ***/ | |
404 | ||
405 | DeviceState *qdev_find_recursive(BusState *bus, const char *id); | |
406 | ||
407 | /* Returns 0 to walk children, > 0 to skip walk, < 0 to terminate walk. */ | |
408 | typedef int (qbus_walkerfn)(BusState *bus, void *opaque); | |
409 | typedef int (qdev_walkerfn)(DeviceState *dev, void *opaque); | |
410 | ||
fb17dfe0 | 411 | void qbus_create_inplace(void *bus, size_t size, const char *typename, |
074a86fc AL |
412 | DeviceState *parent, const char *name); |
413 | BusState *qbus_create(const char *typename, DeviceState *parent, const char *name); | |
414 | /* Returns > 0 if either devfn or busfn skip walk somewhere in cursion, | |
415 | * < 0 if either devfn or busfn terminate walk somewhere in cursion, | |
416 | * 0 otherwise. */ | |
0293214b PB |
417 | int qbus_walk_children(BusState *bus, |
418 | qdev_walkerfn *pre_devfn, qbus_walkerfn *pre_busfn, | |
419 | qdev_walkerfn *post_devfn, qbus_walkerfn *post_busfn, | |
420 | void *opaque); | |
421 | int qdev_walk_children(DeviceState *dev, | |
422 | qdev_walkerfn *pre_devfn, qbus_walkerfn *pre_busfn, | |
423 | qdev_walkerfn *post_devfn, qbus_walkerfn *post_busfn, | |
424 | void *opaque); | |
425 | ||
abb89dbf DH |
426 | /** |
427 | * @qdev_reset_all: | |
428 | * Reset @dev. See @qbus_reset_all() for more details. | |
429 | * | |
430 | * Note: This function is deprecated and will be removed when it becomes unused. | |
431 | * Please use device_cold_reset() now. | |
432 | */ | |
074a86fc | 433 | void qdev_reset_all(DeviceState *dev); |
ff8de075 | 434 | void qdev_reset_all_fn(void *opaque); |
d0508c36 PB |
435 | |
436 | /** | |
437 | * @qbus_reset_all: | |
438 | * @bus: Bus to be reset. | |
439 | * | |
440 | * Reset @bus and perform a bus-level ("hard") reset of all devices connected | |
441 | * to it, including recursive processing of all buses below @bus itself. A | |
442 | * hard reset means that qbus_reset_all will reset all state of the device. | |
443 | * For PCI devices, for example, this will include the base address registers | |
444 | * or configuration space. | |
abb89dbf DH |
445 | * |
446 | * Note: This function is deprecated and will be removed when it becomes unused. | |
447 | * Please use bus_cold_reset() now. | |
d0508c36 PB |
448 | */ |
449 | void qbus_reset_all(BusState *bus); | |
074a86fc AL |
450 | void qbus_reset_all_fn(void *opaque); |
451 | ||
abb89dbf DH |
452 | /** |
453 | * device_cold_reset: | |
454 | * Reset device @dev and perform a recursive processing using the resettable | |
455 | * interface. It triggers a RESET_TYPE_COLD. | |
456 | */ | |
457 | void device_cold_reset(DeviceState *dev); | |
458 | ||
459 | /** | |
460 | * bus_cold_reset: | |
461 | * | |
462 | * Reset bus @bus and perform a recursive processing using the resettable | |
463 | * interface. It triggers a RESET_TYPE_COLD. | |
464 | */ | |
465 | void bus_cold_reset(BusState *bus); | |
466 | ||
c11256aa DH |
467 | /** |
468 | * device_is_in_reset: | |
469 | * Return true if the device @dev is currently being reset. | |
470 | */ | |
471 | bool device_is_in_reset(DeviceState *dev); | |
472 | ||
473 | /** | |
474 | * bus_is_in_reset: | |
475 | * Return true if the bus @bus is currently being reset. | |
476 | */ | |
477 | bool bus_is_in_reset(BusState *bus); | |
478 | ||
074a86fc AL |
479 | /* This should go away once we get rid of the NULL bus hack */ |
480 | BusState *sysbus_get_default(void); | |
481 | ||
482 | char *qdev_get_fw_dev_path(DeviceState *dev); | |
0be63901 | 483 | char *qdev_get_own_fw_dev_path_from_handler(BusState *bus, DeviceState *dev); |
074a86fc AL |
484 | |
485 | /** | |
486 | * @qdev_machine_init | |
487 | * | |
488 | * Initialize platform devices before machine init. This is a hack until full | |
489 | * support for composition is added. | |
490 | */ | |
491 | void qdev_machine_init(void); | |
492 | ||
493 | /** | |
f703a04c | 494 | * device_legacy_reset: |
074a86fc AL |
495 | * |
496 | * Reset a single device (by calling the reset method). | |
abb89dbf DH |
497 | * Note: This function is deprecated and will be removed when it becomes unused. |
498 | * Please use device_cold_reset() now. | |
074a86fc | 499 | */ |
f703a04c | 500 | void device_legacy_reset(DeviceState *dev); |
074a86fc | 501 | |
4f67d30b MAL |
502 | void device_class_set_props(DeviceClass *dc, Property *props); |
503 | ||
c11256aa DH |
504 | /** |
505 | * device_class_set_parent_reset: | |
506 | * TODO: remove the function when DeviceClass's reset method | |
507 | * is not used anymore. | |
508 | */ | |
46795cf2 PMD |
509 | void device_class_set_parent_reset(DeviceClass *dc, |
510 | DeviceReset dev_reset, | |
511 | DeviceReset *parent_reset); | |
512 | void device_class_set_parent_realize(DeviceClass *dc, | |
513 | DeviceRealize dev_realize, | |
514 | DeviceRealize *parent_realize); | |
515 | void device_class_set_parent_unrealize(DeviceClass *dc, | |
516 | DeviceUnrealize dev_unrealize, | |
517 | DeviceUnrealize *parent_unrealize); | |
518 | ||
8a9358cc | 519 | const VMStateDescription *qdev_get_vmsd(DeviceState *dev); |
074a86fc AL |
520 | |
521 | const char *qdev_fw_name(DeviceState *dev); | |
522 | ||
523 | Object *qdev_get_machine(void); | |
524 | ||
525 | /* FIXME: make this a link<> */ | |
526 | void qdev_set_parent_bus(DeviceState *dev, BusState *bus); | |
527 | ||
9bed84c1 | 528 | extern bool qdev_hotplug; |
21def24a | 529 | extern bool qdev_hot_removed; |
074a86fc AL |
530 | |
531 | char *qdev_get_dev_path(DeviceState *dev); | |
532 | ||
94d1cc5f | 533 | void qbus_set_hotplug_handler(BusState *bus, Object *handler, Error **errp); |
431bbb26 IM |
534 | |
535 | void qbus_set_bus_hotplug_handler(BusState *bus, Error **errp); | |
39b888bd IM |
536 | |
537 | static inline bool qbus_is_hotpluggable(BusState *bus) | |
538 | { | |
2d9a982f | 539 | return bus->hotplug_handler; |
39b888bd | 540 | } |
707ff800 PD |
541 | |
542 | void device_listener_register(DeviceListener *listener); | |
543 | void device_listener_unregister(DeviceListener *listener); | |
544 | ||
f3a85056 JF |
545 | /** |
546 | * @qdev_should_hide_device: | |
547 | * @opts: QemuOpts as passed on cmdline. | |
548 | * | |
549 | * Check if a device should be added. | |
550 | * When a device is added via qdev_device_add() this will be called, | |
551 | * and return if the device should be added now or not. | |
552 | */ | |
553 | bool qdev_should_hide_device(QemuOpts *opts); | |
554 | ||
074a86fc | 555 | #endif |