]>
Commit | Line | Data |
---|---|---|
074a86fc AL |
1 | #ifndef QDEV_CORE_H |
2 | #define QDEV_CORE_H | |
3 | ||
26462a70 | 4 | #include "qemu/atomic.h" |
1de7afc9 | 5 | #include "qemu/queue.h" |
949fc823 | 6 | #include "qemu/bitmap.h" |
2d24a646 ML |
7 | #include "qemu/rcu.h" |
8 | #include "qemu/rcu_queue.h" | |
14cccb61 | 9 | #include "qom/object.h" |
0ee4de6c | 10 | #include "hw/hotplug.h" |
c11256aa | 11 | #include "hw/resettable.h" |
074a86fc | 12 | |
6aebb1f6 AB |
13 | /** |
14 | * DOC: The QEMU Device API | |
15 | * | |
16 | * All modern devices should represented as a derived QOM class of | |
17 | * TYPE_DEVICE. The device API introduces the additional methods of | |
18 | * @realize and @unrealize to represent additional stages in a device | |
19 | * objects life cycle. | |
20 | * | |
21 | * Realization | |
22 | * ----------- | |
23 | * | |
24 | * Devices are constructed in two stages: | |
25 | * | |
26 | * 1) object instantiation via object_initialize() and | |
27 | * 2) device realization via the #DeviceState.realized property | |
28 | * | |
29 | * The former may not fail (and must not abort or exit, since it is called | |
30 | * during device introspection already), and the latter may return error | |
31 | * information to the caller and must be re-entrant. | |
32 | * Trivial field initializations should go into #TypeInfo.instance_init. | |
33 | * Operations depending on @props static properties should go into @realize. | |
34 | * After successful realization, setting static properties will fail. | |
35 | * | |
36 | * As an interim step, the #DeviceState.realized property can also be | |
37 | * set with qdev_realize(). In the future, devices will propagate this | |
38 | * state change to their children and along busses they expose. The | |
39 | * point in time will be deferred to machine creation, so that values | |
40 | * set in @realize will not be introspectable beforehand. Therefore | |
41 | * devices must not create children during @realize; they should | |
42 | * initialize them via object_initialize() in their own | |
43 | * #TypeInfo.instance_init and forward the realization events | |
44 | * appropriately. | |
45 | * | |
46 | * Any type may override the @realize and/or @unrealize callbacks but needs | |
47 | * to call the parent type's implementation if keeping their functionality | |
48 | * is desired. Refer to QOM documentation for further discussion and examples. | |
49 | * | |
50 | * .. note:: | |
51 | * Since TYPE_DEVICE doesn't implement @realize and @unrealize, types | |
52 | * derived directly from it need not call their parent's @realize and | |
53 | * @unrealize. For other types consult the documentation and | |
54 | * implementation of the respective parent types. | |
55 | * | |
56 | * Hiding a device | |
57 | * --------------- | |
58 | * | |
59 | * To hide a device, a DeviceListener function hide_device() needs to | |
60 | * be registered. It can be used to defer adding a device and | |
61 | * therefore hide it from the guest. The handler registering to this | |
62 | * DeviceListener can save the QOpts passed to it for re-using it | |
63 | * later. It must return if it wants the device to be hidden or | |
64 | * visible. When the handler function decides the device shall be | |
65 | * visible it will be added with qdev_device_add() and realized as any | |
66 | * other device. Otherwise qdev_device_add() will return early without | |
67 | * adding the device. The guest will not see a "hidden" device until | |
68 | * it was marked visible and qdev_device_add called again. | |
69 | * | |
70 | */ | |
71 | ||
074a86fc AL |
72 | enum { |
73 | DEV_NVECTORS_UNSPECIFIED = -1, | |
74 | }; | |
75 | ||
76 | #define TYPE_DEVICE "device" | |
a489d195 | 77 | OBJECT_DECLARE_TYPE(DeviceState, DeviceClass, DEVICE) |
074a86fc | 78 | |
3d1237fb MA |
79 | typedef enum DeviceCategory { |
80 | DEVICE_CATEGORY_BRIDGE, | |
81 | DEVICE_CATEGORY_USB, | |
82 | DEVICE_CATEGORY_STORAGE, | |
83 | DEVICE_CATEGORY_NETWORK, | |
84 | DEVICE_CATEGORY_INPUT, | |
85 | DEVICE_CATEGORY_DISPLAY, | |
86 | DEVICE_CATEGORY_SOUND, | |
87 | DEVICE_CATEGORY_MISC, | |
ba31cc72 | 88 | DEVICE_CATEGORY_CPU, |
b10cb627 | 89 | DEVICE_CATEGORY_WATCHDOG, |
3d1237fb MA |
90 | DEVICE_CATEGORY_MAX |
91 | } DeviceCategory; | |
92 | ||
249d4172 | 93 | typedef void (*DeviceRealize)(DeviceState *dev, Error **errp); |
b69c3c21 | 94 | typedef void (*DeviceUnrealize)(DeviceState *dev); |
b850f664 | 95 | typedef void (*DeviceReset)(DeviceState *dev); |
02e7f85d | 96 | typedef void (*BusRealize)(BusState *bus, Error **errp); |
b69c3c21 | 97 | typedef void (*BusUnrealize)(BusState *bus); |
074a86fc | 98 | |
249d4172 | 99 | /** |
6aebb1f6 | 100 | * struct DeviceClass - The base class for all devices. |
249d4172 AF |
101 | * @props: Properties accessing state fields. |
102 | * @realize: Callback function invoked when the #DeviceState:realized | |
ff46d9d4 | 103 | * property is changed to %true. |
249d4172 AF |
104 | * @unrealize: Callback function invoked when the #DeviceState:realized |
105 | * property is changed to %false. | |
1a37eca1 IM |
106 | * @hotpluggable: indicates if #DeviceClass is hotpluggable, available |
107 | * as readonly "hotpluggable" property of #DeviceState instance | |
249d4172 | 108 | * |
249d4172 | 109 | */ |
db1015e9 | 110 | struct DeviceClass { |
6aebb1f6 | 111 | /* private: */ |
074a86fc AL |
112 | ObjectClass parent_class; |
113 | ||
6aebb1f6 AB |
114 | /* public: */ |
115 | ||
116 | /** | |
117 | * @categories: device categories device belongs to | |
118 | */ | |
3d1237fb | 119 | DECLARE_BITMAP(categories, DEVICE_CATEGORY_MAX); |
6aebb1f6 AB |
120 | /** |
121 | * @fw_name: name used to identify device to firmware interfaces | |
122 | */ | |
074a86fc | 123 | const char *fw_name; |
6aebb1f6 AB |
124 | /** |
125 | * @desc: human readable description of device | |
126 | */ | |
074a86fc | 127 | const char *desc; |
385d8f22 | 128 | |
6aebb1f6 AB |
129 | /** |
130 | * @props_: properties associated with device, should only be | |
131 | * assigned by using device_class_set_props(). The underscore | |
132 | * ensures a compile-time error if someone attempts to assign | |
133 | * dc->props directly. | |
385d8f22 PB |
134 | */ |
135 | Property *props_; | |
efec3dd6 | 136 | |
6aebb1f6 AB |
137 | /** |
138 | * @user_creatable: Can user instantiate with -device / device_add? | |
139 | * | |
efec3dd6 MA |
140 | * All devices should support instantiation with device_add, and |
141 | * this flag should not exist. But we're not there, yet. Some | |
142 | * devices fail to instantiate with cryptic error messages. | |
143 | * Others instantiate, but don't work. Exposing users to such | |
e90f2a8c EH |
144 | * behavior would be cruel; clearing this flag will protect them. |
145 | * It should never be cleared without a comment explaining why it | |
146 | * is cleared. | |
6aebb1f6 | 147 | * |
efec3dd6 MA |
148 | * TODO remove once we're there |
149 | */ | |
e90f2a8c | 150 | bool user_creatable; |
1a37eca1 | 151 | bool hotpluggable; |
074a86fc AL |
152 | |
153 | /* callbacks */ | |
6aebb1f6 AB |
154 | /** |
155 | * @reset: deprecated device reset method pointer | |
156 | * | |
157 | * Modern code should use the ResettableClass interface to | |
158 | * implement a multi-phase reset. | |
159 | * | |
c11256aa DH |
160 | * TODO: remove once every reset callback is unused |
161 | */ | |
b850f664 | 162 | DeviceReset reset; |
249d4172 AF |
163 | DeviceRealize realize; |
164 | DeviceUnrealize unrealize; | |
074a86fc | 165 | |
6aebb1f6 AB |
166 | /** |
167 | * @vmsd: device state serialisation description for | |
168 | * migration/save/restore | |
169 | */ | |
8a9358cc | 170 | const VMStateDescription *vmsd; |
074a86fc | 171 | |
6aebb1f6 AB |
172 | /** |
173 | * @bus_type: bus type | |
174 | * private: to qdev / bus. | |
175 | */ | |
074a86fc | 176 | const char *bus_type; |
db1015e9 | 177 | }; |
074a86fc | 178 | |
a5f54290 PC |
179 | typedef struct NamedGPIOList NamedGPIOList; |
180 | ||
181 | struct NamedGPIOList { | |
182 | char *name; | |
183 | qemu_irq *in; | |
184 | int num_in; | |
a5f54290 PC |
185 | int num_out; |
186 | QLIST_ENTRY(NamedGPIOList) node; | |
187 | }; | |
188 | ||
0e6934f2 DH |
189 | typedef struct Clock Clock; |
190 | typedef struct NamedClockList NamedClockList; | |
191 | ||
192 | struct NamedClockList { | |
193 | char *name; | |
194 | Clock *clock; | |
195 | bool output; | |
196 | bool alias; | |
197 | QLIST_ENTRY(NamedClockList) node; | |
198 | }; | |
199 | ||
a2e1753b AB |
200 | typedef struct { |
201 | bool engaged_in_io; | |
202 | } MemReentrancyGuard; | |
203 | ||
6aebb1f6 AB |
204 | |
205 | typedef QLIST_HEAD(, NamedGPIOList) NamedGPIOListHead; | |
206 | typedef QLIST_HEAD(, NamedClockList) NamedClockListHead; | |
207 | typedef QLIST_HEAD(, BusState) BusStateHead; | |
208 | ||
7983c8a3 | 209 | /** |
6aebb1f6 | 210 | * struct DeviceState - common device state, accessed with qdev helpers |
7983c8a3 AF |
211 | * |
212 | * This structure should not be accessed directly. We declare it here | |
213 | * so that it can be embedded in individual device state structures. | |
214 | */ | |
074a86fc | 215 | struct DeviceState { |
6aebb1f6 | 216 | /* private: */ |
074a86fc | 217 | Object parent_obj; |
6aebb1f6 | 218 | /* public: */ |
074a86fc | 219 | |
6aebb1f6 AB |
220 | /** |
221 | * @id: global device id | |
222 | */ | |
163f3847 | 223 | char *id; |
6aebb1f6 AB |
224 | /** |
225 | * @canonical_path: canonical path of realized device in the QOM tree | |
226 | */ | |
04162f8f | 227 | char *canonical_path; |
6aebb1f6 AB |
228 | /** |
229 | * @realized: has device been realized? | |
230 | */ | |
7983c8a3 | 231 | bool realized; |
6aebb1f6 AB |
232 | /** |
233 | * @pending_deleted_event: track pending deletion events during unplug | |
234 | */ | |
352e8da7 | 235 | bool pending_deleted_event; |
6aebb1f6 AB |
236 | /** |
237 | * @pending_deleted_expires_ms: optional timeout for deletion events | |
238 | */ | |
18416c62 | 239 | int64_t pending_deleted_expires_ms; |
6aebb1f6 AB |
240 | /** |
241 | * @opts: QDict of options for the device | |
242 | */ | |
f3558b1b | 243 | QDict *opts; |
6aebb1f6 AB |
244 | /** |
245 | * @hotplugged: was device added after PHASE_MACHINE_READY? | |
246 | */ | |
074a86fc | 247 | int hotplugged; |
6aebb1f6 AB |
248 | /** |
249 | * @allow_unplug_during_migration: can device be unplugged during migration | |
250 | */ | |
a1190ab6 | 251 | bool allow_unplug_during_migration; |
6aebb1f6 AB |
252 | /** |
253 | * @parent_bus: bus this device belongs to | |
254 | */ | |
074a86fc | 255 | BusState *parent_bus; |
6aebb1f6 AB |
256 | /** |
257 | * @gpios: QLIST of named GPIOs the device provides. | |
258 | */ | |
259 | NamedGPIOListHead gpios; | |
260 | /** | |
261 | * @clocks: QLIST of named clocks the device provides. | |
262 | */ | |
263 | NamedClockListHead clocks; | |
264 | /** | |
265 | * @child_bus: QLIST of child buses | |
266 | */ | |
267 | BusStateHead child_bus; | |
268 | /** | |
269 | * @num_child_bus: number of @child_bus entries | |
270 | */ | |
074a86fc | 271 | int num_child_bus; |
6aebb1f6 AB |
272 | /** |
273 | * @instance_id_alias: device alias for handling legacy migration setups | |
274 | */ | |
074a86fc | 275 | int instance_id_alias; |
6aebb1f6 AB |
276 | /** |
277 | * @alias_required_for_version: indicates @instance_id_alias is | |
278 | * needed for migration | |
279 | */ | |
074a86fc | 280 | int alias_required_for_version; |
6aebb1f6 AB |
281 | /** |
282 | * @reset: ResettableState for the device; handled by Resettable interface. | |
283 | */ | |
c11256aa | 284 | ResettableState reset; |
6aebb1f6 AB |
285 | /** |
286 | * @unplug_blockers: list of reasons to block unplugging of device | |
287 | */ | |
217c7f01 | 288 | GSList *unplug_blockers; |
6aebb1f6 AB |
289 | /** |
290 | * @mem_reentrancy_guard: Is the device currently in mmio/pio/dma? | |
291 | * | |
292 | * Used to prevent re-entrancy confusing things. | |
293 | */ | |
a2e1753b | 294 | MemReentrancyGuard mem_reentrancy_guard; |
074a86fc AL |
295 | }; |
296 | ||
707ff800 PD |
297 | struct DeviceListener { |
298 | void (*realize)(DeviceListener *listener, DeviceState *dev); | |
299 | void (*unrealize)(DeviceListener *listener, DeviceState *dev); | |
f3a85056 | 300 | /* |
b91ad981 JQ |
301 | * This callback is called upon init of the DeviceState and |
302 | * informs qdev if a device should be visible or hidden. We can | |
303 | * hide a failover device depending for example on the device | |
304 | * opts. | |
7d618082 KW |
305 | * |
306 | * On errors, it returns false and errp is set. Device creation | |
307 | * should fail in this case. | |
f3a85056 | 308 | */ |
f3558b1b KW |
309 | bool (*hide_device)(DeviceListener *listener, const QDict *device_opts, |
310 | bool from_json, Error **errp); | |
707ff800 PD |
311 | QTAILQ_ENTRY(DeviceListener) link; |
312 | }; | |
313 | ||
074a86fc | 314 | #define TYPE_BUS "bus" |
8110fa1d EH |
315 | DECLARE_OBJ_CHECKERS(BusState, BusClass, |
316 | BUS, TYPE_BUS) | |
074a86fc AL |
317 | |
318 | struct BusClass { | |
319 | ObjectClass parent_class; | |
320 | ||
321 | /* FIXME first arg should be BusState */ | |
322 | void (*print_dev)(Monitor *mon, DeviceState *dev, int indent); | |
323 | char *(*get_dev_path)(DeviceState *dev); | |
bb755ba4 | 324 | |
074a86fc AL |
325 | /* |
326 | * This callback is used to create Open Firmware device path in accordance | |
327 | * with OF spec http://forthworks.com/standards/of1275.pdf. Individual bus | |
328 | * bindings can be found at http://playground.sun.com/1275/bindings/. | |
329 | */ | |
330 | char *(*get_fw_dev_path)(DeviceState *dev); | |
bb755ba4 | 331 | |
dcc20931 | 332 | void (*reset)(BusState *bus); |
bb755ba4 PB |
333 | |
334 | /* | |
335 | * Return whether the device can be added to @bus, | |
336 | * based on the address that was set (via device properties) | |
337 | * before realize. If not, on return @errp contains the | |
338 | * human-readable error message. | |
339 | */ | |
340 | bool (*check_address)(BusState *bus, DeviceState *dev, Error **errp); | |
341 | ||
02e7f85d BD |
342 | BusRealize realize; |
343 | BusUnrealize unrealize; | |
344 | ||
1395af6f FK |
345 | /* maximum devices allowed on the bus, 0: no limit. */ |
346 | int max_dev; | |
61de3676 AG |
347 | /* number of automatically allocated bus ids (e.g. ide.0) */ |
348 | int automatic_ids; | |
074a86fc AL |
349 | }; |
350 | ||
351 | typedef struct BusChild { | |
2d24a646 | 352 | struct rcu_head rcu; |
074a86fc AL |
353 | DeviceState *child; |
354 | int index; | |
355 | QTAILQ_ENTRY(BusChild) sibling; | |
356 | } BusChild; | |
357 | ||
0ee4de6c IM |
358 | #define QDEV_HOTPLUG_HANDLER_PROPERTY "hotplug-handler" |
359 | ||
6aebb1f6 AB |
360 | typedef QTAILQ_HEAD(, BusChild) BusChildHead; |
361 | typedef QLIST_ENTRY(BusState) BusStateEntry; | |
362 | ||
074a86fc | 363 | /** |
6aebb1f6 AB |
364 | * struct BusState: |
365 | * @obj: parent object | |
366 | * @parent: parent Device | |
367 | * @name: name of bus | |
27c6ef1b | 368 | * @hotplug_handler: link to a hotplug handler associated with bus. |
6aebb1f6 AB |
369 | * @max_index: max number of child buses |
370 | * @realized: is the bus itself realized? | |
371 | * @full: is the bus full? | |
372 | * @num_children: current number of child buses | |
074a86fc AL |
373 | */ |
374 | struct BusState { | |
6aebb1f6 | 375 | /* private: */ |
074a86fc | 376 | Object obj; |
6aebb1f6 | 377 | /* public: */ |
074a86fc | 378 | DeviceState *parent; |
f73480c3 | 379 | char *name; |
0ee4de6c | 380 | HotplugHandler *hotplug_handler; |
074a86fc | 381 | int max_index; |
02e7f85d | 382 | bool realized; |
1518562b | 383 | bool full; |
12b2e9f3 | 384 | int num_children; |
2d24a646 | 385 | |
6aebb1f6 AB |
386 | /** |
387 | * @children: an RCU protected QTAILQ, thus readers must use RCU | |
388 | * to access it, and writers must hold the big qemu lock | |
389 | */ | |
390 | BusChildHead children; | |
391 | /** | |
392 | * @sibling: next bus | |
393 | */ | |
394 | BusStateEntry sibling; | |
395 | /** | |
396 | * @reset: ResettableState for the bus; handled by Resettable interface. | |
2d24a646 | 397 | */ |
c11256aa | 398 | ResettableState reset; |
074a86fc AL |
399 | }; |
400 | ||
9f9260a3 | 401 | /** |
6aebb1f6 AB |
402 | * typedef GlobalProperty - a global property type |
403 | * | |
b3ce84fe | 404 | * @used: Set to true if property was used when initializing a device. |
92fd453c DDAG |
405 | * @optional: If set to true, GlobalProperty will be skipped without errors |
406 | * if the property doesn't exist. | |
cff8b715 MAL |
407 | * |
408 | * An error is fatal for non-hotplugged devices, when the global is applied. | |
9f9260a3 | 409 | */ |
074a86fc AL |
410 | typedef struct GlobalProperty { |
411 | const char *driver; | |
412 | const char *property; | |
413 | const char *value; | |
b3ce84fe | 414 | bool used; |
92fd453c | 415 | bool optional; |
074a86fc AL |
416 | } GlobalProperty; |
417 | ||
ea9ce893 MAL |
418 | static inline void |
419 | compat_props_add(GPtrArray *arr, | |
420 | GlobalProperty props[], size_t nelem) | |
421 | { | |
422 | int i; | |
423 | for (i = 0; i < nelem; i++) { | |
424 | g_ptr_array_add(arr, (void *)&props[i]); | |
425 | } | |
426 | } | |
427 | ||
074a86fc AL |
428 | /*** Board API. This should go away once we have a machine config file. ***/ |
429 | ||
b51238e2 PM |
430 | /** |
431 | * qdev_new: Create a device on the heap | |
432 | * @name: device type to create (we assert() that this type exists) | |
433 | * | |
434 | * This only allocates the memory and initializes the device state | |
435 | * structure, ready for the caller to set properties if they wish. | |
436 | * The device still needs to be realized. | |
6aebb1f6 AB |
437 | * |
438 | * Return: a derived DeviceState object with a reference count of 1. | |
b51238e2 | 439 | */ |
9940b2cf | 440 | DeviceState *qdev_new(const char *name); |
694804ed | 441 | |
b51238e2 PM |
442 | /** |
443 | * qdev_try_new: Try to create a device on the heap | |
444 | * @name: device type to create | |
445 | * | |
446 | * This is like qdev_new(), except it returns %NULL when type @name | |
447 | * does not exist, rather than asserting. | |
6aebb1f6 AB |
448 | * |
449 | * Return: a derived DeviceState object with a reference count of 1 or | |
450 | * NULL if type @name does not exist. | |
b51238e2 | 451 | */ |
9940b2cf | 452 | DeviceState *qdev_try_new(const char *name); |
694804ed | 453 | |
26462a70 | 454 | /** |
6aebb1f6 | 455 | * qdev_is_realized() - check if device is realized |
26462a70 SH |
456 | * @dev: The device to check. |
457 | * | |
6aebb1f6 AB |
458 | * Context: May be called outside big qemu lock. |
459 | * Return: true if the device has been fully constructed, false otherwise. | |
26462a70 SH |
460 | */ |
461 | static inline bool qdev_is_realized(DeviceState *dev) | |
462 | { | |
463 | return qatomic_load_acquire(&dev->realized); | |
464 | } | |
465 | ||
b51238e2 PM |
466 | /** |
467 | * qdev_realize: Realize @dev. | |
468 | * @dev: device to realize | |
469 | * @bus: bus to plug it into (may be NULL) | |
470 | * @errp: pointer to error object | |
471 | * | |
472 | * "Realize" the device, i.e. perform the second phase of device | |
473 | * initialization. | |
474 | * @dev must not be plugged into a bus already. | |
475 | * If @bus, plug @dev into @bus. This takes a reference to @dev. | |
476 | * If @dev has no QOM parent, make one up, taking another reference. | |
b51238e2 PM |
477 | * |
478 | * If you created @dev using qdev_new(), you probably want to use | |
479 | * qdev_realize_and_unref() instead. | |
6aebb1f6 AB |
480 | * |
481 | * Return: true on success, else false setting @errp with error | |
b51238e2 | 482 | */ |
9940b2cf | 483 | bool qdev_realize(DeviceState *dev, BusState *bus, Error **errp); |
694804ed | 484 | |
b51238e2 PM |
485 | /** |
486 | * qdev_realize_and_unref: Realize @dev and drop a reference | |
487 | * @dev: device to realize | |
488 | * @bus: bus to plug it into (may be NULL) | |
489 | * @errp: pointer to error object | |
490 | * | |
491 | * Realize @dev and drop a reference. | |
492 | * This is like qdev_realize(), except the caller must hold a | |
493 | * (private) reference, which is dropped on return regardless of | |
494 | * success or failure. Intended use:: | |
495 | * | |
496 | * dev = qdev_new(); | |
497 | * [...] | |
498 | * qdev_realize_and_unref(dev, bus, errp); | |
499 | * | |
500 | * Now @dev can go away without further ado. | |
501 | * | |
502 | * If you are embedding the device into some other QOM device and | |
503 | * initialized it via some variant on object_initialize_child() then | |
504 | * do not use this function, because that family of functions arrange | |
505 | * for the only reference to the child device to be held by the parent | |
506 | * via the child<> property, and so the reference-count-drop done here | |
507 | * would be incorrect. For that use case you want qdev_realize(). | |
6aebb1f6 AB |
508 | * |
509 | * Return: true on success, else false setting @errp with error | |
b51238e2 | 510 | */ |
9940b2cf | 511 | bool qdev_realize_and_unref(DeviceState *dev, BusState *bus, Error **errp); |
694804ed | 512 | |
46ea1be1 PM |
513 | /** |
514 | * qdev_unrealize: Unrealize a device | |
515 | * @dev: device to unrealize | |
516 | * | |
517 | * This function will "unrealize" a device, which is the first phase | |
518 | * of correctly destroying a device that has been realized. It will: | |
519 | * | |
520 | * - unrealize any child buses by calling qbus_unrealize() | |
521 | * (this will recursively unrealize any devices on those buses) | |
7a21bee2 | 522 | * - call the unrealize method of @dev |
46ea1be1 PM |
523 | * |
524 | * The device can then be freed by causing its reference count to go | |
525 | * to zero. | |
526 | * | |
527 | * Warning: most devices in QEMU do not expect to be unrealized. Only | |
528 | * devices which are hot-unpluggable should be unrealized (as part of | |
529 | * the unplugging process); all other devices are expected to last for | |
530 | * the life of the simulation and should not be unrealized and freed. | |
531 | */ | |
9940b2cf | 532 | void qdev_unrealize(DeviceState *dev); |
074a86fc AL |
533 | void qdev_set_legacy_instance_id(DeviceState *dev, int alias_id, |
534 | int required_for_version); | |
14405c27 | 535 | HotplugHandler *qdev_get_bus_hotplug_handler(DeviceState *dev); |
03fcbd9d | 536 | HotplugHandler *qdev_get_machine_hotplug_handler(DeviceState *dev); |
d2321d31 | 537 | bool qdev_hotplug_allowed(DeviceState *dev, Error **errp); |
6aebb1f6 | 538 | |
17cc0128 | 539 | /** |
6aebb1f6 AB |
540 | * qdev_get_hotplug_handler() - Get handler responsible for device wiring |
541 | * @dev: the device we want the HOTPLUG_HANDLER for. | |
17cc0128 IM |
542 | * |
543 | * Note: in case @dev has a parent bus, it will be returned as handler unless | |
544 | * machine handler overrides it. | |
545 | * | |
6aebb1f6 AB |
546 | * Return: pointer to object that implements TYPE_HOTPLUG_HANDLER interface |
547 | * or NULL if there aren't any. | |
17cc0128 | 548 | */ |
c06b2ffb | 549 | HotplugHandler *qdev_get_hotplug_handler(DeviceState *dev); |
074a86fc | 550 | void qdev_unplug(DeviceState *dev, Error **errp); |
014176f9 IM |
551 | void qdev_simple_device_unplug_cb(HotplugHandler *hotplug_dev, |
552 | DeviceState *dev, Error **errp); | |
074a86fc AL |
553 | void qdev_machine_creation_done(void); |
554 | bool qdev_machine_modified(void); | |
555 | ||
217c7f01 JR |
556 | /** |
557 | * qdev_add_unplug_blocker: Add an unplug blocker to a device | |
558 | * | |
559 | * @dev: Device to be blocked from unplug | |
560 | * @reason: Reason for blocking | |
561 | */ | |
562 | void qdev_add_unplug_blocker(DeviceState *dev, Error *reason); | |
563 | ||
564 | /** | |
565 | * qdev_del_unplug_blocker: Remove an unplug blocker from a device | |
566 | * | |
567 | * @dev: Device to be unblocked | |
568 | * @reason: Pointer to the Error used with qdev_add_unplug_blocker. | |
569 | * Used as a handle to lookup the blocker for deletion. | |
570 | */ | |
571 | void qdev_del_unplug_blocker(DeviceState *dev, Error *reason); | |
572 | ||
573 | /** | |
574 | * qdev_unplug_blocked: Confirm if a device is blocked from unplug | |
575 | * | |
576 | * @dev: Device to be tested | |
6aebb1f6 | 577 | * @errp: The reasons why the device is blocked, if any |
217c7f01 | 578 | * |
6aebb1f6 AB |
579 | * Returns: true (also setting @errp) if device is blocked from unplug, |
580 | * false otherwise | |
217c7f01 JR |
581 | */ |
582 | bool qdev_unplug_blocked(DeviceState *dev, Error **errp); | |
583 | ||
ddb67f64 | 584 | /** |
6aebb1f6 | 585 | * typedef GpioPolarity - Polarity of a GPIO line |
ddb67f64 PMD |
586 | * |
587 | * GPIO lines use either positive (active-high) logic, | |
588 | * or negative (active-low) logic. | |
589 | * | |
590 | * In active-high logic (%GPIO_POLARITY_ACTIVE_HIGH), a pin is | |
591 | * active when the voltage on the pin is high (relative to ground); | |
592 | * whereas in active-low logic (%GPIO_POLARITY_ACTIVE_LOW), a pin | |
593 | * is active when the voltage on the pin is low (or grounded). | |
594 | */ | |
595 | typedef enum { | |
596 | GPIO_POLARITY_ACTIVE_LOW, | |
597 | GPIO_POLARITY_ACTIVE_HIGH | |
598 | } GpioPolarity; | |
599 | ||
cd07d7f9 PM |
600 | /** |
601 | * qdev_get_gpio_in: Get one of a device's anonymous input GPIO lines | |
602 | * @dev: Device whose GPIO we want | |
603 | * @n: Number of the anonymous GPIO line (which must be in range) | |
604 | * | |
605 | * Returns the qemu_irq corresponding to an anonymous input GPIO line | |
606 | * (which the device has set up with qdev_init_gpio_in()). The index | |
607 | * @n of the GPIO line must be valid (i.e. be at least 0 and less than | |
608 | * the total number of anonymous input GPIOs the device has); this | |
609 | * function will assert() if passed an invalid index. | |
610 | * | |
611 | * This function is intended to be used by board code or SoC "container" | |
612 | * device models to wire up the GPIO lines; usually the return value | |
613 | * will be passed to qdev_connect_gpio_out() or a similar function to | |
614 | * connect another device's output GPIO line to this input. | |
615 | * | |
616 | * For named input GPIO lines, use qdev_get_gpio_in_named(). | |
6aebb1f6 AB |
617 | * |
618 | * Return: qemu_irq corresponding to anonymous input GPIO line | |
cd07d7f9 | 619 | */ |
074a86fc | 620 | qemu_irq qdev_get_gpio_in(DeviceState *dev, int n); |
694804ed | 621 | |
cd07d7f9 PM |
622 | /** |
623 | * qdev_get_gpio_in_named: Get one of a device's named input GPIO lines | |
624 | * @dev: Device whose GPIO we want | |
625 | * @name: Name of the input GPIO array | |
626 | * @n: Number of the GPIO line in that array (which must be in range) | |
627 | * | |
628 | * Returns the qemu_irq corresponding to a named input GPIO line | |
629 | * (which the device has set up with qdev_init_gpio_in_named()). | |
630 | * The @name string must correspond to an input GPIO array which exists on | |
631 | * the device, and the index @n of the GPIO line must be valid (i.e. | |
632 | * be at least 0 and less than the total number of input GPIOs in that | |
633 | * array); this function will assert() if passed an invalid name or index. | |
634 | * | |
635 | * For anonymous input GPIO lines, use qdev_get_gpio_in(). | |
6aebb1f6 AB |
636 | * |
637 | * Return: qemu_irq corresponding to named input GPIO line | |
cd07d7f9 | 638 | */ |
a5f54290 PC |
639 | qemu_irq qdev_get_gpio_in_named(DeviceState *dev, const char *name, int n); |
640 | ||
cd07d7f9 PM |
641 | /** |
642 | * qdev_connect_gpio_out: Connect one of a device's anonymous output GPIO lines | |
643 | * @dev: Device whose GPIO to connect | |
644 | * @n: Number of the anonymous output GPIO line (which must be in range) | |
6aebb1f6 | 645 | * @pin: qemu_irq to connect the output line to |
cd07d7f9 PM |
646 | * |
647 | * This function connects an anonymous output GPIO line on a device | |
648 | * up to an arbitrary qemu_irq, so that when the device asserts that | |
649 | * output GPIO line, the qemu_irq's callback is invoked. | |
650 | * The index @n of the GPIO line must be valid (i.e. be at least 0 and | |
651 | * less than the total number of anonymous output GPIOs the device has | |
652 | * created with qdev_init_gpio_out()); otherwise this function will assert(). | |
653 | * | |
654 | * Outbound GPIO lines can be connected to any qemu_irq, but the common | |
655 | * case is connecting them to another device's inbound GPIO line, using | |
656 | * the qemu_irq returned by qdev_get_gpio_in() or qdev_get_gpio_in_named(). | |
657 | * | |
658 | * It is not valid to try to connect one outbound GPIO to multiple | |
659 | * qemu_irqs at once, or to connect multiple outbound GPIOs to the | |
660 | * same qemu_irq. (Warning: there is no assertion or other guard to | |
661 | * catch this error: the model will just not do the right thing.) | |
5df69ab8 | 662 | * Instead, for fan-out you can use the TYPE_SPLIT_IRQ device: connect |
cd07d7f9 PM |
663 | * a device's outbound GPIO to the splitter's input, and connect each |
664 | * of the splitter's outputs to a different device. For fan-in you | |
665 | * can use the TYPE_OR_IRQ device, which is a model of a logical OR | |
666 | * gate with multiple inputs and one output. | |
667 | * | |
668 | * For named output GPIO lines, use qdev_connect_gpio_out_named(). | |
669 | */ | |
074a86fc | 670 | void qdev_connect_gpio_out(DeviceState *dev, int n, qemu_irq pin); |
694804ed | 671 | |
cd07d7f9 | 672 | /** |
1fbd004b PMD |
673 | * qdev_connect_gpio_out_named: Connect one of a device's named output |
674 | * GPIO lines | |
cd07d7f9 PM |
675 | * @dev: Device whose GPIO to connect |
676 | * @name: Name of the output GPIO array | |
677 | * @n: Number of the anonymous output GPIO line (which must be in range) | |
2ebd9ce1 | 678 | * @input_pin: qemu_irq to connect the output line to |
cd07d7f9 PM |
679 | * |
680 | * This function connects an anonymous output GPIO line on a device | |
681 | * up to an arbitrary qemu_irq, so that when the device asserts that | |
682 | * output GPIO line, the qemu_irq's callback is invoked. | |
683 | * The @name string must correspond to an output GPIO array which exists on | |
684 | * the device, and the index @n of the GPIO line must be valid (i.e. | |
685 | * be at least 0 and less than the total number of input GPIOs in that | |
686 | * array); this function will assert() if passed an invalid name or index. | |
687 | * | |
688 | * Outbound GPIO lines can be connected to any qemu_irq, but the common | |
689 | * case is connecting them to another device's inbound GPIO line, using | |
690 | * the qemu_irq returned by qdev_get_gpio_in() or qdev_get_gpio_in_named(). | |
691 | * | |
692 | * It is not valid to try to connect one outbound GPIO to multiple | |
693 | * qemu_irqs at once, or to connect multiple outbound GPIOs to the | |
694 | * same qemu_irq; see qdev_connect_gpio_out() for details. | |
695 | * | |
1fbd004b | 696 | * For anonymous output GPIO lines, use qdev_connect_gpio_out(). |
cd07d7f9 | 697 | */ |
a5f54290 | 698 | void qdev_connect_gpio_out_named(DeviceState *dev, const char *name, int n, |
2ebd9ce1 | 699 | qemu_irq input_pin); |
694804ed | 700 | |
cd07d7f9 PM |
701 | /** |
702 | * qdev_get_gpio_out_connector: Get the qemu_irq connected to an output GPIO | |
703 | * @dev: Device whose output GPIO we are interested in | |
704 | * @name: Name of the output GPIO array | |
705 | * @n: Number of the output GPIO line within that array | |
706 | * | |
707 | * Returns whatever qemu_irq is currently connected to the specified | |
708 | * output GPIO line of @dev. This will be NULL if the output GPIO line | |
709 | * has never been wired up to the anything. Note that the qemu_irq | |
710 | * returned does not belong to @dev -- it will be the input GPIO or | |
711 | * IRQ of whichever device the board code has connected up to @dev's | |
712 | * output GPIO. | |
713 | * | |
714 | * You probably don't need to use this function -- it is used only | |
715 | * by the platform-bus subsystem. | |
6aebb1f6 AB |
716 | * |
717 | * Return: qemu_irq associated with GPIO or NULL if un-wired. | |
cd07d7f9 | 718 | */ |
b7973186 | 719 | qemu_irq qdev_get_gpio_out_connector(DeviceState *dev, const char *name, int n); |
694804ed | 720 | |
cd07d7f9 PM |
721 | /** |
722 | * qdev_intercept_gpio_out: Intercept an existing GPIO connection | |
723 | * @dev: Device to intercept the outbound GPIO line from | |
724 | * @icpt: New qemu_irq to connect instead | |
725 | * @name: Name of the output GPIO array | |
726 | * @n: Number of the GPIO line in the array | |
727 | * | |
6aebb1f6 AB |
728 | * .. note:: |
729 | * This function is provided only for use by the qtest testing framework | |
730 | * and is not suitable for use in non-testing parts of QEMU. | |
cd07d7f9 PM |
731 | * |
732 | * This function breaks an existing connection of an outbound GPIO | |
733 | * line from @dev, and replaces it with the new qemu_irq @icpt, as if | |
734 | * ``qdev_connect_gpio_out_named(dev, icpt, name, n)`` had been called. | |
735 | * The previously connected qemu_irq is returned, so it can be restored | |
736 | * by a second call to qdev_intercept_gpio_out() if desired. | |
6aebb1f6 AB |
737 | * |
738 | * Return: old disconnected qemu_irq if one existed | |
cd07d7f9 | 739 | */ |
0c24db2b PC |
740 | qemu_irq qdev_intercept_gpio_out(DeviceState *dev, qemu_irq icpt, |
741 | const char *name, int n); | |
074a86fc AL |
742 | |
743 | BusState *qdev_get_child_bus(DeviceState *dev, const char *name); | |
744 | ||
745 | /*** Device API. ***/ | |
746 | ||
cd07d7f9 PM |
747 | /** |
748 | * qdev_init_gpio_in: create an array of anonymous input GPIO lines | |
749 | * @dev: Device to create input GPIOs for | |
750 | * @handler: Function to call when GPIO line value is set | |
751 | * @n: Number of GPIO lines to create | |
752 | * | |
753 | * Devices should use functions in the qdev_init_gpio_in* family in | |
754 | * their instance_init or realize methods to create any input GPIO | |
755 | * lines they need. There is no functional difference between | |
756 | * anonymous and named GPIO lines. Stylistically, named GPIOs are | |
757 | * preferable (easier to understand at callsites) unless a device | |
758 | * has exactly one uniform kind of GPIO input whose purpose is obvious. | |
759 | * Note that input GPIO lines can serve as 'sinks' for IRQ lines. | |
760 | * | |
761 | * See qdev_get_gpio_in() for how code that uses such a device can get | |
762 | * hold of an input GPIO line to manipulate it. | |
763 | */ | |
074a86fc | 764 | void qdev_init_gpio_in(DeviceState *dev, qemu_irq_handler handler, int n); |
694804ed | 765 | |
cd07d7f9 PM |
766 | /** |
767 | * qdev_init_gpio_out: create an array of anonymous output GPIO lines | |
768 | * @dev: Device to create output GPIOs for | |
769 | * @pins: Pointer to qemu_irq or qemu_irq array for the GPIO lines | |
770 | * @n: Number of GPIO lines to create | |
771 | * | |
772 | * Devices should use functions in the qdev_init_gpio_out* family | |
773 | * in their instance_init or realize methods to create any output | |
774 | * GPIO lines they need. There is no functional difference between | |
775 | * anonymous and named GPIO lines. Stylistically, named GPIOs are | |
776 | * preferable (easier to understand at callsites) unless a device | |
777 | * has exactly one uniform kind of GPIO output whose purpose is obvious. | |
778 | * | |
779 | * The @pins argument should be a pointer to either a "qemu_irq" | |
780 | * (if @n == 1) or a "qemu_irq []" array (if @n > 1) in the device's | |
781 | * state structure. The device implementation can then raise and | |
782 | * lower the GPIO line by calling qemu_set_irq(). (If anything is | |
783 | * connected to the other end of the GPIO this will cause the handler | |
784 | * function for that input GPIO to be called.) | |
785 | * | |
786 | * See qdev_connect_gpio_out() for how code that uses such a device | |
787 | * can connect to one of its output GPIO lines. | |
526dc840 PMD |
788 | * |
789 | * There is no need to release the @pins allocated array because it | |
790 | * will be automatically released when @dev calls its instance_finalize() | |
791 | * handler. | |
cd07d7f9 | 792 | */ |
074a86fc | 793 | void qdev_init_gpio_out(DeviceState *dev, qemu_irq *pins, int n); |
694804ed | 794 | |
cd07d7f9 | 795 | /** |
14b0375b | 796 | * qdev_init_gpio_out_named: create an array of named output GPIO lines |
cd07d7f9 PM |
797 | * @dev: Device to create output GPIOs for |
798 | * @pins: Pointer to qemu_irq or qemu_irq array for the GPIO lines | |
799 | * @name: Name to give this array of GPIO lines | |
800 | * @n: Number of GPIO lines to create | |
801 | * | |
802 | * Like qdev_init_gpio_out(), but creates an array of GPIO output lines | |
803 | * with a name. Code using the device can then connect these GPIO lines | |
804 | * using qdev_connect_gpio_out_named(). | |
805 | */ | |
a5f54290 PC |
806 | void qdev_init_gpio_out_named(DeviceState *dev, qemu_irq *pins, |
807 | const char *name, int n); | |
694804ed | 808 | |
4a151677 | 809 | /** |
6aebb1f6 | 810 | * qdev_init_gpio_in_named_with_opaque() - create an array of input GPIO lines |
4a151677 PM |
811 | * @dev: Device to create input GPIOs for |
812 | * @handler: Function to call when GPIO line value is set | |
813 | * @opaque: Opaque data pointer to pass to @handler | |
814 | * @name: Name of the GPIO input (must be unique for this device) | |
815 | * @n: Number of GPIO lines in this input set | |
816 | */ | |
817 | void qdev_init_gpio_in_named_with_opaque(DeviceState *dev, | |
818 | qemu_irq_handler handler, | |
819 | void *opaque, | |
820 | const char *name, int n); | |
821 | ||
822 | /** | |
6aebb1f6 AB |
823 | * qdev_init_gpio_in_named() - create an array of input GPIO lines |
824 | * @dev: device to add array to | |
825 | * @handler: a &typedef qemu_irq_handler function to call when GPIO is set | |
826 | * @name: Name of the GPIO input (must be unique for this device) | |
827 | * @n: Number of GPIO lines in this input set | |
4a151677 PM |
828 | * |
829 | * Like qdev_init_gpio_in_named_with_opaque(), but the opaque pointer | |
830 | * passed to the handler is @dev (which is the most commonly desired behaviour). | |
831 | */ | |
832 | static inline void qdev_init_gpio_in_named(DeviceState *dev, | |
833 | qemu_irq_handler handler, | |
834 | const char *name, int n) | |
835 | { | |
836 | qdev_init_gpio_in_named_with_opaque(dev, handler, dev, name, n); | |
837 | } | |
074a86fc | 838 | |
cd07d7f9 PM |
839 | /** |
840 | * qdev_pass_gpios: create GPIO lines on container which pass through to device | |
841 | * @dev: Device which has GPIO lines | |
842 | * @container: Container device which needs to expose them | |
843 | * @name: Name of GPIO array to pass through (NULL for the anonymous GPIO array) | |
844 | * | |
845 | * In QEMU, complicated devices like SoCs are often modelled with a | |
846 | * "container" QOM device which itself contains other QOM devices and | |
847 | * which wires them up appropriately. This function allows the container | |
848 | * to create GPIO arrays on itself which simply pass through to a GPIO | |
849 | * array of one of its internal devices. | |
850 | * | |
851 | * If @dev has both input and output GPIOs named @name then both will | |
852 | * be passed through. It is not possible to pass a subset of the array | |
853 | * with this function. | |
854 | * | |
855 | * To users of the container device, the GPIO array created on @container | |
856 | * behaves exactly like any other. | |
857 | */ | |
17a96a14 PC |
858 | void qdev_pass_gpios(DeviceState *dev, DeviceState *container, |
859 | const char *name); | |
860 | ||
2d2f2507 | 861 | BusState *qdev_get_parent_bus(const DeviceState *dev); |
074a86fc AL |
862 | |
863 | /*** BUS API. ***/ | |
864 | ||
865 | DeviceState *qdev_find_recursive(BusState *bus, const char *id); | |
866 | ||
867 | /* Returns 0 to walk children, > 0 to skip walk, < 0 to terminate walk. */ | |
868 | typedef int (qbus_walkerfn)(BusState *bus, void *opaque); | |
869 | typedef int (qdev_walkerfn)(DeviceState *dev, void *opaque); | |
870 | ||
d637e1dc PM |
871 | void qbus_init(void *bus, size_t size, const char *typename, |
872 | DeviceState *parent, const char *name); | |
9388d170 | 873 | BusState *qbus_new(const char *typename, DeviceState *parent, const char *name); |
9940b2cf MA |
874 | bool qbus_realize(BusState *bus, Error **errp); |
875 | void qbus_unrealize(BusState *bus); | |
876 | ||
074a86fc AL |
877 | /* Returns > 0 if either devfn or busfn skip walk somewhere in cursion, |
878 | * < 0 if either devfn or busfn terminate walk somewhere in cursion, | |
879 | * 0 otherwise. */ | |
0293214b PB |
880 | int qbus_walk_children(BusState *bus, |
881 | qdev_walkerfn *pre_devfn, qbus_walkerfn *pre_busfn, | |
882 | qdev_walkerfn *post_devfn, qbus_walkerfn *post_busfn, | |
883 | void *opaque); | |
884 | int qdev_walk_children(DeviceState *dev, | |
885 | qdev_walkerfn *pre_devfn, qbus_walkerfn *pre_busfn, | |
886 | qdev_walkerfn *post_devfn, qbus_walkerfn *post_busfn, | |
887 | void *opaque); | |
888 | ||
abb89dbf | 889 | /** |
6aebb1f6 AB |
890 | * device_cold_reset() - perform a recursive cold reset on a device |
891 | * @dev: device to reset. | |
892 | * | |
abb89dbf DH |
893 | * Reset device @dev and perform a recursive processing using the resettable |
894 | * interface. It triggers a RESET_TYPE_COLD. | |
895 | */ | |
896 | void device_cold_reset(DeviceState *dev); | |
897 | ||
898 | /** | |
6aebb1f6 AB |
899 | * bus_cold_reset() - perform a recursive cold reset on a bus |
900 | * @bus: bus to reset | |
abb89dbf DH |
901 | * |
902 | * Reset bus @bus and perform a recursive processing using the resettable | |
903 | * interface. It triggers a RESET_TYPE_COLD. | |
904 | */ | |
905 | void bus_cold_reset(BusState *bus); | |
906 | ||
c11256aa | 907 | /** |
6aebb1f6 AB |
908 | * device_is_in_reset() - check device reset state |
909 | * @dev: device to check | |
910 | * | |
911 | * Return: true if the device @dev is currently being reset. | |
c11256aa DH |
912 | */ |
913 | bool device_is_in_reset(DeviceState *dev); | |
914 | ||
915 | /** | |
6aebb1f6 AB |
916 | * bus_is_in_reset() - check bus reset state |
917 | * @bus: bus to check | |
918 | * | |
919 | * Return: true if the bus @bus is currently being reset. | |
c11256aa DH |
920 | */ |
921 | bool bus_is_in_reset(BusState *bus); | |
922 | ||
074a86fc AL |
923 | /* This should go away once we get rid of the NULL bus hack */ |
924 | BusState *sysbus_get_default(void); | |
925 | ||
926 | char *qdev_get_fw_dev_path(DeviceState *dev); | |
0be63901 | 927 | char *qdev_get_own_fw_dev_path_from_handler(BusState *bus, DeviceState *dev); |
074a86fc | 928 | |
e57fc3de AB |
929 | /** |
930 | * device_class_set_props(): add a set of properties to an device | |
931 | * @dc: the parent DeviceClass all devices inherit | |
932 | * @props: an array of properties, terminate by DEFINE_PROP_END_OF_LIST() | |
933 | * | |
934 | * This will add a set of properties to the object. It will fault if | |
935 | * you attempt to add an existing property defined by a parent class. | |
936 | * To modify an inherited property you need to use???? | |
937 | */ | |
4f67d30b MAL |
938 | void device_class_set_props(DeviceClass *dc, Property *props); |
939 | ||
c11256aa | 940 | /** |
6aebb1f6 AB |
941 | * device_class_set_parent_reset() - legacy set device reset handlers |
942 | * @dc: device class | |
943 | * @dev_reset: function pointer to reset handler | |
944 | * @parent_reset: function pointer to parents reset handler | |
945 | * | |
946 | * Modern code should use the ResettableClass interface to | |
947 | * implement a multi-phase reset instead. | |
948 | * | |
c11256aa DH |
949 | * TODO: remove the function when DeviceClass's reset method |
950 | * is not used anymore. | |
951 | */ | |
46795cf2 PMD |
952 | void device_class_set_parent_reset(DeviceClass *dc, |
953 | DeviceReset dev_reset, | |
954 | DeviceReset *parent_reset); | |
c378e882 AB |
955 | |
956 | /** | |
957 | * device_class_set_parent_realize() - set up for chaining realize fns | |
958 | * @dc: The device class | |
959 | * @dev_realize: the device realize function | |
960 | * @parent_realize: somewhere to save the parents realize function | |
961 | * | |
962 | * This is intended to be used when the new realize function will | |
963 | * eventually call its parent realization function during creation. | |
964 | * This requires storing the function call somewhere (usually in the | |
965 | * instance structure) so you can eventually call | |
966 | * dc->parent_realize(dev, errp) | |
967 | */ | |
46795cf2 PMD |
968 | void device_class_set_parent_realize(DeviceClass *dc, |
969 | DeviceRealize dev_realize, | |
970 | DeviceRealize *parent_realize); | |
c378e882 AB |
971 | |
972 | ||
973 | /** | |
974 | * device_class_set_parent_unrealize() - set up for chaining unrealize fns | |
975 | * @dc: The device class | |
976 | * @dev_unrealize: the device realize function | |
977 | * @parent_unrealize: somewhere to save the parents unrealize function | |
978 | * | |
979 | * This is intended to be used when the new unrealize function will | |
980 | * eventually call its parent unrealization function during the | |
981 | * unrealize phase. This requires storing the function call somewhere | |
982 | * (usually in the instance structure) so you can eventually call | |
983 | * dc->parent_unrealize(dev); | |
984 | */ | |
46795cf2 PMD |
985 | void device_class_set_parent_unrealize(DeviceClass *dc, |
986 | DeviceUnrealize dev_unrealize, | |
987 | DeviceUnrealize *parent_unrealize); | |
988 | ||
8a9358cc | 989 | const VMStateDescription *qdev_get_vmsd(DeviceState *dev); |
074a86fc AL |
990 | |
991 | const char *qdev_fw_name(DeviceState *dev); | |
992 | ||
f66dc873 | 993 | void qdev_assert_realized_properly(void); |
074a86fc AL |
994 | Object *qdev_get_machine(void); |
995 | ||
956ef499 MP |
996 | /** |
997 | * qdev_get_human_name() - Return a human-readable name for a device | |
998 | * @dev: The device. Must be a valid and non-NULL pointer. | |
999 | * | |
1000 | * .. note:: | |
1001 | * This function is intended for user friendly error messages. | |
1002 | * | |
1003 | * Returns: A newly allocated string containing the device id if not null, | |
1004 | * else the object canonical path. | |
1005 | * | |
1006 | * Use g_free() to free it. | |
1007 | */ | |
1008 | char *qdev_get_human_name(DeviceState *dev); | |
1009 | ||
074a86fc | 1010 | /* FIXME: make this a link<> */ |
bb755ba4 | 1011 | bool qdev_set_parent_bus(DeviceState *dev, BusState *bus, Error **errp); |
074a86fc | 1012 | |
21def24a | 1013 | extern bool qdev_hot_removed; |
074a86fc AL |
1014 | |
1015 | char *qdev_get_dev_path(DeviceState *dev); | |
1016 | ||
9bc6bfdf | 1017 | void qbus_set_hotplug_handler(BusState *bus, Object *handler); |
cd7c8660 | 1018 | void qbus_set_bus_hotplug_handler(BusState *bus); |
39b888bd IM |
1019 | |
1020 | static inline bool qbus_is_hotpluggable(BusState *bus) | |
1021 | { | |
ceefa0b7 IM |
1022 | HotplugHandler *plug_handler = bus->hotplug_handler; |
1023 | bool ret = !!plug_handler; | |
1024 | ||
1025 | if (plug_handler) { | |
1026 | HotplugHandlerClass *hdc; | |
1027 | ||
1028 | hdc = HOTPLUG_HANDLER_GET_CLASS(plug_handler); | |
1029 | if (hdc->is_hotpluggable_bus) { | |
1030 | ret = hdc->is_hotpluggable_bus(plug_handler, bus); | |
1031 | } | |
1032 | } | |
1033 | return ret; | |
39b888bd | 1034 | } |
707ff800 | 1035 | |
1518562b PM |
1036 | /** |
1037 | * qbus_mark_full: Mark this bus as full, so no more devices can be attached | |
1038 | * @bus: Bus to mark as full | |
1039 | * | |
1040 | * By default, QEMU will allow devices to be plugged into a bus up | |
1041 | * to the bus class's device count limit. Calling this function | |
1042 | * marks a particular bus as full, so that no more devices can be | |
1043 | * plugged into it. In particular this means that the bus will not | |
1044 | * be considered as a candidate for plugging in devices created by | |
1045 | * the user on the commandline or via the monitor. | |
1046 | * If a machine has multiple buses of a given type, such as I2C, | |
1047 | * where some of those buses in the real hardware are used only for | |
1048 | * internal devices and some are exposed via expansion ports, you | |
1049 | * can use this function to mark the internal-only buses as full | |
1050 | * after you have created all their internal devices. Then user | |
1051 | * created devices will appear on the expansion-port bus where | |
1052 | * guest software expects them. | |
1053 | */ | |
1054 | static inline void qbus_mark_full(BusState *bus) | |
1055 | { | |
1056 | bus->full = true; | |
1057 | } | |
1058 | ||
707ff800 PD |
1059 | void device_listener_register(DeviceListener *listener); |
1060 | void device_listener_unregister(DeviceListener *listener); | |
1061 | ||
f3a85056 | 1062 | /** |
6aebb1f6 AB |
1063 | * qdev_should_hide_device() - check if device should be hidden |
1064 | * | |
f3558b1b KW |
1065 | * @opts: options QDict |
1066 | * @from_json: true if @opts entries are typed, false for all strings | |
1067 | * @errp: pointer to error object | |
f3a85056 | 1068 | * |
6aebb1f6 AB |
1069 | * When a device is added via qdev_device_add() this will be called. |
1070 | * | |
1071 | * Return: if the device should be added now or not. | |
f3a85056 | 1072 | */ |
f3558b1b | 1073 | bool qdev_should_hide_device(const QDict *opts, bool from_json, Error **errp); |
f3a85056 | 1074 | |
2f181fbd PB |
1075 | typedef enum MachineInitPhase { |
1076 | /* current_machine is NULL. */ | |
1077 | PHASE_NO_MACHINE, | |
1078 | ||
1079 | /* current_machine is not NULL, but current_machine->accel is NULL. */ | |
1080 | PHASE_MACHINE_CREATED, | |
1081 | ||
1082 | /* | |
1083 | * current_machine->accel is not NULL, but the machine properties have | |
1084 | * not been validated and machine_class->init has not yet been called. | |
1085 | */ | |
1086 | PHASE_ACCEL_CREATED, | |
1087 | ||
1088 | /* | |
1089 | * machine_class->init has been called, thus creating any embedded | |
1090 | * devices and validating machine properties. Devices created at | |
1091 | * this time are considered to be cold-plugged. | |
1092 | */ | |
1093 | PHASE_MACHINE_INITIALIZED, | |
1094 | ||
1095 | /* | |
1096 | * QEMU is ready to start CPUs and devices created at this time | |
1097 | * are considered to be hot-plugged. The monitor is not restricted | |
1098 | * to "preconfig" commands. | |
1099 | */ | |
1100 | PHASE_MACHINE_READY, | |
1101 | } MachineInitPhase; | |
1102 | ||
f703f1ef PMD |
1103 | bool phase_check(MachineInitPhase phase); |
1104 | void phase_advance(MachineInitPhase phase); | |
2f181fbd | 1105 | |
074a86fc | 1106 | #endif |