Anthony Liguori | 074a86f | 2012-08-10 12:00:43 -0500 | [diff] [blame] | 1 | #ifndef QDEV_CORE_H |
| 2 | #define QDEV_CORE_H |
| 3 | |
Paolo Bonzini | 1de7afc | 2012-12-17 18:20:00 +0100 | [diff] [blame] | 4 | #include "qemu/queue.h" |
| 5 | #include "qemu/option.h" |
Marcel Apfelbaum | 949fc82 | 2013-07-29 17:17:43 +0300 | [diff] [blame] | 6 | #include "qemu/bitmap.h" |
Paolo Bonzini | 14cccb6 | 2012-12-17 18:19:50 +0100 | [diff] [blame] | 7 | #include "qom/object.h" |
Anthony Liguori | 074a86f | 2012-08-10 12:00:43 -0500 | [diff] [blame] | 8 | #include "hw/irq.h" |
Igor Mammedov | 0ee4de6 | 2014-02-05 16:36:45 +0100 | [diff] [blame] | 9 | #include "hw/hotplug.h" |
Anthony Liguori | 074a86f | 2012-08-10 12:00:43 -0500 | [diff] [blame] | 10 | |
Anthony Liguori | 074a86f | 2012-08-10 12:00:43 -0500 | [diff] [blame] | 11 | enum { |
| 12 | DEV_NVECTORS_UNSPECIFIED = -1, |
| 13 | }; |
| 14 | |
| 15 | #define TYPE_DEVICE "device" |
| 16 | #define DEVICE(obj) OBJECT_CHECK(DeviceState, (obj), TYPE_DEVICE) |
| 17 | #define DEVICE_CLASS(klass) OBJECT_CLASS_CHECK(DeviceClass, (klass), TYPE_DEVICE) |
| 18 | #define DEVICE_GET_CLASS(obj) OBJECT_GET_CLASS(DeviceClass, (obj), TYPE_DEVICE) |
| 19 | |
Marcel Apfelbaum | 3d1237f | 2013-07-29 17:17:44 +0300 | [diff] [blame] | 20 | typedef enum DeviceCategory { |
| 21 | DEVICE_CATEGORY_BRIDGE, |
| 22 | DEVICE_CATEGORY_USB, |
| 23 | DEVICE_CATEGORY_STORAGE, |
| 24 | DEVICE_CATEGORY_NETWORK, |
| 25 | DEVICE_CATEGORY_INPUT, |
| 26 | DEVICE_CATEGORY_DISPLAY, |
| 27 | DEVICE_CATEGORY_SOUND, |
| 28 | DEVICE_CATEGORY_MISC, |
Thomas Huth | ba31cc7 | 2017-01-20 14:01:16 +0100 | [diff] [blame] | 29 | DEVICE_CATEGORY_CPU, |
Marcel Apfelbaum | 3d1237f | 2013-07-29 17:17:44 +0300 | [diff] [blame] | 30 | DEVICE_CATEGORY_MAX |
| 31 | } DeviceCategory; |
| 32 | |
Anthony Liguori | 074a86f | 2012-08-10 12:00:43 -0500 | [diff] [blame] | 33 | typedef int (*qdev_initfn)(DeviceState *dev); |
| 34 | typedef int (*qdev_event)(DeviceState *dev); |
| 35 | typedef void (*qdev_resetfn)(DeviceState *dev); |
Andreas Färber | 249d417 | 2013-01-09 03:58:11 +0100 | [diff] [blame] | 36 | typedef void (*DeviceRealize)(DeviceState *dev, Error **errp); |
| 37 | typedef void (*DeviceUnrealize)(DeviceState *dev, Error **errp); |
Bandan Das | 02e7f85 | 2013-11-25 17:48:40 -0500 | [diff] [blame] | 38 | typedef void (*BusRealize)(BusState *bus, Error **errp); |
| 39 | typedef void (*BusUnrealize)(BusState *bus, Error **errp); |
Anthony Liguori | 074a86f | 2012-08-10 12:00:43 -0500 | [diff] [blame] | 40 | |
| 41 | struct VMStateDescription; |
| 42 | |
Andreas Färber | 249d417 | 2013-01-09 03:58:11 +0100 | [diff] [blame] | 43 | /** |
| 44 | * DeviceClass: |
| 45 | * @props: Properties accessing state fields. |
| 46 | * @realize: Callback function invoked when the #DeviceState:realized |
| 47 | * property is changed to %true. The default invokes @init if not %NULL. |
| 48 | * @unrealize: Callback function invoked when the #DeviceState:realized |
| 49 | * property is changed to %false. |
| 50 | * @init: Callback function invoked when the #DeviceState::realized property |
| 51 | * is changed to %true. Deprecated, new types inheriting directly from |
| 52 | * TYPE_DEVICE should use @realize instead, new leaf types should consult |
| 53 | * their respective parent type. |
Igor Mammedov | 1a37eca | 2014-02-05 16:36:46 +0100 | [diff] [blame] | 54 | * @hotpluggable: indicates if #DeviceClass is hotpluggable, available |
| 55 | * as readonly "hotpluggable" property of #DeviceState instance |
Andreas Färber | 249d417 | 2013-01-09 03:58:11 +0100 | [diff] [blame] | 56 | * |
| 57 | * # Realization # |
| 58 | * Devices are constructed in two stages, |
| 59 | * 1) object instantiation via object_initialize() and |
| 60 | * 2) device realization via #DeviceState:realized property. |
| 61 | * The former may not fail (it might assert or exit), the latter may return |
| 62 | * error information to the caller and must be re-entrant. |
| 63 | * Trivial field initializations should go into #TypeInfo.instance_init. |
| 64 | * Operations depending on @props static properties should go into @realize. |
| 65 | * After successful realization, setting static properties will fail. |
| 66 | * |
Markus Armbruster | daeba96 | 2015-06-19 16:17:23 +0200 | [diff] [blame] | 67 | * As an interim step, the #DeviceState:realized property can also be |
| 68 | * set with qdev_init_nofail(). |
Andreas Färber | 249d417 | 2013-01-09 03:58:11 +0100 | [diff] [blame] | 69 | * In the future, devices will propagate this state change to their children |
| 70 | * and along busses they expose. |
| 71 | * The point in time will be deferred to machine creation, so that values |
| 72 | * set in @realize will not be introspectable beforehand. Therefore devices |
| 73 | * must not create children during @realize; they should initialize them via |
| 74 | * object_initialize() in their own #TypeInfo.instance_init and forward the |
| 75 | * realization events appropriately. |
| 76 | * |
| 77 | * The @init callback is considered private to a particular bus implementation |
| 78 | * (immediate abstract child types of TYPE_DEVICE). Derived leaf types set an |
| 79 | * "init" callback on their parent class instead. |
Andreas Färber | 782beb5 | 2013-01-17 08:31:50 +0100 | [diff] [blame] | 80 | * |
Andreas Färber | 249d417 | 2013-01-09 03:58:11 +0100 | [diff] [blame] | 81 | * Any type may override the @realize and/or @unrealize callbacks but needs |
Andreas Färber | 782beb5 | 2013-01-17 08:31:50 +0100 | [diff] [blame] | 82 | * to call the parent type's implementation if keeping their functionality |
| 83 | * is desired. Refer to QOM documentation for further discussion and examples. |
| 84 | * |
| 85 | * <note> |
| 86 | * <para> |
Andreas Färber | 249d417 | 2013-01-09 03:58:11 +0100 | [diff] [blame] | 87 | * If a type derived directly from TYPE_DEVICE implements @realize, it does |
| 88 | * not need to implement @init and therefore does not need to store and call |
| 89 | * #DeviceClass' default @realize callback. |
Andreas Färber | 782beb5 | 2013-01-17 08:31:50 +0100 | [diff] [blame] | 90 | * For other types consult the documentation and implementation of the |
| 91 | * respective parent types. |
| 92 | * </para> |
| 93 | * </note> |
Andreas Färber | 249d417 | 2013-01-09 03:58:11 +0100 | [diff] [blame] | 94 | */ |
Anthony Liguori | 074a86f | 2012-08-10 12:00:43 -0500 | [diff] [blame] | 95 | typedef struct DeviceClass { |
Andreas Färber | 249d417 | 2013-01-09 03:58:11 +0100 | [diff] [blame] | 96 | /*< private >*/ |
Anthony Liguori | 074a86f | 2012-08-10 12:00:43 -0500 | [diff] [blame] | 97 | ObjectClass parent_class; |
Andreas Färber | 249d417 | 2013-01-09 03:58:11 +0100 | [diff] [blame] | 98 | /*< public >*/ |
Anthony Liguori | 074a86f | 2012-08-10 12:00:43 -0500 | [diff] [blame] | 99 | |
Marcel Apfelbaum | 3d1237f | 2013-07-29 17:17:44 +0300 | [diff] [blame] | 100 | DECLARE_BITMAP(categories, DEVICE_CATEGORY_MAX); |
Anthony Liguori | 074a86f | 2012-08-10 12:00:43 -0500 | [diff] [blame] | 101 | const char *fw_name; |
| 102 | const char *desc; |
| 103 | Property *props; |
Markus Armbruster | efec3dd | 2013-11-28 17:26:54 +0100 | [diff] [blame] | 104 | |
| 105 | /* |
Eduardo Habkost | e90f2a8 | 2017-05-03 17:35:44 -0300 | [diff] [blame] | 106 | * Can this device be instantiated with -device / device_add? |
Markus Armbruster | efec3dd | 2013-11-28 17:26:54 +0100 | [diff] [blame] | 107 | * All devices should support instantiation with device_add, and |
| 108 | * this flag should not exist. But we're not there, yet. Some |
| 109 | * devices fail to instantiate with cryptic error messages. |
| 110 | * Others instantiate, but don't work. Exposing users to such |
Eduardo Habkost | e90f2a8 | 2017-05-03 17:35:44 -0300 | [diff] [blame] | 111 | * behavior would be cruel; clearing this flag will protect them. |
| 112 | * It should never be cleared without a comment explaining why it |
| 113 | * is cleared. |
Markus Armbruster | efec3dd | 2013-11-28 17:26:54 +0100 | [diff] [blame] | 114 | * TODO remove once we're there |
| 115 | */ |
Eduardo Habkost | e90f2a8 | 2017-05-03 17:35:44 -0300 | [diff] [blame] | 116 | bool user_creatable; |
Igor Mammedov | 1a37eca | 2014-02-05 16:36:46 +0100 | [diff] [blame] | 117 | bool hotpluggable; |
Anthony Liguori | 074a86f | 2012-08-10 12:00:43 -0500 | [diff] [blame] | 118 | |
| 119 | /* callbacks */ |
| 120 | void (*reset)(DeviceState *dev); |
Andreas Färber | 249d417 | 2013-01-09 03:58:11 +0100 | [diff] [blame] | 121 | DeviceRealize realize; |
| 122 | DeviceUnrealize unrealize; |
Anthony Liguori | 074a86f | 2012-08-10 12:00:43 -0500 | [diff] [blame] | 123 | |
| 124 | /* device state */ |
| 125 | const struct VMStateDescription *vmsd; |
| 126 | |
| 127 | /* Private to qdev / bus. */ |
Andreas Färber | 249d417 | 2013-01-09 03:58:11 +0100 | [diff] [blame] | 128 | qdev_initfn init; /* TODO remove, once users are converted to realize */ |
Andreas Färber | fe6c211 | 2013-04-15 18:34:10 +0200 | [diff] [blame] | 129 | qdev_event exit; /* TODO remove, once users are converted to unrealize */ |
Anthony Liguori | 074a86f | 2012-08-10 12:00:43 -0500 | [diff] [blame] | 130 | const char *bus_type; |
| 131 | } DeviceClass; |
| 132 | |
Peter Crosthwaite | a5f5429 | 2014-05-19 23:30:58 -0700 | [diff] [blame] | 133 | typedef struct NamedGPIOList NamedGPIOList; |
| 134 | |
| 135 | struct NamedGPIOList { |
| 136 | char *name; |
| 137 | qemu_irq *in; |
| 138 | int num_in; |
Peter Crosthwaite | a5f5429 | 2014-05-19 23:30:58 -0700 | [diff] [blame] | 139 | int num_out; |
| 140 | QLIST_ENTRY(NamedGPIOList) node; |
| 141 | }; |
| 142 | |
Andreas Färber | 7983c8a | 2013-01-09 03:58:10 +0100 | [diff] [blame] | 143 | /** |
| 144 | * DeviceState: |
| 145 | * @realized: Indicates whether the device has been fully constructed. |
| 146 | * |
| 147 | * This structure should not be accessed directly. We declare it here |
| 148 | * so that it can be embedded in individual device state structures. |
| 149 | */ |
Anthony Liguori | 074a86f | 2012-08-10 12:00:43 -0500 | [diff] [blame] | 150 | struct DeviceState { |
Andreas Färber | 7983c8a | 2013-01-09 03:58:10 +0100 | [diff] [blame] | 151 | /*< private >*/ |
Anthony Liguori | 074a86f | 2012-08-10 12:00:43 -0500 | [diff] [blame] | 152 | Object parent_obj; |
Andreas Färber | 7983c8a | 2013-01-09 03:58:10 +0100 | [diff] [blame] | 153 | /*< public >*/ |
Anthony Liguori | 074a86f | 2012-08-10 12:00:43 -0500 | [diff] [blame] | 154 | |
| 155 | const char *id; |
Michael Roth | 04162f8 | 2017-10-16 17:23:13 -0500 | [diff] [blame] | 156 | char *canonical_path; |
Andreas Färber | 7983c8a | 2013-01-09 03:58:10 +0100 | [diff] [blame] | 157 | bool realized; |
Paolo Bonzini | 352e8da | 2014-06-26 15:10:03 +0200 | [diff] [blame] | 158 | bool pending_deleted_event; |
Anthony Liguori | 074a86f | 2012-08-10 12:00:43 -0500 | [diff] [blame] | 159 | QemuOpts *opts; |
| 160 | int hotplugged; |
| 161 | BusState *parent_bus; |
Peter Crosthwaite | a5f5429 | 2014-05-19 23:30:58 -0700 | [diff] [blame] | 162 | QLIST_HEAD(, NamedGPIOList) gpios; |
Anthony Liguori | 074a86f | 2012-08-10 12:00:43 -0500 | [diff] [blame] | 163 | QLIST_HEAD(, BusState) child_bus; |
| 164 | int num_child_bus; |
| 165 | int instance_id_alias; |
| 166 | int alias_required_for_version; |
| 167 | }; |
| 168 | |
Paul Durrant | 707ff80 | 2015-01-20 11:05:07 +0000 | [diff] [blame] | 169 | struct DeviceListener { |
| 170 | void (*realize)(DeviceListener *listener, DeviceState *dev); |
| 171 | void (*unrealize)(DeviceListener *listener, DeviceState *dev); |
| 172 | QTAILQ_ENTRY(DeviceListener) link; |
| 173 | }; |
| 174 | |
Anthony Liguori | 074a86f | 2012-08-10 12:00:43 -0500 | [diff] [blame] | 175 | #define TYPE_BUS "bus" |
| 176 | #define BUS(obj) OBJECT_CHECK(BusState, (obj), TYPE_BUS) |
| 177 | #define BUS_CLASS(klass) OBJECT_CLASS_CHECK(BusClass, (klass), TYPE_BUS) |
| 178 | #define BUS_GET_CLASS(obj) OBJECT_GET_CLASS(BusClass, (obj), TYPE_BUS) |
| 179 | |
| 180 | struct BusClass { |
| 181 | ObjectClass parent_class; |
| 182 | |
| 183 | /* FIXME first arg should be BusState */ |
| 184 | void (*print_dev)(Monitor *mon, DeviceState *dev, int indent); |
| 185 | char *(*get_dev_path)(DeviceState *dev); |
| 186 | /* |
| 187 | * This callback is used to create Open Firmware device path in accordance |
| 188 | * with OF spec http://forthworks.com/standards/of1275.pdf. Individual bus |
| 189 | * bindings can be found at http://playground.sun.com/1275/bindings/. |
| 190 | */ |
| 191 | char *(*get_fw_dev_path)(DeviceState *dev); |
Paolo Bonzini | dcc2093 | 2013-12-06 17:54:27 +0100 | [diff] [blame] | 192 | void (*reset)(BusState *bus); |
Bandan Das | 02e7f85 | 2013-11-25 17:48:40 -0500 | [diff] [blame] | 193 | BusRealize realize; |
| 194 | BusUnrealize unrealize; |
| 195 | |
KONRAD Frederic | 1395af6 | 2013-01-15 00:08:00 +0100 | [diff] [blame] | 196 | /* maximum devices allowed on the bus, 0: no limit. */ |
| 197 | int max_dev; |
Alexander Graf | 61de367 | 2014-02-06 16:08:15 +0100 | [diff] [blame] | 198 | /* number of automatically allocated bus ids (e.g. ide.0) */ |
| 199 | int automatic_ids; |
Anthony Liguori | 074a86f | 2012-08-10 12:00:43 -0500 | [diff] [blame] | 200 | }; |
| 201 | |
| 202 | typedef struct BusChild { |
| 203 | DeviceState *child; |
| 204 | int index; |
| 205 | QTAILQ_ENTRY(BusChild) sibling; |
| 206 | } BusChild; |
| 207 | |
Igor Mammedov | 0ee4de6 | 2014-02-05 16:36:45 +0100 | [diff] [blame] | 208 | #define QDEV_HOTPLUG_HANDLER_PROPERTY "hotplug-handler" |
| 209 | |
Anthony Liguori | 074a86f | 2012-08-10 12:00:43 -0500 | [diff] [blame] | 210 | /** |
| 211 | * BusState: |
Igor Mammedov | 0ee4de6 | 2014-02-05 16:36:45 +0100 | [diff] [blame] | 212 | * @hotplug_device: link to a hotplug device associated with bus. |
Anthony Liguori | 074a86f | 2012-08-10 12:00:43 -0500 | [diff] [blame] | 213 | */ |
| 214 | struct BusState { |
| 215 | Object obj; |
| 216 | DeviceState *parent; |
Marc-André Lureau | f73480c | 2016-07-15 12:04:49 +0200 | [diff] [blame] | 217 | char *name; |
Igor Mammedov | 0ee4de6 | 2014-02-05 16:36:45 +0100 | [diff] [blame] | 218 | HotplugHandler *hotplug_handler; |
Anthony Liguori | 074a86f | 2012-08-10 12:00:43 -0500 | [diff] [blame] | 219 | int max_index; |
Bandan Das | 02e7f85 | 2013-11-25 17:48:40 -0500 | [diff] [blame] | 220 | bool realized; |
Anthony Liguori | 074a86f | 2012-08-10 12:00:43 -0500 | [diff] [blame] | 221 | QTAILQ_HEAD(ChildrenHead, BusChild) children; |
| 222 | QLIST_ENTRY(BusState) sibling; |
| 223 | }; |
| 224 | |
Peter Maydell | 5cc56cc | 2017-07-17 13:36:06 +0100 | [diff] [blame] | 225 | /** |
| 226 | * Property: |
| 227 | * @set_default: true if the default value should be set from @defval, |
| 228 | * in which case @info->set_default_value must not be NULL |
| 229 | * (if false then no default value is set by the property system |
| 230 | * and the field retains whatever value it was given by instance_init). |
| 231 | * @defval: default value for the property. This is used only if @set_default |
| 232 | * is true. |
| 233 | */ |
Anthony Liguori | 074a86f | 2012-08-10 12:00:43 -0500 | [diff] [blame] | 234 | struct Property { |
| 235 | const char *name; |
Fam Zheng | 1b6b7d1 | 2017-07-14 10:14:54 +0800 | [diff] [blame] | 236 | const PropertyInfo *info; |
Ildar Isaev | 3b6ca40 | 2015-03-04 17:09:46 +0300 | [diff] [blame] | 237 | ptrdiff_t offset; |
Anthony Liguori | 074a86f | 2012-08-10 12:00:43 -0500 | [diff] [blame] | 238 | uint8_t bitnr; |
Peter Maydell | 5cc56cc | 2017-07-17 13:36:06 +0100 | [diff] [blame] | 239 | bool set_default; |
Marc-André Lureau | 7631865 | 2017-06-07 20:36:08 +0400 | [diff] [blame] | 240 | union { |
| 241 | int64_t i; |
Marc-André Lureau | 3fb2111 | 2017-06-07 20:36:09 +0400 | [diff] [blame] | 242 | uint64_t u; |
Marc-André Lureau | 7631865 | 2017-06-07 20:36:08 +0400 | [diff] [blame] | 243 | } defval; |
Peter Maydell | 0be6bfa | 2013-03-15 16:41:57 +0000 | [diff] [blame] | 244 | int arrayoffset; |
Fam Zheng | 1b6b7d1 | 2017-07-14 10:14:54 +0800 | [diff] [blame] | 245 | const PropertyInfo *arrayinfo; |
Peter Maydell | 0be6bfa | 2013-03-15 16:41:57 +0000 | [diff] [blame] | 246 | int arrayfieldsize; |
Fam Zheng | 5b4ff3c | 2017-07-14 10:14:52 +0800 | [diff] [blame] | 247 | const char *link_type; |
Anthony Liguori | 074a86f | 2012-08-10 12:00:43 -0500 | [diff] [blame] | 248 | }; |
| 249 | |
| 250 | struct PropertyInfo { |
| 251 | const char *name; |
Gonglei | 51b2e8c | 2014-10-07 14:33:20 +0800 | [diff] [blame] | 252 | const char *description; |
Marc-André Lureau | f7abe0e | 2017-08-24 10:46:10 +0200 | [diff] [blame] | 253 | const QEnumLookup *enum_table; |
Anthony Liguori | 074a86f | 2012-08-10 12:00:43 -0500 | [diff] [blame] | 254 | int (*print)(DeviceState *dev, Property *prop, char *dest, size_t len); |
Marc-André Lureau | a2740ad | 2017-06-07 20:35:53 +0400 | [diff] [blame] | 255 | void (*set_default_value)(Object *obj, const Property *prop); |
Fam Zheng | faabdbb | 2017-07-14 10:14:51 +0800 | [diff] [blame] | 256 | void (*create)(Object *obj, Property *prop, Error **errp); |
Anthony Liguori | 074a86f | 2012-08-10 12:00:43 -0500 | [diff] [blame] | 257 | ObjectPropertyAccessor *get; |
| 258 | ObjectPropertyAccessor *set; |
| 259 | ObjectPropertyRelease *release; |
| 260 | }; |
| 261 | |
Don Slutz | 9f9260a | 2014-05-05 14:03:06 -0400 | [diff] [blame] | 262 | /** |
| 263 | * GlobalProperty: |
Eduardo Habkost | b3ce84f | 2014-08-08 16:03:31 -0300 | [diff] [blame] | 264 | * @user_provided: Set to true if property comes from user-provided config |
| 265 | * (command-line or config file). |
| 266 | * @used: Set to true if property was used when initializing a device. |
Eduardo Habkost | 77280ad | 2016-06-15 16:08:06 -0300 | [diff] [blame] | 267 | * @errp: Error destination, used like first argument of error_setg() |
| 268 | * in case property setting fails later. If @errp is NULL, we |
Greg Kurz | b3443f4 | 2016-07-21 23:58:37 +0200 | [diff] [blame] | 269 | * print warnings instead of ignoring errors silently. For |
| 270 | * hotplugged devices, errp is always ignored and warnings are |
| 271 | * printed instead. |
Don Slutz | 9f9260a | 2014-05-05 14:03:06 -0400 | [diff] [blame] | 272 | */ |
Anthony Liguori | 074a86f | 2012-08-10 12:00:43 -0500 | [diff] [blame] | 273 | typedef struct GlobalProperty { |
| 274 | const char *driver; |
| 275 | const char *property; |
| 276 | const char *value; |
Eduardo Habkost | b3ce84f | 2014-08-08 16:03:31 -0300 | [diff] [blame] | 277 | bool user_provided; |
| 278 | bool used; |
Eduardo Habkost | 77280ad | 2016-06-15 16:08:06 -0300 | [diff] [blame] | 279 | Error **errp; |
Anthony Liguori | 074a86f | 2012-08-10 12:00:43 -0500 | [diff] [blame] | 280 | } GlobalProperty; |
| 281 | |
| 282 | /*** Board API. This should go away once we have a machine config file. ***/ |
| 283 | |
| 284 | DeviceState *qdev_create(BusState *bus, const char *name); |
| 285 | DeviceState *qdev_try_create(BusState *bus, const char *name); |
Anthony Liguori | 074a86f | 2012-08-10 12:00:43 -0500 | [diff] [blame] | 286 | void qdev_init_nofail(DeviceState *dev); |
| 287 | void qdev_set_legacy_instance_id(DeviceState *dev, int alias_id, |
| 288 | int required_for_version); |
Zhu Guihua | c06b2ff | 2015-04-27 16:47:21 +0800 | [diff] [blame] | 289 | HotplugHandler *qdev_get_hotplug_handler(DeviceState *dev); |
Anthony Liguori | 074a86f | 2012-08-10 12:00:43 -0500 | [diff] [blame] | 290 | void qdev_unplug(DeviceState *dev, Error **errp); |
Igor Mammedov | 014176f | 2014-09-26 09:28:21 +0000 | [diff] [blame] | 291 | void qdev_simple_device_unplug_cb(HotplugHandler *hotplug_dev, |
| 292 | DeviceState *dev, Error **errp); |
Anthony Liguori | 074a86f | 2012-08-10 12:00:43 -0500 | [diff] [blame] | 293 | void qdev_machine_creation_done(void); |
| 294 | bool qdev_machine_modified(void); |
| 295 | |
| 296 | qemu_irq qdev_get_gpio_in(DeviceState *dev, int n); |
Peter Crosthwaite | a5f5429 | 2014-05-19 23:30:58 -0700 | [diff] [blame] | 297 | qemu_irq qdev_get_gpio_in_named(DeviceState *dev, const char *name, int n); |
| 298 | |
Anthony Liguori | 074a86f | 2012-08-10 12:00:43 -0500 | [diff] [blame] | 299 | void qdev_connect_gpio_out(DeviceState *dev, int n, qemu_irq pin); |
Peter Crosthwaite | a5f5429 | 2014-05-19 23:30:58 -0700 | [diff] [blame] | 300 | void qdev_connect_gpio_out_named(DeviceState *dev, const char *name, int n, |
| 301 | qemu_irq pin); |
Alexander Graf | b797318 | 2014-09-24 12:32:17 +0200 | [diff] [blame] | 302 | qemu_irq qdev_get_gpio_out_connector(DeviceState *dev, const char *name, int n); |
Peter Crosthwaite | 0c24db2 | 2014-09-25 22:20:58 -0700 | [diff] [blame] | 303 | qemu_irq qdev_intercept_gpio_out(DeviceState *dev, qemu_irq icpt, |
| 304 | const char *name, int n); |
Anthony Liguori | 074a86f | 2012-08-10 12:00:43 -0500 | [diff] [blame] | 305 | |
| 306 | BusState *qdev_get_child_bus(DeviceState *dev, const char *name); |
| 307 | |
| 308 | /*** Device API. ***/ |
| 309 | |
| 310 | /* Register device properties. */ |
| 311 | /* GPIO inputs also double as IRQ sinks. */ |
| 312 | void qdev_init_gpio_in(DeviceState *dev, qemu_irq_handler handler, int n); |
| 313 | void qdev_init_gpio_out(DeviceState *dev, qemu_irq *pins, int n); |
Peter Crosthwaite | a5f5429 | 2014-05-19 23:30:58 -0700 | [diff] [blame] | 314 | void qdev_init_gpio_in_named(DeviceState *dev, qemu_irq_handler handler, |
| 315 | const char *name, int n); |
| 316 | void qdev_init_gpio_out_named(DeviceState *dev, qemu_irq *pins, |
| 317 | const char *name, int n); |
Anthony Liguori | 074a86f | 2012-08-10 12:00:43 -0500 | [diff] [blame] | 318 | |
Peter Crosthwaite | 17a96a1 | 2014-09-25 22:23:42 -0700 | [diff] [blame] | 319 | void qdev_pass_gpios(DeviceState *dev, DeviceState *container, |
| 320 | const char *name); |
| 321 | |
Anthony Liguori | 074a86f | 2012-08-10 12:00:43 -0500 | [diff] [blame] | 322 | BusState *qdev_get_parent_bus(DeviceState *dev); |
| 323 | |
| 324 | /*** BUS API. ***/ |
| 325 | |
| 326 | DeviceState *qdev_find_recursive(BusState *bus, const char *id); |
| 327 | |
| 328 | /* Returns 0 to walk children, > 0 to skip walk, < 0 to terminate walk. */ |
| 329 | typedef int (qbus_walkerfn)(BusState *bus, void *opaque); |
| 330 | typedef int (qdev_walkerfn)(DeviceState *dev, void *opaque); |
| 331 | |
Andreas Färber | fb17dfe | 2013-08-24 00:02:27 +0200 | [diff] [blame] | 332 | void qbus_create_inplace(void *bus, size_t size, const char *typename, |
Anthony Liguori | 074a86f | 2012-08-10 12:00:43 -0500 | [diff] [blame] | 333 | DeviceState *parent, const char *name); |
| 334 | BusState *qbus_create(const char *typename, DeviceState *parent, const char *name); |
| 335 | /* Returns > 0 if either devfn or busfn skip walk somewhere in cursion, |
| 336 | * < 0 if either devfn or busfn terminate walk somewhere in cursion, |
| 337 | * 0 otherwise. */ |
Paolo Bonzini | 0293214 | 2013-12-06 17:54:26 +0100 | [diff] [blame] | 338 | int qbus_walk_children(BusState *bus, |
| 339 | qdev_walkerfn *pre_devfn, qbus_walkerfn *pre_busfn, |
| 340 | qdev_walkerfn *post_devfn, qbus_walkerfn *post_busfn, |
| 341 | void *opaque); |
| 342 | int qdev_walk_children(DeviceState *dev, |
| 343 | qdev_walkerfn *pre_devfn, qbus_walkerfn *pre_busfn, |
| 344 | qdev_walkerfn *post_devfn, qbus_walkerfn *post_busfn, |
| 345 | void *opaque); |
| 346 | |
Anthony Liguori | 074a86f | 2012-08-10 12:00:43 -0500 | [diff] [blame] | 347 | void qdev_reset_all(DeviceState *dev); |
David Hildenbrand | ff8de07 | 2015-07-21 08:32:07 +0200 | [diff] [blame] | 348 | void qdev_reset_all_fn(void *opaque); |
Paolo Bonzini | d0508c3 | 2013-01-10 15:49:07 +0100 | [diff] [blame] | 349 | |
| 350 | /** |
| 351 | * @qbus_reset_all: |
| 352 | * @bus: Bus to be reset. |
| 353 | * |
| 354 | * Reset @bus and perform a bus-level ("hard") reset of all devices connected |
| 355 | * to it, including recursive processing of all buses below @bus itself. A |
| 356 | * hard reset means that qbus_reset_all will reset all state of the device. |
| 357 | * For PCI devices, for example, this will include the base address registers |
| 358 | * or configuration space. |
| 359 | */ |
| 360 | void qbus_reset_all(BusState *bus); |
Anthony Liguori | 074a86f | 2012-08-10 12:00:43 -0500 | [diff] [blame] | 361 | void qbus_reset_all_fn(void *opaque); |
| 362 | |
Anthony Liguori | 074a86f | 2012-08-10 12:00:43 -0500 | [diff] [blame] | 363 | /* This should go away once we get rid of the NULL bus hack */ |
| 364 | BusState *sysbus_get_default(void); |
| 365 | |
| 366 | char *qdev_get_fw_dev_path(DeviceState *dev); |
Gonglei | 0be6390 | 2015-01-29 15:08:51 +0800 | [diff] [blame] | 367 | char *qdev_get_own_fw_dev_path_from_handler(BusState *bus, DeviceState *dev); |
Anthony Liguori | 074a86f | 2012-08-10 12:00:43 -0500 | [diff] [blame] | 368 | |
| 369 | /** |
| 370 | * @qdev_machine_init |
| 371 | * |
| 372 | * Initialize platform devices before machine init. This is a hack until full |
| 373 | * support for composition is added. |
| 374 | */ |
| 375 | void qdev_machine_init(void); |
| 376 | |
| 377 | /** |
| 378 | * @device_reset |
| 379 | * |
| 380 | * Reset a single device (by calling the reset method). |
| 381 | */ |
| 382 | void device_reset(DeviceState *dev); |
| 383 | |
| 384 | const struct VMStateDescription *qdev_get_vmsd(DeviceState *dev); |
| 385 | |
| 386 | const char *qdev_fw_name(DeviceState *dev); |
| 387 | |
| 388 | Object *qdev_get_machine(void); |
| 389 | |
| 390 | /* FIXME: make this a link<> */ |
| 391 | void qdev_set_parent_bus(DeviceState *dev, BusState *bus); |
| 392 | |
Juan Quintela | 9bed84c | 2017-03-28 11:08:52 +0200 | [diff] [blame] | 393 | extern bool qdev_hotplug; |
Juan Quintela | 21def24 | 2017-03-28 11:22:10 +0200 | [diff] [blame] | 394 | extern bool qdev_hot_removed; |
Anthony Liguori | 074a86f | 2012-08-10 12:00:43 -0500 | [diff] [blame] | 395 | |
| 396 | char *qdev_get_dev_path(DeviceState *dev); |
| 397 | |
Marcel Apfelbaum | 4cae4d5 | 2014-11-26 13:50:01 +0200 | [diff] [blame] | 398 | GSList *qdev_build_hotpluggable_device_list(Object *peripheral); |
Zhu Guihua | 66e56b1 | 2014-10-21 19:46:04 +0800 | [diff] [blame] | 399 | |
Igor Mammedov | 431bbb2 | 2014-09-26 09:28:22 +0000 | [diff] [blame] | 400 | void qbus_set_hotplug_handler(BusState *bus, DeviceState *handler, |
| 401 | Error **errp); |
| 402 | |
| 403 | void qbus_set_bus_hotplug_handler(BusState *bus, Error **errp); |
Igor Mammedov | 39b888b | 2014-09-26 09:28:17 +0000 | [diff] [blame] | 404 | |
| 405 | static inline bool qbus_is_hotpluggable(BusState *bus) |
| 406 | { |
Igor Mammedov | 2d9a982 | 2014-09-26 09:28:40 +0000 | [diff] [blame] | 407 | return bus->hotplug_handler; |
Igor Mammedov | 39b888b | 2014-09-26 09:28:17 +0000 | [diff] [blame] | 408 | } |
Paul Durrant | 707ff80 | 2015-01-20 11:05:07 +0000 | [diff] [blame] | 409 | |
| 410 | void device_listener_register(DeviceListener *listener); |
| 411 | void device_listener_unregister(DeviceListener *listener); |
| 412 | |
Anthony Liguori | 074a86f | 2012-08-10 12:00:43 -0500 | [diff] [blame] | 413 | #endif |