| #ifndef QDEV_CORE_H |
| #define QDEV_CORE_H |
| |
| #include "qemu/queue.h" |
| #include "qemu/option.h" |
| #include "qemu/typedefs.h" |
| #include "qom/object.h" |
| #include "hw/irq.h" |
| #include "qapi/error.h" |
| |
| enum { |
| DEV_NVECTORS_UNSPECIFIED = -1, |
| }; |
| |
| #define TYPE_DEVICE "device" |
| #define DEVICE(obj) OBJECT_CHECK(DeviceState, (obj), TYPE_DEVICE) |
| #define DEVICE_CLASS(klass) OBJECT_CLASS_CHECK(DeviceClass, (klass), TYPE_DEVICE) |
| #define DEVICE_GET_CLASS(obj) OBJECT_GET_CLASS(DeviceClass, (obj), TYPE_DEVICE) |
| |
| typedef int (*qdev_initfn)(DeviceState *dev); |
| typedef int (*qdev_event)(DeviceState *dev); |
| typedef void (*qdev_resetfn)(DeviceState *dev); |
| typedef void (*DeviceRealize)(DeviceState *dev, Error **errp); |
| typedef void (*DeviceUnrealize)(DeviceState *dev, Error **errp); |
| |
| struct VMStateDescription; |
| |
| /** |
| * DeviceClass: |
| * @props: Properties accessing state fields. |
| * @realize: Callback function invoked when the #DeviceState:realized |
| * property is changed to %true. The default invokes @init if not %NULL. |
| * @unrealize: Callback function invoked when the #DeviceState:realized |
| * property is changed to %false. |
| * @init: Callback function invoked when the #DeviceState::realized property |
| * is changed to %true. Deprecated, new types inheriting directly from |
| * TYPE_DEVICE should use @realize instead, new leaf types should consult |
| * their respective parent type. |
| * |
| * # Realization # |
| * Devices are constructed in two stages, |
| * 1) object instantiation via object_initialize() and |
| * 2) device realization via #DeviceState:realized property. |
| * The former may not fail (it might assert or exit), the latter may return |
| * error information to the caller and must be re-entrant. |
| * Trivial field initializations should go into #TypeInfo.instance_init. |
| * Operations depending on @props static properties should go into @realize. |
| * After successful realization, setting static properties will fail. |
| * |
| * As an interim step, the #DeviceState:realized property is set by deprecated |
| * functions qdev_init() and qdev_init_nofail(). |
| * In the future, devices will propagate this state change to their children |
| * and along busses they expose. |
| * The point in time will be deferred to machine creation, so that values |
| * set in @realize will not be introspectable beforehand. Therefore devices |
| * must not create children during @realize; they should initialize them via |
| * object_initialize() in their own #TypeInfo.instance_init and forward the |
| * realization events appropriately. |
| * |
| * The @init callback is considered private to a particular bus implementation |
| * (immediate abstract child types of TYPE_DEVICE). Derived leaf types set an |
| * "init" callback on their parent class instead. |
| * |
| * Any type may override the @realize and/or @unrealize callbacks but needs |
| * to call the parent type's implementation if keeping their functionality |
| * is desired. Refer to QOM documentation for further discussion and examples. |
| * |
| * <note> |
| * <para> |
| * If a type derived directly from TYPE_DEVICE implements @realize, it does |
| * not need to implement @init and therefore does not need to store and call |
| * #DeviceClass' default @realize callback. |
| * For other types consult the documentation and implementation of the |
| * respective parent types. |
| * </para> |
| * </note> |
| */ |
| typedef struct DeviceClass { |
| /*< private >*/ |
| ObjectClass parent_class; |
| /*< public >*/ |
| |
| const char *fw_name; |
| const char *desc; |
| Property *props; |
| int no_user; |
| |
| /* callbacks */ |
| void (*reset)(DeviceState *dev); |
| DeviceRealize realize; |
| DeviceUnrealize unrealize; |
| |
| /* device state */ |
| const struct VMStateDescription *vmsd; |
| |
| /* Private to qdev / bus. */ |
| qdev_initfn init; /* TODO remove, once users are converted to realize */ |
| qdev_event unplug; |
| qdev_event exit; /* TODO remove, once users are converted to unrealize */ |
| const char *bus_type; |
| } DeviceClass; |
| |
| /** |
| * DeviceState: |
| * @realized: Indicates whether the device has been fully constructed. |
| * |
| * This structure should not be accessed directly. We declare it here |
| * so that it can be embedded in individual device state structures. |
| */ |
| struct DeviceState { |
| /*< private >*/ |
| Object parent_obj; |
| /*< public >*/ |
| |
| const char *id; |
| bool realized; |
| QemuOpts *opts; |
| int hotplugged; |
| BusState *parent_bus; |
| int num_gpio_out; |
| qemu_irq *gpio_out; |
| int num_gpio_in; |
| qemu_irq *gpio_in; |
| QLIST_HEAD(, BusState) child_bus; |
| int num_child_bus; |
| int instance_id_alias; |
| int alias_required_for_version; |
| }; |
| |
| #define TYPE_BUS "bus" |
| #define BUS(obj) OBJECT_CHECK(BusState, (obj), TYPE_BUS) |
| #define BUS_CLASS(klass) OBJECT_CLASS_CHECK(BusClass, (klass), TYPE_BUS) |
| #define BUS_GET_CLASS(obj) OBJECT_GET_CLASS(BusClass, (obj), TYPE_BUS) |
| |
| struct BusClass { |
| ObjectClass parent_class; |
| |
| /* FIXME first arg should be BusState */ |
| void (*print_dev)(Monitor *mon, DeviceState *dev, int indent); |
| char *(*get_dev_path)(DeviceState *dev); |
| /* |
| * This callback is used to create Open Firmware device path in accordance |
| * with OF spec http://forthworks.com/standards/of1275.pdf. Individual bus |
| * bindings can be found at http://playground.sun.com/1275/bindings/. |
| */ |
| char *(*get_fw_dev_path)(DeviceState *dev); |
| int (*reset)(BusState *bus); |
| /* maximum devices allowed on the bus, 0: no limit. */ |
| int max_dev; |
| }; |
| |
| typedef struct BusChild { |
| DeviceState *child; |
| int index; |
| QTAILQ_ENTRY(BusChild) sibling; |
| } BusChild; |
| |
| /** |
| * BusState: |
| */ |
| struct BusState { |
| Object obj; |
| DeviceState *parent; |
| const char *name; |
| int allow_hotplug; |
| int max_index; |
| QTAILQ_HEAD(ChildrenHead, BusChild) children; |
| QLIST_ENTRY(BusState) sibling; |
| }; |
| |
| struct Property { |
| const char *name; |
| PropertyInfo *info; |
| int offset; |
| uint8_t bitnr; |
| uint8_t qtype; |
| int64_t defval; |
| int arrayoffset; |
| PropertyInfo *arrayinfo; |
| int arrayfieldsize; |
| }; |
| |
| struct PropertyInfo { |
| const char *name; |
| const char *legacy_name; |
| const char **enum_table; |
| int (*parse)(DeviceState *dev, Property *prop, const char *str); |
| int (*print)(DeviceState *dev, Property *prop, char *dest, size_t len); |
| ObjectPropertyAccessor *get; |
| ObjectPropertyAccessor *set; |
| ObjectPropertyRelease *release; |
| }; |
| |
| typedef struct GlobalProperty { |
| const char *driver; |
| const char *property; |
| const char *value; |
| QTAILQ_ENTRY(GlobalProperty) next; |
| } GlobalProperty; |
| |
| /*** Board API. This should go away once we have a machine config file. ***/ |
| |
| DeviceState *qdev_create(BusState *bus, const char *name); |
| DeviceState *qdev_try_create(BusState *bus, const char *name); |
| int qdev_init(DeviceState *dev) QEMU_WARN_UNUSED_RESULT; |
| void qdev_init_nofail(DeviceState *dev); |
| void qdev_set_legacy_instance_id(DeviceState *dev, int alias_id, |
| int required_for_version); |
| void qdev_unplug(DeviceState *dev, Error **errp); |
| void qdev_free(DeviceState *dev); |
| int qdev_simple_unplug_cb(DeviceState *dev); |
| void qdev_machine_creation_done(void); |
| bool qdev_machine_modified(void); |
| |
| qemu_irq qdev_get_gpio_in(DeviceState *dev, int n); |
| void qdev_connect_gpio_out(DeviceState *dev, int n, qemu_irq pin); |
| |
| BusState *qdev_get_child_bus(DeviceState *dev, const char *name); |
| |
| /*** Device API. ***/ |
| |
| /* Register device properties. */ |
| /* GPIO inputs also double as IRQ sinks. */ |
| void qdev_init_gpio_in(DeviceState *dev, qemu_irq_handler handler, int n); |
| void qdev_init_gpio_out(DeviceState *dev, qemu_irq *pins, int n); |
| |
| BusState *qdev_get_parent_bus(DeviceState *dev); |
| |
| /*** BUS API. ***/ |
| |
| DeviceState *qdev_find_recursive(BusState *bus, const char *id); |
| |
| /* Returns 0 to walk children, > 0 to skip walk, < 0 to terminate walk. */ |
| typedef int (qbus_walkerfn)(BusState *bus, void *opaque); |
| typedef int (qdev_walkerfn)(DeviceState *dev, void *opaque); |
| |
| void qbus_create_inplace(void *bus, const char *typename, |
| DeviceState *parent, const char *name); |
| BusState *qbus_create(const char *typename, DeviceState *parent, const char *name); |
| /* Returns > 0 if either devfn or busfn skip walk somewhere in cursion, |
| * < 0 if either devfn or busfn terminate walk somewhere in cursion, |
| * 0 otherwise. */ |
| int qbus_walk_children(BusState *bus, qdev_walkerfn *devfn, |
| qbus_walkerfn *busfn, void *opaque); |
| int qdev_walk_children(DeviceState *dev, qdev_walkerfn *devfn, |
| qbus_walkerfn *busfn, void *opaque); |
| void qdev_reset_all(DeviceState *dev); |
| |
| /** |
| * @qbus_reset_all: |
| * @bus: Bus to be reset. |
| * |
| * Reset @bus and perform a bus-level ("hard") reset of all devices connected |
| * to it, including recursive processing of all buses below @bus itself. A |
| * hard reset means that qbus_reset_all will reset all state of the device. |
| * For PCI devices, for example, this will include the base address registers |
| * or configuration space. |
| */ |
| void qbus_reset_all(BusState *bus); |
| void qbus_reset_all_fn(void *opaque); |
| |
| void qbus_free(BusState *bus); |
| |
| /* This should go away once we get rid of the NULL bus hack */ |
| BusState *sysbus_get_default(void); |
| |
| char *qdev_get_fw_dev_path(DeviceState *dev); |
| |
| /** |
| * @qdev_machine_init |
| * |
| * Initialize platform devices before machine init. This is a hack until full |
| * support for composition is added. |
| */ |
| void qdev_machine_init(void); |
| |
| /** |
| * @device_reset |
| * |
| * Reset a single device (by calling the reset method). |
| */ |
| void device_reset(DeviceState *dev); |
| |
| const struct VMStateDescription *qdev_get_vmsd(DeviceState *dev); |
| |
| const char *qdev_fw_name(DeviceState *dev); |
| |
| Object *qdev_get_machine(void); |
| |
| /* FIXME: make this a link<> */ |
| void qdev_set_parent_bus(DeviceState *dev, BusState *bus); |
| |
| extern int qdev_hotplug; |
| |
| char *qdev_get_dev_path(DeviceState *dev); |
| |
| #endif |