1074a86fcSAnthony Liguori #ifndef QDEV_CORE_H 2074a86fcSAnthony Liguori #define QDEV_CORE_H 3074a86fcSAnthony Liguori 41de7afc9SPaolo Bonzini #include "qemu/queue.h" 5949fc823SMarcel Apfelbaum #include "qemu/bitmap.h" 614cccb61SPaolo Bonzini #include "qom/object.h" 70ee4de6cSIgor Mammedov #include "hw/hotplug.h" 8c11256aaSDamien Hedde #include "hw/resettable.h" 9074a86fcSAnthony Liguori 10074a86fcSAnthony Liguori enum { 11074a86fcSAnthony Liguori DEV_NVECTORS_UNSPECIFIED = -1, 12074a86fcSAnthony Liguori }; 13074a86fcSAnthony Liguori 14074a86fcSAnthony Liguori #define TYPE_DEVICE "device" 15074a86fcSAnthony Liguori #define DEVICE(obj) OBJECT_CHECK(DeviceState, (obj), TYPE_DEVICE) 16074a86fcSAnthony Liguori #define DEVICE_CLASS(klass) OBJECT_CLASS_CHECK(DeviceClass, (klass), TYPE_DEVICE) 17074a86fcSAnthony Liguori #define DEVICE_GET_CLASS(obj) OBJECT_GET_CLASS(DeviceClass, (obj), TYPE_DEVICE) 18074a86fcSAnthony Liguori 193d1237fbSMarcel Apfelbaum typedef enum DeviceCategory { 203d1237fbSMarcel Apfelbaum DEVICE_CATEGORY_BRIDGE, 213d1237fbSMarcel Apfelbaum DEVICE_CATEGORY_USB, 223d1237fbSMarcel Apfelbaum DEVICE_CATEGORY_STORAGE, 233d1237fbSMarcel Apfelbaum DEVICE_CATEGORY_NETWORK, 243d1237fbSMarcel Apfelbaum DEVICE_CATEGORY_INPUT, 253d1237fbSMarcel Apfelbaum DEVICE_CATEGORY_DISPLAY, 263d1237fbSMarcel Apfelbaum DEVICE_CATEGORY_SOUND, 273d1237fbSMarcel Apfelbaum DEVICE_CATEGORY_MISC, 28ba31cc72SThomas Huth DEVICE_CATEGORY_CPU, 293d1237fbSMarcel Apfelbaum DEVICE_CATEGORY_MAX 303d1237fbSMarcel Apfelbaum } DeviceCategory; 313d1237fbSMarcel Apfelbaum 32249d4172SAndreas Färber typedef void (*DeviceRealize)(DeviceState *dev, Error **errp); 33b69c3c21SMarkus Armbruster typedef void (*DeviceUnrealize)(DeviceState *dev); 34b850f664SPhilippe Mathieu-Daudé typedef void (*DeviceReset)(DeviceState *dev); 3502e7f85dSBandan Das typedef void (*BusRealize)(BusState *bus, Error **errp); 36b69c3c21SMarkus Armbruster typedef void (*BusUnrealize)(BusState *bus); 37074a86fcSAnthony Liguori 38249d4172SAndreas Färber /** 39249d4172SAndreas Färber * DeviceClass: 40249d4172SAndreas Färber * @props: Properties accessing state fields. 41249d4172SAndreas Färber * @realize: Callback function invoked when the #DeviceState:realized 42ff46d9d4SPhilippe Mathieu-Daudé * property is changed to %true. 43249d4172SAndreas Färber * @unrealize: Callback function invoked when the #DeviceState:realized 44249d4172SAndreas Färber * property is changed to %false. 451a37eca1SIgor Mammedov * @hotpluggable: indicates if #DeviceClass is hotpluggable, available 461a37eca1SIgor Mammedov * as readonly "hotpluggable" property of #DeviceState instance 47249d4172SAndreas Färber * 48249d4172SAndreas Färber * # Realization # 49249d4172SAndreas Färber * Devices are constructed in two stages, 50249d4172SAndreas Färber * 1) object instantiation via object_initialize() and 51249d4172SAndreas Färber * 2) device realization via #DeviceState:realized property. 526038f989SThomas Huth * The former may not fail (and must not abort or exit, since it is called 536038f989SThomas Huth * during device introspection already), and the latter may return error 546038f989SThomas Huth * information to the caller and must be re-entrant. 55249d4172SAndreas Färber * Trivial field initializations should go into #TypeInfo.instance_init. 56249d4172SAndreas Färber * Operations depending on @props static properties should go into @realize. 57249d4172SAndreas Färber * After successful realization, setting static properties will fail. 58249d4172SAndreas Färber * 59daeba969SMarkus Armbruster * As an interim step, the #DeviceState:realized property can also be 60*c835fac3SMarkus Armbruster * set with qdev_realize(). 61249d4172SAndreas Färber * In the future, devices will propagate this state change to their children 62249d4172SAndreas Färber * and along busses they expose. 63249d4172SAndreas Färber * The point in time will be deferred to machine creation, so that values 64249d4172SAndreas Färber * set in @realize will not be introspectable beforehand. Therefore devices 65249d4172SAndreas Färber * must not create children during @realize; they should initialize them via 66249d4172SAndreas Färber * object_initialize() in their own #TypeInfo.instance_init and forward the 67249d4172SAndreas Färber * realization events appropriately. 68249d4172SAndreas Färber * 69249d4172SAndreas Färber * Any type may override the @realize and/or @unrealize callbacks but needs 70782beb52SAndreas Färber * to call the parent type's implementation if keeping their functionality 71782beb52SAndreas Färber * is desired. Refer to QOM documentation for further discussion and examples. 72782beb52SAndreas Färber * 73782beb52SAndreas Färber * <note> 74782beb52SAndreas Färber * <para> 75ff46d9d4SPhilippe Mathieu-Daudé * Since TYPE_DEVICE doesn't implement @realize and @unrealize, types 76ff46d9d4SPhilippe Mathieu-Daudé * derived directly from it need not call their parent's @realize and 77ff46d9d4SPhilippe Mathieu-Daudé * @unrealize. 78782beb52SAndreas Färber * For other types consult the documentation and implementation of the 79782beb52SAndreas Färber * respective parent types. 80782beb52SAndreas Färber * </para> 81782beb52SAndreas Färber * </note> 82f3a85056SJens Freimann * 83f3a85056SJens Freimann * # Hiding a device # 84f3a85056SJens Freimann * To hide a device, a DeviceListener function should_be_hidden() needs to 85f3a85056SJens Freimann * be registered. 86f3a85056SJens Freimann * It can be used to defer adding a device and therefore hide it from the 87f3a85056SJens Freimann * guest. The handler registering to this DeviceListener can save the QOpts 88f3a85056SJens Freimann * passed to it for re-using it later and must return that it wants the device 89f3a85056SJens Freimann * to be/remain hidden or not. When the handler function decides the device 90f3a85056SJens Freimann * shall not be hidden it will be added in qdev_device_add() and 91f3a85056SJens Freimann * realized as any other device. Otherwise qdev_device_add() will return early 92f3a85056SJens Freimann * without adding the device. The guest will not see a "hidden" device 93f3a85056SJens Freimann * until it was marked don't hide and qdev_device_add called again. 94f3a85056SJens Freimann * 95249d4172SAndreas Färber */ 96074a86fcSAnthony Liguori typedef struct DeviceClass { 97249d4172SAndreas Färber /*< private >*/ 98074a86fcSAnthony Liguori ObjectClass parent_class; 99249d4172SAndreas Färber /*< public >*/ 100074a86fcSAnthony Liguori 1013d1237fbSMarcel Apfelbaum DECLARE_BITMAP(categories, DEVICE_CATEGORY_MAX); 102074a86fcSAnthony Liguori const char *fw_name; 103074a86fcSAnthony Liguori const char *desc; 104385d8f22SPaolo Bonzini 105385d8f22SPaolo Bonzini /* 106385d8f22SPaolo Bonzini * The underscore at the end ensures a compile-time error if someone 107385d8f22SPaolo Bonzini * assigns to dc->props instead of using device_class_set_props. 108385d8f22SPaolo Bonzini */ 109385d8f22SPaolo Bonzini Property *props_; 110efec3dd6SMarkus Armbruster 111efec3dd6SMarkus Armbruster /* 112e90f2a8cSEduardo Habkost * Can this device be instantiated with -device / device_add? 113efec3dd6SMarkus Armbruster * All devices should support instantiation with device_add, and 114efec3dd6SMarkus Armbruster * this flag should not exist. But we're not there, yet. Some 115efec3dd6SMarkus Armbruster * devices fail to instantiate with cryptic error messages. 116efec3dd6SMarkus Armbruster * Others instantiate, but don't work. Exposing users to such 117e90f2a8cSEduardo Habkost * behavior would be cruel; clearing this flag will protect them. 118e90f2a8cSEduardo Habkost * It should never be cleared without a comment explaining why it 119e90f2a8cSEduardo Habkost * is cleared. 120efec3dd6SMarkus Armbruster * TODO remove once we're there 121efec3dd6SMarkus Armbruster */ 122e90f2a8cSEduardo Habkost bool user_creatable; 1231a37eca1SIgor Mammedov bool hotpluggable; 124074a86fcSAnthony Liguori 125074a86fcSAnthony Liguori /* callbacks */ 126c11256aaSDamien Hedde /* 127c11256aaSDamien Hedde * Reset method here is deprecated and replaced by methods in the 128c11256aaSDamien Hedde * resettable class interface to implement a multi-phase reset. 129c11256aaSDamien Hedde * TODO: remove once every reset callback is unused 130c11256aaSDamien Hedde */ 131b850f664SPhilippe Mathieu-Daudé DeviceReset reset; 132249d4172SAndreas Färber DeviceRealize realize; 133249d4172SAndreas Färber DeviceUnrealize unrealize; 134074a86fcSAnthony Liguori 135074a86fcSAnthony Liguori /* device state */ 1368a9358ccSMarkus Armbruster const VMStateDescription *vmsd; 137074a86fcSAnthony Liguori 138074a86fcSAnthony Liguori /* Private to qdev / bus. */ 139074a86fcSAnthony Liguori const char *bus_type; 140074a86fcSAnthony Liguori } DeviceClass; 141074a86fcSAnthony Liguori 142a5f54290SPeter Crosthwaite typedef struct NamedGPIOList NamedGPIOList; 143a5f54290SPeter Crosthwaite 144a5f54290SPeter Crosthwaite struct NamedGPIOList { 145a5f54290SPeter Crosthwaite char *name; 146a5f54290SPeter Crosthwaite qemu_irq *in; 147a5f54290SPeter Crosthwaite int num_in; 148a5f54290SPeter Crosthwaite int num_out; 149a5f54290SPeter Crosthwaite QLIST_ENTRY(NamedGPIOList) node; 150a5f54290SPeter Crosthwaite }; 151a5f54290SPeter Crosthwaite 1520e6934f2SDamien Hedde typedef struct Clock Clock; 1530e6934f2SDamien Hedde typedef struct NamedClockList NamedClockList; 1540e6934f2SDamien Hedde 1550e6934f2SDamien Hedde struct NamedClockList { 1560e6934f2SDamien Hedde char *name; 1570e6934f2SDamien Hedde Clock *clock; 1580e6934f2SDamien Hedde bool output; 1590e6934f2SDamien Hedde bool alias; 1600e6934f2SDamien Hedde QLIST_ENTRY(NamedClockList) node; 1610e6934f2SDamien Hedde }; 1620e6934f2SDamien Hedde 1637983c8a3SAndreas Färber /** 1647983c8a3SAndreas Färber * DeviceState: 1657983c8a3SAndreas Färber * @realized: Indicates whether the device has been fully constructed. 166c11256aaSDamien Hedde * @reset: ResettableState for the device; handled by Resettable interface. 1677983c8a3SAndreas Färber * 1687983c8a3SAndreas Färber * This structure should not be accessed directly. We declare it here 1697983c8a3SAndreas Färber * so that it can be embedded in individual device state structures. 1707983c8a3SAndreas Färber */ 171074a86fcSAnthony Liguori struct DeviceState { 1727983c8a3SAndreas Färber /*< private >*/ 173074a86fcSAnthony Liguori Object parent_obj; 1747983c8a3SAndreas Färber /*< public >*/ 175074a86fcSAnthony Liguori 176074a86fcSAnthony Liguori const char *id; 17704162f8fSMichael Roth char *canonical_path; 1787983c8a3SAndreas Färber bool realized; 179352e8da7SPaolo Bonzini bool pending_deleted_event; 180074a86fcSAnthony Liguori QemuOpts *opts; 181074a86fcSAnthony Liguori int hotplugged; 182a1190ab6SJens Freimann bool allow_unplug_during_migration; 183074a86fcSAnthony Liguori BusState *parent_bus; 184a5f54290SPeter Crosthwaite QLIST_HEAD(, NamedGPIOList) gpios; 1850e6934f2SDamien Hedde QLIST_HEAD(, NamedClockList) clocks; 186074a86fcSAnthony Liguori QLIST_HEAD(, BusState) child_bus; 187074a86fcSAnthony Liguori int num_child_bus; 188074a86fcSAnthony Liguori int instance_id_alias; 189074a86fcSAnthony Liguori int alias_required_for_version; 190c11256aaSDamien Hedde ResettableState reset; 191074a86fcSAnthony Liguori }; 192074a86fcSAnthony Liguori 193707ff800SPaul Durrant struct DeviceListener { 194707ff800SPaul Durrant void (*realize)(DeviceListener *listener, DeviceState *dev); 195707ff800SPaul Durrant void (*unrealize)(DeviceListener *listener, DeviceState *dev); 196f3a85056SJens Freimann /* 197f3a85056SJens Freimann * This callback is called upon init of the DeviceState and allows to 198f3a85056SJens Freimann * inform qdev that a device should be hidden, depending on the device 199f3a85056SJens Freimann * opts, for example, to hide a standby device. 200f3a85056SJens Freimann */ 201f3a85056SJens Freimann int (*should_be_hidden)(DeviceListener *listener, QemuOpts *device_opts); 202707ff800SPaul Durrant QTAILQ_ENTRY(DeviceListener) link; 203707ff800SPaul Durrant }; 204707ff800SPaul Durrant 205074a86fcSAnthony Liguori #define TYPE_BUS "bus" 206074a86fcSAnthony Liguori #define BUS(obj) OBJECT_CHECK(BusState, (obj), TYPE_BUS) 207074a86fcSAnthony Liguori #define BUS_CLASS(klass) OBJECT_CLASS_CHECK(BusClass, (klass), TYPE_BUS) 208074a86fcSAnthony Liguori #define BUS_GET_CLASS(obj) OBJECT_GET_CLASS(BusClass, (obj), TYPE_BUS) 209074a86fcSAnthony Liguori 210074a86fcSAnthony Liguori struct BusClass { 211074a86fcSAnthony Liguori ObjectClass parent_class; 212074a86fcSAnthony Liguori 213074a86fcSAnthony Liguori /* FIXME first arg should be BusState */ 214074a86fcSAnthony Liguori void (*print_dev)(Monitor *mon, DeviceState *dev, int indent); 215074a86fcSAnthony Liguori char *(*get_dev_path)(DeviceState *dev); 216074a86fcSAnthony Liguori /* 217074a86fcSAnthony Liguori * This callback is used to create Open Firmware device path in accordance 218074a86fcSAnthony Liguori * with OF spec http://forthworks.com/standards/of1275.pdf. Individual bus 219074a86fcSAnthony Liguori * bindings can be found at http://playground.sun.com/1275/bindings/. 220074a86fcSAnthony Liguori */ 221074a86fcSAnthony Liguori char *(*get_fw_dev_path)(DeviceState *dev); 222dcc20931SPaolo Bonzini void (*reset)(BusState *bus); 22302e7f85dSBandan Das BusRealize realize; 22402e7f85dSBandan Das BusUnrealize unrealize; 22502e7f85dSBandan Das 2261395af6fSKONRAD Frederic /* maximum devices allowed on the bus, 0: no limit. */ 2271395af6fSKONRAD Frederic int max_dev; 22861de3676SAlexander Graf /* number of automatically allocated bus ids (e.g. ide.0) */ 22961de3676SAlexander Graf int automatic_ids; 230074a86fcSAnthony Liguori }; 231074a86fcSAnthony Liguori 232074a86fcSAnthony Liguori typedef struct BusChild { 233074a86fcSAnthony Liguori DeviceState *child; 234074a86fcSAnthony Liguori int index; 235074a86fcSAnthony Liguori QTAILQ_ENTRY(BusChild) sibling; 236074a86fcSAnthony Liguori } BusChild; 237074a86fcSAnthony Liguori 2380ee4de6cSIgor Mammedov #define QDEV_HOTPLUG_HANDLER_PROPERTY "hotplug-handler" 2390ee4de6cSIgor Mammedov 240074a86fcSAnthony Liguori /** 241074a86fcSAnthony Liguori * BusState: 24227c6ef1bSLi Qiang * @hotplug_handler: link to a hotplug handler associated with bus. 243c11256aaSDamien Hedde * @reset: ResettableState for the bus; handled by Resettable interface. 244074a86fcSAnthony Liguori */ 245074a86fcSAnthony Liguori struct BusState { 246074a86fcSAnthony Liguori Object obj; 247074a86fcSAnthony Liguori DeviceState *parent; 248f73480c3SMarc-André Lureau char *name; 2490ee4de6cSIgor Mammedov HotplugHandler *hotplug_handler; 250074a86fcSAnthony Liguori int max_index; 25102e7f85dSBandan Das bool realized; 25212b2e9f3STony Krowiak int num_children; 253eae3eb3eSPaolo Bonzini QTAILQ_HEAD(, BusChild) children; 254074a86fcSAnthony Liguori QLIST_ENTRY(BusState) sibling; 255c11256aaSDamien Hedde ResettableState reset; 256074a86fcSAnthony Liguori }; 257074a86fcSAnthony Liguori 2585cc56cc6SPeter Maydell /** 2595cc56cc6SPeter Maydell * Property: 2605cc56cc6SPeter Maydell * @set_default: true if the default value should be set from @defval, 2615cc56cc6SPeter Maydell * in which case @info->set_default_value must not be NULL 2625cc56cc6SPeter Maydell * (if false then no default value is set by the property system 2635cc56cc6SPeter Maydell * and the field retains whatever value it was given by instance_init). 2645cc56cc6SPeter Maydell * @defval: default value for the property. This is used only if @set_default 2655cc56cc6SPeter Maydell * is true. 2665cc56cc6SPeter Maydell */ 267074a86fcSAnthony Liguori struct Property { 268074a86fcSAnthony Liguori const char *name; 2691b6b7d10SFam Zheng const PropertyInfo *info; 2703b6ca402SIldar Isaev ptrdiff_t offset; 271074a86fcSAnthony Liguori uint8_t bitnr; 2725cc56cc6SPeter Maydell bool set_default; 27376318657SMarc-André Lureau union { 27476318657SMarc-André Lureau int64_t i; 2753fb2111fSMarc-André Lureau uint64_t u; 27676318657SMarc-André Lureau } defval; 2770be6bfacSPeter Maydell int arrayoffset; 2781b6b7d10SFam Zheng const PropertyInfo *arrayinfo; 2790be6bfacSPeter Maydell int arrayfieldsize; 2805b4ff3c6SFam Zheng const char *link_type; 281074a86fcSAnthony Liguori }; 282074a86fcSAnthony Liguori 283074a86fcSAnthony Liguori struct PropertyInfo { 284074a86fcSAnthony Liguori const char *name; 28551b2e8c3SGonglei const char *description; 286f7abe0ecSMarc-André Lureau const QEnumLookup *enum_table; 287074a86fcSAnthony Liguori int (*print)(DeviceState *dev, Property *prop, char *dest, size_t len); 28877b06bbaSMarc-André Lureau void (*set_default_value)(ObjectProperty *op, const Property *prop); 28940c2281cSMarkus Armbruster void (*create)(ObjectClass *oc, Property *prop); 290074a86fcSAnthony Liguori ObjectPropertyAccessor *get; 291074a86fcSAnthony Liguori ObjectPropertyAccessor *set; 292074a86fcSAnthony Liguori ObjectPropertyRelease *release; 293074a86fcSAnthony Liguori }; 294074a86fcSAnthony Liguori 2959f9260a3SDon Slutz /** 2969f9260a3SDon Slutz * GlobalProperty: 297b3ce84feSEduardo Habkost * @used: Set to true if property was used when initializing a device. 29892fd453cSDr. David Alan Gilbert * @optional: If set to true, GlobalProperty will be skipped without errors 29992fd453cSDr. David Alan Gilbert * if the property doesn't exist. 300cff8b715SMarc-André Lureau * 301cff8b715SMarc-André Lureau * An error is fatal for non-hotplugged devices, when the global is applied. 3029f9260a3SDon Slutz */ 303074a86fcSAnthony Liguori typedef struct GlobalProperty { 304074a86fcSAnthony Liguori const char *driver; 305074a86fcSAnthony Liguori const char *property; 306074a86fcSAnthony Liguori const char *value; 307b3ce84feSEduardo Habkost bool used; 30892fd453cSDr. David Alan Gilbert bool optional; 309074a86fcSAnthony Liguori } GlobalProperty; 310074a86fcSAnthony Liguori 311ea9ce893SMarc-André Lureau static inline void 312ea9ce893SMarc-André Lureau compat_props_add(GPtrArray *arr, 313ea9ce893SMarc-André Lureau GlobalProperty props[], size_t nelem) 314ea9ce893SMarc-André Lureau { 315ea9ce893SMarc-André Lureau int i; 316ea9ce893SMarc-André Lureau for (i = 0; i < nelem; i++) { 317ea9ce893SMarc-André Lureau g_ptr_array_add(arr, (void *)&props[i]); 318ea9ce893SMarc-André Lureau } 319ea9ce893SMarc-André Lureau } 320ea9ce893SMarc-André Lureau 321074a86fcSAnthony Liguori /*** Board API. This should go away once we have a machine config file. ***/ 322074a86fcSAnthony Liguori 3239940b2cfSMarkus Armbruster DeviceState *qdev_new(const char *name); 3249940b2cfSMarkus Armbruster DeviceState *qdev_try_new(const char *name); 3259940b2cfSMarkus Armbruster bool qdev_realize(DeviceState *dev, BusState *bus, Error **errp); 3269940b2cfSMarkus Armbruster bool qdev_realize_and_unref(DeviceState *dev, BusState *bus, Error **errp); 3279940b2cfSMarkus Armbruster void qdev_unrealize(DeviceState *dev); 328074a86fcSAnthony Liguori void qdev_set_legacy_instance_id(DeviceState *dev, int alias_id, 329074a86fcSAnthony Liguori int required_for_version); 33014405c27SDavid Hildenbrand HotplugHandler *qdev_get_bus_hotplug_handler(DeviceState *dev); 33103fcbd9dSThomas Huth HotplugHandler *qdev_get_machine_hotplug_handler(DeviceState *dev); 332d2321d31SPeter Xu bool qdev_hotplug_allowed(DeviceState *dev, Error **errp); 33317cc0128SIgor Mammedov /** 33417cc0128SIgor Mammedov * qdev_get_hotplug_handler: Get handler responsible for device wiring 33517cc0128SIgor Mammedov * 33617cc0128SIgor Mammedov * Find HOTPLUG_HANDLER for @dev that provides [pre|un]plug callbacks for it. 33717cc0128SIgor Mammedov * 33817cc0128SIgor Mammedov * Note: in case @dev has a parent bus, it will be returned as handler unless 33917cc0128SIgor Mammedov * machine handler overrides it. 34017cc0128SIgor Mammedov * 34117cc0128SIgor Mammedov * Returns: pointer to object that implements TYPE_HOTPLUG_HANDLER interface 34217cc0128SIgor Mammedov * or NULL if there aren't any. 34317cc0128SIgor Mammedov */ 344c06b2ffbSZhu Guihua HotplugHandler *qdev_get_hotplug_handler(DeviceState *dev); 345074a86fcSAnthony Liguori void qdev_unplug(DeviceState *dev, Error **errp); 346014176f9SIgor Mammedov void qdev_simple_device_unplug_cb(HotplugHandler *hotplug_dev, 347014176f9SIgor Mammedov DeviceState *dev, Error **errp); 348074a86fcSAnthony Liguori void qdev_machine_creation_done(void); 349074a86fcSAnthony Liguori bool qdev_machine_modified(void); 350074a86fcSAnthony Liguori 351074a86fcSAnthony Liguori qemu_irq qdev_get_gpio_in(DeviceState *dev, int n); 352a5f54290SPeter Crosthwaite qemu_irq qdev_get_gpio_in_named(DeviceState *dev, const char *name, int n); 353a5f54290SPeter Crosthwaite 354074a86fcSAnthony Liguori void qdev_connect_gpio_out(DeviceState *dev, int n, qemu_irq pin); 355a5f54290SPeter Crosthwaite void qdev_connect_gpio_out_named(DeviceState *dev, const char *name, int n, 356a5f54290SPeter Crosthwaite qemu_irq pin); 357b7973186SAlexander Graf qemu_irq qdev_get_gpio_out_connector(DeviceState *dev, const char *name, int n); 3580c24db2bSPeter Crosthwaite qemu_irq qdev_intercept_gpio_out(DeviceState *dev, qemu_irq icpt, 3590c24db2bSPeter Crosthwaite const char *name, int n); 360074a86fcSAnthony Liguori 361074a86fcSAnthony Liguori BusState *qdev_get_child_bus(DeviceState *dev, const char *name); 362074a86fcSAnthony Liguori 363074a86fcSAnthony Liguori /*** Device API. ***/ 364074a86fcSAnthony Liguori 365074a86fcSAnthony Liguori /* Register device properties. */ 366074a86fcSAnthony Liguori /* GPIO inputs also double as IRQ sinks. */ 367074a86fcSAnthony Liguori void qdev_init_gpio_in(DeviceState *dev, qemu_irq_handler handler, int n); 368074a86fcSAnthony Liguori void qdev_init_gpio_out(DeviceState *dev, qemu_irq *pins, int n); 369a5f54290SPeter Crosthwaite void qdev_init_gpio_out_named(DeviceState *dev, qemu_irq *pins, 370a5f54290SPeter Crosthwaite const char *name, int n); 3714a151677SPeter Maydell /** 3724a151677SPeter Maydell * qdev_init_gpio_in_named_with_opaque: create an array of input GPIO lines 3734a151677SPeter Maydell * for the specified device 3744a151677SPeter Maydell * 3754a151677SPeter Maydell * @dev: Device to create input GPIOs for 3764a151677SPeter Maydell * @handler: Function to call when GPIO line value is set 3774a151677SPeter Maydell * @opaque: Opaque data pointer to pass to @handler 3784a151677SPeter Maydell * @name: Name of the GPIO input (must be unique for this device) 3794a151677SPeter Maydell * @n: Number of GPIO lines in this input set 3804a151677SPeter Maydell */ 3814a151677SPeter Maydell void qdev_init_gpio_in_named_with_opaque(DeviceState *dev, 3824a151677SPeter Maydell qemu_irq_handler handler, 3834a151677SPeter Maydell void *opaque, 3844a151677SPeter Maydell const char *name, int n); 3854a151677SPeter Maydell 3864a151677SPeter Maydell /** 3874a151677SPeter Maydell * qdev_init_gpio_in_named: create an array of input GPIO lines 3884a151677SPeter Maydell * for the specified device 3894a151677SPeter Maydell * 3904a151677SPeter Maydell * Like qdev_init_gpio_in_named_with_opaque(), but the opaque pointer 3914a151677SPeter Maydell * passed to the handler is @dev (which is the most commonly desired behaviour). 3924a151677SPeter Maydell */ 3934a151677SPeter Maydell static inline void qdev_init_gpio_in_named(DeviceState *dev, 3944a151677SPeter Maydell qemu_irq_handler handler, 3954a151677SPeter Maydell const char *name, int n) 3964a151677SPeter Maydell { 3974a151677SPeter Maydell qdev_init_gpio_in_named_with_opaque(dev, handler, dev, name, n); 3984a151677SPeter Maydell } 399074a86fcSAnthony Liguori 40017a96a14SPeter Crosthwaite void qdev_pass_gpios(DeviceState *dev, DeviceState *container, 40117a96a14SPeter Crosthwaite const char *name); 40217a96a14SPeter Crosthwaite 403074a86fcSAnthony Liguori BusState *qdev_get_parent_bus(DeviceState *dev); 404074a86fcSAnthony Liguori 405074a86fcSAnthony Liguori /*** BUS API. ***/ 406074a86fcSAnthony Liguori 407074a86fcSAnthony Liguori DeviceState *qdev_find_recursive(BusState *bus, const char *id); 408074a86fcSAnthony Liguori 409074a86fcSAnthony Liguori /* Returns 0 to walk children, > 0 to skip walk, < 0 to terminate walk. */ 410074a86fcSAnthony Liguori typedef int (qbus_walkerfn)(BusState *bus, void *opaque); 411074a86fcSAnthony Liguori typedef int (qdev_walkerfn)(DeviceState *dev, void *opaque); 412074a86fcSAnthony Liguori 413fb17dfe0SAndreas Färber void qbus_create_inplace(void *bus, size_t size, const char *typename, 414074a86fcSAnthony Liguori DeviceState *parent, const char *name); 415074a86fcSAnthony Liguori BusState *qbus_create(const char *typename, DeviceState *parent, const char *name); 4169940b2cfSMarkus Armbruster bool qbus_realize(BusState *bus, Error **errp); 4179940b2cfSMarkus Armbruster void qbus_unrealize(BusState *bus); 4189940b2cfSMarkus Armbruster 419074a86fcSAnthony Liguori /* Returns > 0 if either devfn or busfn skip walk somewhere in cursion, 420074a86fcSAnthony Liguori * < 0 if either devfn or busfn terminate walk somewhere in cursion, 421074a86fcSAnthony Liguori * 0 otherwise. */ 4220293214bSPaolo Bonzini int qbus_walk_children(BusState *bus, 4230293214bSPaolo Bonzini qdev_walkerfn *pre_devfn, qbus_walkerfn *pre_busfn, 4240293214bSPaolo Bonzini qdev_walkerfn *post_devfn, qbus_walkerfn *post_busfn, 4250293214bSPaolo Bonzini void *opaque); 4260293214bSPaolo Bonzini int qdev_walk_children(DeviceState *dev, 4270293214bSPaolo Bonzini qdev_walkerfn *pre_devfn, qbus_walkerfn *pre_busfn, 4280293214bSPaolo Bonzini qdev_walkerfn *post_devfn, qbus_walkerfn *post_busfn, 4290293214bSPaolo Bonzini void *opaque); 4300293214bSPaolo Bonzini 431abb89dbfSDamien Hedde /** 432abb89dbfSDamien Hedde * @qdev_reset_all: 433abb89dbfSDamien Hedde * Reset @dev. See @qbus_reset_all() for more details. 434abb89dbfSDamien Hedde * 435abb89dbfSDamien Hedde * Note: This function is deprecated and will be removed when it becomes unused. 436abb89dbfSDamien Hedde * Please use device_cold_reset() now. 437abb89dbfSDamien Hedde */ 438074a86fcSAnthony Liguori void qdev_reset_all(DeviceState *dev); 439ff8de075SDavid Hildenbrand void qdev_reset_all_fn(void *opaque); 440d0508c36SPaolo Bonzini 441d0508c36SPaolo Bonzini /** 442d0508c36SPaolo Bonzini * @qbus_reset_all: 443d0508c36SPaolo Bonzini * @bus: Bus to be reset. 444d0508c36SPaolo Bonzini * 445d0508c36SPaolo Bonzini * Reset @bus and perform a bus-level ("hard") reset of all devices connected 446d0508c36SPaolo Bonzini * to it, including recursive processing of all buses below @bus itself. A 447d0508c36SPaolo Bonzini * hard reset means that qbus_reset_all will reset all state of the device. 448d0508c36SPaolo Bonzini * For PCI devices, for example, this will include the base address registers 449d0508c36SPaolo Bonzini * or configuration space. 450abb89dbfSDamien Hedde * 451abb89dbfSDamien Hedde * Note: This function is deprecated and will be removed when it becomes unused. 452abb89dbfSDamien Hedde * Please use bus_cold_reset() now. 453d0508c36SPaolo Bonzini */ 454d0508c36SPaolo Bonzini void qbus_reset_all(BusState *bus); 455074a86fcSAnthony Liguori void qbus_reset_all_fn(void *opaque); 456074a86fcSAnthony Liguori 457c11256aaSDamien Hedde /** 458abb89dbfSDamien Hedde * device_cold_reset: 459abb89dbfSDamien Hedde * Reset device @dev and perform a recursive processing using the resettable 460abb89dbfSDamien Hedde * interface. It triggers a RESET_TYPE_COLD. 461abb89dbfSDamien Hedde */ 462abb89dbfSDamien Hedde void device_cold_reset(DeviceState *dev); 463abb89dbfSDamien Hedde 464abb89dbfSDamien Hedde /** 465abb89dbfSDamien Hedde * bus_cold_reset: 466abb89dbfSDamien Hedde * 467abb89dbfSDamien Hedde * Reset bus @bus and perform a recursive processing using the resettable 468abb89dbfSDamien Hedde * interface. It triggers a RESET_TYPE_COLD. 469abb89dbfSDamien Hedde */ 470abb89dbfSDamien Hedde void bus_cold_reset(BusState *bus); 471abb89dbfSDamien Hedde 472abb89dbfSDamien Hedde /** 473c11256aaSDamien Hedde * device_is_in_reset: 474c11256aaSDamien Hedde * Return true if the device @dev is currently being reset. 475c11256aaSDamien Hedde */ 476c11256aaSDamien Hedde bool device_is_in_reset(DeviceState *dev); 477c11256aaSDamien Hedde 478c11256aaSDamien Hedde /** 479c11256aaSDamien Hedde * bus_is_in_reset: 480c11256aaSDamien Hedde * Return true if the bus @bus is currently being reset. 481c11256aaSDamien Hedde */ 482c11256aaSDamien Hedde bool bus_is_in_reset(BusState *bus); 483c11256aaSDamien Hedde 484074a86fcSAnthony Liguori /* This should go away once we get rid of the NULL bus hack */ 485074a86fcSAnthony Liguori BusState *sysbus_get_default(void); 486074a86fcSAnthony Liguori 487074a86fcSAnthony Liguori char *qdev_get_fw_dev_path(DeviceState *dev); 4880be63901SGonglei char *qdev_get_own_fw_dev_path_from_handler(BusState *bus, DeviceState *dev); 489074a86fcSAnthony Liguori 490074a86fcSAnthony Liguori /** 491074a86fcSAnthony Liguori * @qdev_machine_init 492074a86fcSAnthony Liguori * 493074a86fcSAnthony Liguori * Initialize platform devices before machine init. This is a hack until full 494074a86fcSAnthony Liguori * support for composition is added. 495074a86fcSAnthony Liguori */ 496074a86fcSAnthony Liguori void qdev_machine_init(void); 497074a86fcSAnthony Liguori 498074a86fcSAnthony Liguori /** 499f703a04cSDamien Hedde * device_legacy_reset: 500074a86fcSAnthony Liguori * 501074a86fcSAnthony Liguori * Reset a single device (by calling the reset method). 502abb89dbfSDamien Hedde * Note: This function is deprecated and will be removed when it becomes unused. 503abb89dbfSDamien Hedde * Please use device_cold_reset() now. 504074a86fcSAnthony Liguori */ 505f703a04cSDamien Hedde void device_legacy_reset(DeviceState *dev); 506074a86fcSAnthony Liguori 5074f67d30bSMarc-André Lureau void device_class_set_props(DeviceClass *dc, Property *props); 5084f67d30bSMarc-André Lureau 509c11256aaSDamien Hedde /** 510c11256aaSDamien Hedde * device_class_set_parent_reset: 511c11256aaSDamien Hedde * TODO: remove the function when DeviceClass's reset method 512c11256aaSDamien Hedde * is not used anymore. 513c11256aaSDamien Hedde */ 51446795cf2SPhilippe Mathieu-Daudé void device_class_set_parent_reset(DeviceClass *dc, 51546795cf2SPhilippe Mathieu-Daudé DeviceReset dev_reset, 51646795cf2SPhilippe Mathieu-Daudé DeviceReset *parent_reset); 51746795cf2SPhilippe Mathieu-Daudé void device_class_set_parent_realize(DeviceClass *dc, 51846795cf2SPhilippe Mathieu-Daudé DeviceRealize dev_realize, 51946795cf2SPhilippe Mathieu-Daudé DeviceRealize *parent_realize); 52046795cf2SPhilippe Mathieu-Daudé void device_class_set_parent_unrealize(DeviceClass *dc, 52146795cf2SPhilippe Mathieu-Daudé DeviceUnrealize dev_unrealize, 52246795cf2SPhilippe Mathieu-Daudé DeviceUnrealize *parent_unrealize); 52346795cf2SPhilippe Mathieu-Daudé 5248a9358ccSMarkus Armbruster const VMStateDescription *qdev_get_vmsd(DeviceState *dev); 525074a86fcSAnthony Liguori 526074a86fcSAnthony Liguori const char *qdev_fw_name(DeviceState *dev); 527074a86fcSAnthony Liguori 528074a86fcSAnthony Liguori Object *qdev_get_machine(void); 529074a86fcSAnthony Liguori 530074a86fcSAnthony Liguori /* FIXME: make this a link<> */ 531074a86fcSAnthony Liguori void qdev_set_parent_bus(DeviceState *dev, BusState *bus); 532074a86fcSAnthony Liguori 5339bed84c1SJuan Quintela extern bool qdev_hotplug; 53421def24aSJuan Quintela extern bool qdev_hot_removed; 535074a86fcSAnthony Liguori 536074a86fcSAnthony Liguori char *qdev_get_dev_path(DeviceState *dev); 537074a86fcSAnthony Liguori 53894d1cc5fSMichael Roth void qbus_set_hotplug_handler(BusState *bus, Object *handler, Error **errp); 539431bbb26SIgor Mammedov 540431bbb26SIgor Mammedov void qbus_set_bus_hotplug_handler(BusState *bus, Error **errp); 54139b888bdSIgor Mammedov 54239b888bdSIgor Mammedov static inline bool qbus_is_hotpluggable(BusState *bus) 54339b888bdSIgor Mammedov { 5442d9a982fSIgor Mammedov return bus->hotplug_handler; 54539b888bdSIgor Mammedov } 546707ff800SPaul Durrant 547707ff800SPaul Durrant void device_listener_register(DeviceListener *listener); 548707ff800SPaul Durrant void device_listener_unregister(DeviceListener *listener); 549707ff800SPaul Durrant 550f3a85056SJens Freimann /** 551f3a85056SJens Freimann * @qdev_should_hide_device: 552f3a85056SJens Freimann * @opts: QemuOpts as passed on cmdline. 553f3a85056SJens Freimann * 554f3a85056SJens Freimann * Check if a device should be added. 555f3a85056SJens Freimann * When a device is added via qdev_device_add() this will be called, 556f3a85056SJens Freimann * and return if the device should be added now or not. 557f3a85056SJens Freimann */ 558f3a85056SJens Freimann bool qdev_should_hide_device(QemuOpts *opts); 559f3a85056SJens Freimann 560074a86fcSAnthony Liguori #endif 561