2012-08-11 01:00:43 +08:00
|
|
|
#ifndef QDEV_CORE_H
|
|
|
|
#define QDEV_CORE_H
|
|
|
|
|
2012-12-18 01:20:00 +08:00
|
|
|
#include "qemu/queue.h"
|
2013-07-29 22:17:43 +08:00
|
|
|
#include "qemu/bitmap.h"
|
2012-12-18 01:19:50 +08:00
|
|
|
#include "qom/object.h"
|
2012-08-11 01:00:43 +08:00
|
|
|
#include "hw/irq.h"
|
2014-02-05 23:36:45 +08:00
|
|
|
#include "hw/hotplug.h"
|
2012-08-11 01:00:43 +08:00
|
|
|
|
|
|
|
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)
|
|
|
|
|
2013-07-29 22:17:44 +08:00
|
|
|
typedef enum DeviceCategory {
|
|
|
|
DEVICE_CATEGORY_BRIDGE,
|
|
|
|
DEVICE_CATEGORY_USB,
|
|
|
|
DEVICE_CATEGORY_STORAGE,
|
|
|
|
DEVICE_CATEGORY_NETWORK,
|
|
|
|
DEVICE_CATEGORY_INPUT,
|
|
|
|
DEVICE_CATEGORY_DISPLAY,
|
|
|
|
DEVICE_CATEGORY_SOUND,
|
|
|
|
DEVICE_CATEGORY_MISC,
|
2017-01-20 21:01:16 +08:00
|
|
|
DEVICE_CATEGORY_CPU,
|
2013-07-29 22:17:44 +08:00
|
|
|
DEVICE_CATEGORY_MAX
|
|
|
|
} DeviceCategory;
|
|
|
|
|
2013-01-09 10:58:11 +08:00
|
|
|
typedef void (*DeviceRealize)(DeviceState *dev, Error **errp);
|
|
|
|
typedef void (*DeviceUnrealize)(DeviceState *dev, Error **errp);
|
2018-01-14 10:04:10 +08:00
|
|
|
typedef void (*DeviceReset)(DeviceState *dev);
|
2013-11-26 06:48:40 +08:00
|
|
|
typedef void (*BusRealize)(BusState *bus, Error **errp);
|
|
|
|
typedef void (*BusUnrealize)(BusState *bus, Error **errp);
|
2012-08-11 01:00:43 +08:00
|
|
|
|
|
|
|
struct VMStateDescription;
|
|
|
|
|
2013-01-09 10:58:11 +08:00
|
|
|
/**
|
|
|
|
* DeviceClass:
|
|
|
|
* @props: Properties accessing state fields.
|
|
|
|
* @realize: Callback function invoked when the #DeviceState:realized
|
2018-05-28 22:45:09 +08:00
|
|
|
* property is changed to %true.
|
2013-01-09 10:58:11 +08:00
|
|
|
* @unrealize: Callback function invoked when the #DeviceState:realized
|
|
|
|
* property is changed to %false.
|
2014-02-05 23:36:46 +08:00
|
|
|
* @hotpluggable: indicates if #DeviceClass is hotpluggable, available
|
|
|
|
* as readonly "hotpluggable" property of #DeviceState instance
|
2013-01-09 10:58:11 +08:00
|
|
|
*
|
|
|
|
* # Realization #
|
|
|
|
* Devices are constructed in two stages,
|
|
|
|
* 1) object instantiation via object_initialize() and
|
|
|
|
* 2) device realization via #DeviceState:realized property.
|
2018-09-10 15:46:26 +08:00
|
|
|
* The former may not fail (and must not abort or exit, since it is called
|
|
|
|
* during device introspection already), and the latter may return error
|
|
|
|
* information to the caller and must be re-entrant.
|
2013-01-09 10:58:11 +08:00
|
|
|
* 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.
|
|
|
|
*
|
2015-06-19 22:17:23 +08:00
|
|
|
* As an interim step, the #DeviceState:realized property can also be
|
|
|
|
* set with qdev_init_nofail().
|
2013-01-09 10:58:11 +08:00
|
|
|
* 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.
|
|
|
|
*
|
|
|
|
* Any type may override the @realize and/or @unrealize callbacks but needs
|
2013-01-17 15:31:50 +08:00
|
|
|
* to call the parent type's implementation if keeping their functionality
|
|
|
|
* is desired. Refer to QOM documentation for further discussion and examples.
|
|
|
|
*
|
|
|
|
* <note>
|
|
|
|
* <para>
|
2018-05-28 22:45:09 +08:00
|
|
|
* Since TYPE_DEVICE doesn't implement @realize and @unrealize, types
|
|
|
|
* derived directly from it need not call their parent's @realize and
|
|
|
|
* @unrealize.
|
2013-01-17 15:31:50 +08:00
|
|
|
* For other types consult the documentation and implementation of the
|
|
|
|
* respective parent types.
|
|
|
|
* </para>
|
|
|
|
* </note>
|
2013-01-09 10:58:11 +08:00
|
|
|
*/
|
2012-08-11 01:00:43 +08:00
|
|
|
typedef struct DeviceClass {
|
2013-01-09 10:58:11 +08:00
|
|
|
/*< private >*/
|
2012-08-11 01:00:43 +08:00
|
|
|
ObjectClass parent_class;
|
2013-01-09 10:58:11 +08:00
|
|
|
/*< public >*/
|
2012-08-11 01:00:43 +08:00
|
|
|
|
2013-07-29 22:17:44 +08:00
|
|
|
DECLARE_BITMAP(categories, DEVICE_CATEGORY_MAX);
|
2012-08-11 01:00:43 +08:00
|
|
|
const char *fw_name;
|
|
|
|
const char *desc;
|
|
|
|
Property *props;
|
qdev: Replace no_user by cannot_instantiate_with_device_add_yet
In an ideal world, machines can be built by wiring devices together
with configuration, not code. Unfortunately, that's not the world we
live in right now. We still have quite a few devices that need to be
wired up by code. If you try to device_add such a device, it'll fail
in sometimes mysterious ways. If you're lucky, you get an
unmysterious immediate crash.
To protect users from such badness, DeviceClass member no_user used to
make device models unavailable with -device / device_add, but that
regressed in commit 18b6dad. The device model is still omitted from
help, but is available anyway.
Attempts to fix the regression have been rejected with the argument
that the purpose of no_user isn't clear, and it's prone to misuse.
This commit clarifies no_user's purpose. Anthony suggested to rename
it cannot_instantiate_with_device_add_yet_due_to_internal_bugs, which
I shorten somewhat to keep checkpatch happy. While there, make it
bool.
Every use of cannot_instantiate_with_device_add_yet gets a FIXME
comment asking for rationale. The next few commits will clean them
all up, either by providing a rationale, or by getting rid of the use.
With that done, the regression fix is hopefully acceptable.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Marcel Apfelbaum <marcel.a@redhat.com>
Signed-off-by: Andreas Färber <afaerber@suse.de>
2013-11-29 00:26:54 +08:00
|
|
|
|
|
|
|
/*
|
2017-05-04 04:35:44 +08:00
|
|
|
* Can this device be instantiated with -device / device_add?
|
qdev: Replace no_user by cannot_instantiate_with_device_add_yet
In an ideal world, machines can be built by wiring devices together
with configuration, not code. Unfortunately, that's not the world we
live in right now. We still have quite a few devices that need to be
wired up by code. If you try to device_add such a device, it'll fail
in sometimes mysterious ways. If you're lucky, you get an
unmysterious immediate crash.
To protect users from such badness, DeviceClass member no_user used to
make device models unavailable with -device / device_add, but that
regressed in commit 18b6dad. The device model is still omitted from
help, but is available anyway.
Attempts to fix the regression have been rejected with the argument
that the purpose of no_user isn't clear, and it's prone to misuse.
This commit clarifies no_user's purpose. Anthony suggested to rename
it cannot_instantiate_with_device_add_yet_due_to_internal_bugs, which
I shorten somewhat to keep checkpatch happy. While there, make it
bool.
Every use of cannot_instantiate_with_device_add_yet gets a FIXME
comment asking for rationale. The next few commits will clean them
all up, either by providing a rationale, or by getting rid of the use.
With that done, the regression fix is hopefully acceptable.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Marcel Apfelbaum <marcel.a@redhat.com>
Signed-off-by: Andreas Färber <afaerber@suse.de>
2013-11-29 00:26:54 +08:00
|
|
|
* All devices should support instantiation with device_add, and
|
|
|
|
* this flag should not exist. But we're not there, yet. Some
|
|
|
|
* devices fail to instantiate with cryptic error messages.
|
|
|
|
* Others instantiate, but don't work. Exposing users to such
|
2017-05-04 04:35:44 +08:00
|
|
|
* behavior would be cruel; clearing this flag will protect them.
|
|
|
|
* It should never be cleared without a comment explaining why it
|
|
|
|
* is cleared.
|
qdev: Replace no_user by cannot_instantiate_with_device_add_yet
In an ideal world, machines can be built by wiring devices together
with configuration, not code. Unfortunately, that's not the world we
live in right now. We still have quite a few devices that need to be
wired up by code. If you try to device_add such a device, it'll fail
in sometimes mysterious ways. If you're lucky, you get an
unmysterious immediate crash.
To protect users from such badness, DeviceClass member no_user used to
make device models unavailable with -device / device_add, but that
regressed in commit 18b6dad. The device model is still omitted from
help, but is available anyway.
Attempts to fix the regression have been rejected with the argument
that the purpose of no_user isn't clear, and it's prone to misuse.
This commit clarifies no_user's purpose. Anthony suggested to rename
it cannot_instantiate_with_device_add_yet_due_to_internal_bugs, which
I shorten somewhat to keep checkpatch happy. While there, make it
bool.
Every use of cannot_instantiate_with_device_add_yet gets a FIXME
comment asking for rationale. The next few commits will clean them
all up, either by providing a rationale, or by getting rid of the use.
With that done, the regression fix is hopefully acceptable.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Marcel Apfelbaum <marcel.a@redhat.com>
Signed-off-by: Andreas Färber <afaerber@suse.de>
2013-11-29 00:26:54 +08:00
|
|
|
* TODO remove once we're there
|
|
|
|
*/
|
2017-05-04 04:35:44 +08:00
|
|
|
bool user_creatable;
|
2014-02-05 23:36:46 +08:00
|
|
|
bool hotpluggable;
|
2012-08-11 01:00:43 +08:00
|
|
|
|
|
|
|
/* callbacks */
|
2018-01-14 10:04:10 +08:00
|
|
|
DeviceReset reset;
|
2013-01-09 10:58:11 +08:00
|
|
|
DeviceRealize realize;
|
|
|
|
DeviceUnrealize unrealize;
|
2012-08-11 01:00:43 +08:00
|
|
|
|
|
|
|
/* device state */
|
|
|
|
const struct VMStateDescription *vmsd;
|
|
|
|
|
|
|
|
/* Private to qdev / bus. */
|
|
|
|
const char *bus_type;
|
|
|
|
} DeviceClass;
|
|
|
|
|
2014-05-20 14:30:58 +08:00
|
|
|
typedef struct NamedGPIOList NamedGPIOList;
|
|
|
|
|
|
|
|
struct NamedGPIOList {
|
|
|
|
char *name;
|
|
|
|
qemu_irq *in;
|
|
|
|
int num_in;
|
|
|
|
int num_out;
|
|
|
|
QLIST_ENTRY(NamedGPIOList) node;
|
|
|
|
};
|
|
|
|
|
2013-01-09 10:58:10 +08:00
|
|
|
/**
|
|
|
|
* 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.
|
|
|
|
*/
|
2012-08-11 01:00:43 +08:00
|
|
|
struct DeviceState {
|
2013-01-09 10:58:10 +08:00
|
|
|
/*< private >*/
|
2012-08-11 01:00:43 +08:00
|
|
|
Object parent_obj;
|
2013-01-09 10:58:10 +08:00
|
|
|
/*< public >*/
|
2012-08-11 01:00:43 +08:00
|
|
|
|
|
|
|
const char *id;
|
qdev: store DeviceState's canonical path to use when unparenting
device_unparent(dev, ...) is called when a device is unparented,
either directly, or as a result of a parent device being
finalized, and handles some final cleanup for the device. Part
of this includes emiting a DEVICE_DELETED QMP event to notify
management, which includes the device's path in the composition
tree as provided by object_get_canonical_path().
object_get_canonical_path() assumes the device is still connected
to the machine/root container, and will assert otherwise, but
in some situations this isn't the case:
If the parent is finalized as a result of object_unparent(), it
will still be attached to the composition tree at the time any
children are unparented as a result of that same call to
object_unparent(). However, in some cases, object_unparent()
will complete without finalizing the parent device, due to
lingering references that won't be released till some time later.
One such example is if the parent has MemoryRegion children (which
take a ref on their parent), who in turn have AddressSpace's (which
take a ref on their regions), since those AddressSpaces get cleaned
up asynchronously by the RCU thread.
In this case qdev:device_unparent() may be called for a child Device
that no longer has a path to the root/machine container, causing
object_get_canonical_path() to assert.
Fix this by storing the canonical path during realize() so the
information will still be available for device_unparent() in such
cases.
Cc: Michael S. Tsirkin <mst@redhat.com>
Cc: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Michael Roth <mdroth@linux.vnet.ibm.com>
Signed-off-by: Greg Kurz <groug@kaod.org>
Signed-off-by: Michael Roth <mdroth@linux.vnet.ibm.com>
Tested-by: Eric Auger <eric.auger@redhat.com>
Reviewed-by: David Gibson <david@gibson.dropbear.id.au>
Message-Id: <20171016222315.407-2-mdroth@linux.vnet.ibm.com>
[Clear dev->canonical_path at the post_realize_fail label, which is
cleaner. Suggested by David Gibson. - Paolo]
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2017-10-17 06:23:13 +08:00
|
|
|
char *canonical_path;
|
2013-01-09 10:58:10 +08:00
|
|
|
bool realized;
|
2014-06-26 21:10:03 +08:00
|
|
|
bool pending_deleted_event;
|
2012-08-11 01:00:43 +08:00
|
|
|
QemuOpts *opts;
|
|
|
|
int hotplugged;
|
|
|
|
BusState *parent_bus;
|
2014-05-20 14:30:58 +08:00
|
|
|
QLIST_HEAD(, NamedGPIOList) gpios;
|
2012-08-11 01:00:43 +08:00
|
|
|
QLIST_HEAD(, BusState) child_bus;
|
|
|
|
int num_child_bus;
|
|
|
|
int instance_id_alias;
|
|
|
|
int alias_required_for_version;
|
|
|
|
};
|
|
|
|
|
2015-01-20 19:05:07 +08:00
|
|
|
struct DeviceListener {
|
|
|
|
void (*realize)(DeviceListener *listener, DeviceState *dev);
|
|
|
|
void (*unrealize)(DeviceListener *listener, DeviceState *dev);
|
|
|
|
QTAILQ_ENTRY(DeviceListener) link;
|
|
|
|
};
|
|
|
|
|
2012-08-11 01:00:43 +08:00
|
|
|
#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);
|
2013-12-07 00:54:27 +08:00
|
|
|
void (*reset)(BusState *bus);
|
2013-11-26 06:48:40 +08:00
|
|
|
BusRealize realize;
|
|
|
|
BusUnrealize unrealize;
|
|
|
|
|
2013-01-15 07:08:00 +08:00
|
|
|
/* maximum devices allowed on the bus, 0: no limit. */
|
|
|
|
int max_dev;
|
qdev: Keep global allocation counter per bus
When we have 2 separate qdev devices that both create a qbus of the
same type without specifying a bus name or device name, we end up
with two buses of the same name, such as ide.0 on the Mac machines:
dev: macio-ide, id ""
bus: ide.0
type IDE
dev: macio-ide, id ""
bus: ide.0
type IDE
If we now spawn a device that connects to a ide.0 the last created
bus gets the device, with the first created bus inaccessible to the
command line.
After some discussion on IRC we concluded that the best quick fix way
forward for this is to make automated bus-class type based allocation
count a global counter. That's what this patch implements. With this
we instead get
dev: macio-ide, id ""
bus: ide.1
type IDE
dev: macio-ide, id ""
bus: ide.0
type IDE
on the example mentioned above.
This also means that if you did -device ...,bus=ide.0 you got a device
on the first bus (the last created one) before this patch and get that
device on the second one (the first created one) now. Breaks
migration unless you change bus=ide.0 to bus=ide.1 on the destination.
This is intended and makes the bus enumeration work as expected.
As per review request follows a list of otherwise affected boards and
the reasoning for the conclusion that they are ok:
target machine bus id times
------ ------- ------ -----
aarch64 n800 i2c-bus.0 2
aarch64 n810 i2c-bus.0 2
arm n800 i2c-bus.0 2
arm n810 i2c-bus.0 2
-> Devices are only created explicitly on one of the two buses, using
s->mpu->i2c[0], so no change to the guest.
aarch64 vexpress-a15 virtio-mmio-bus.0 4
aarch64 vexpress-a9 virtio-mmio-bus.0 4
aarch64 virt virtio-mmio-bus.0 32
arm vexpress-a15 virtio-mmio-bus.0 4
arm vexpress-a9 virtio-mmio-bus.0 4
arm virt virtio-mmio-bus.0 32
-> Makes -device bus= work for all virtio-mmio buses. Breaks
migration. Workaround for migration from old to new: specify
virtio-mmio-bus.4 or .32 respectively rather than .0 on the
destination.
aarch64 xilinx-zynq-a9 usb-bus.0 2
arm xilinx-zynq-a9 usb-bus.0 2
mips64el fulong2e usb-bus.0 2
-> Normal USB operation not affected. Migration driver needs command
line to use the other bus.
i386 isapc ide.0 2
x86_64 isapc ide.0 2
mips mips ide.0 2
mips64 mips ide.0 2
mips64el mips ide.0 2
mipsel mips ide.0 2
ppc g3beige ide.0 2
ppc mac99 ide.0 2
ppc prep ide.0 2
ppc64 g3beige ide.0 2
ppc64 mac99 ide.0 2
ppc64 prep ide.0 2
-> Makes -device bus= work for all IDE buses. Breaks migration.
Workaround for migration from old to new: specify ide.1 rather than
ide.0 on the destination.
Signed-off-by: Alexander Graf <agraf@suse.de>
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Andreas Faerber <afaerber@suse.de>
Signed-off-by: Alexander Graf <agraf@suse.de>
2014-02-06 23:08:15 +08:00
|
|
|
/* number of automatically allocated bus ids (e.g. ide.0) */
|
|
|
|
int automatic_ids;
|
2012-08-11 01:00:43 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
typedef struct BusChild {
|
|
|
|
DeviceState *child;
|
|
|
|
int index;
|
|
|
|
QTAILQ_ENTRY(BusChild) sibling;
|
|
|
|
} BusChild;
|
|
|
|
|
2014-02-05 23:36:45 +08:00
|
|
|
#define QDEV_HOTPLUG_HANDLER_PROPERTY "hotplug-handler"
|
|
|
|
|
2012-08-11 01:00:43 +08:00
|
|
|
/**
|
|
|
|
* BusState:
|
2018-10-30 23:16:37 +08:00
|
|
|
* @hotplug_handler: link to a hotplug handler associated with bus.
|
2012-08-11 01:00:43 +08:00
|
|
|
*/
|
|
|
|
struct BusState {
|
|
|
|
Object obj;
|
|
|
|
DeviceState *parent;
|
2016-07-15 18:04:49 +08:00
|
|
|
char *name;
|
2014-02-05 23:36:45 +08:00
|
|
|
HotplugHandler *hotplug_handler;
|
2012-08-11 01:00:43 +08:00
|
|
|
int max_index;
|
2013-11-26 06:48:40 +08:00
|
|
|
bool realized;
|
2012-08-11 01:00:43 +08:00
|
|
|
QTAILQ_HEAD(ChildrenHead, BusChild) children;
|
|
|
|
QLIST_ENTRY(BusState) sibling;
|
|
|
|
};
|
|
|
|
|
2017-07-17 20:36:06 +08:00
|
|
|
/**
|
|
|
|
* Property:
|
|
|
|
* @set_default: true if the default value should be set from @defval,
|
|
|
|
* in which case @info->set_default_value must not be NULL
|
|
|
|
* (if false then no default value is set by the property system
|
|
|
|
* and the field retains whatever value it was given by instance_init).
|
|
|
|
* @defval: default value for the property. This is used only if @set_default
|
|
|
|
* is true.
|
|
|
|
*/
|
2012-08-11 01:00:43 +08:00
|
|
|
struct Property {
|
|
|
|
const char *name;
|
2017-07-14 10:14:54 +08:00
|
|
|
const PropertyInfo *info;
|
2015-03-04 22:09:46 +08:00
|
|
|
ptrdiff_t offset;
|
2012-08-11 01:00:43 +08:00
|
|
|
uint8_t bitnr;
|
2017-07-17 20:36:06 +08:00
|
|
|
bool set_default;
|
2017-06-08 00:36:08 +08:00
|
|
|
union {
|
|
|
|
int64_t i;
|
2017-06-08 00:36:09 +08:00
|
|
|
uint64_t u;
|
2017-06-08 00:36:08 +08:00
|
|
|
} defval;
|
2013-03-16 00:41:57 +08:00
|
|
|
int arrayoffset;
|
2017-07-14 10:14:54 +08:00
|
|
|
const PropertyInfo *arrayinfo;
|
2013-03-16 00:41:57 +08:00
|
|
|
int arrayfieldsize;
|
2017-07-14 10:14:52 +08:00
|
|
|
const char *link_type;
|
2012-08-11 01:00:43 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
struct PropertyInfo {
|
|
|
|
const char *name;
|
2014-10-07 14:33:20 +08:00
|
|
|
const char *description;
|
2017-08-24 16:46:10 +08:00
|
|
|
const QEnumLookup *enum_table;
|
2012-08-11 01:00:43 +08:00
|
|
|
int (*print)(DeviceState *dev, Property *prop, char *dest, size_t len);
|
2017-06-08 00:35:53 +08:00
|
|
|
void (*set_default_value)(Object *obj, const Property *prop);
|
2017-07-14 10:14:51 +08:00
|
|
|
void (*create)(Object *obj, Property *prop, Error **errp);
|
2012-08-11 01:00:43 +08:00
|
|
|
ObjectPropertyAccessor *get;
|
|
|
|
ObjectPropertyAccessor *set;
|
|
|
|
ObjectPropertyRelease *release;
|
|
|
|
};
|
|
|
|
|
2014-05-06 02:03:06 +08:00
|
|
|
/**
|
|
|
|
* GlobalProperty:
|
2014-08-09 03:03:31 +08:00
|
|
|
* @user_provided: Set to true if property comes from user-provided config
|
|
|
|
* (command-line or config file).
|
|
|
|
* @used: Set to true if property was used when initializing a device.
|
2016-06-16 03:08:06 +08:00
|
|
|
* @errp: Error destination, used like first argument of error_setg()
|
|
|
|
* in case property setting fails later. If @errp is NULL, we
|
2016-07-22 05:58:37 +08:00
|
|
|
* print warnings instead of ignoring errors silently. For
|
|
|
|
* hotplugged devices, errp is always ignored and warnings are
|
|
|
|
* printed instead.
|
2014-05-06 02:03:06 +08:00
|
|
|
*/
|
2012-08-11 01:00:43 +08:00
|
|
|
typedef struct GlobalProperty {
|
|
|
|
const char *driver;
|
|
|
|
const char *property;
|
|
|
|
const char *value;
|
2014-08-09 03:03:31 +08:00
|
|
|
bool user_provided;
|
|
|
|
bool used;
|
2016-06-16 03:08:06 +08:00
|
|
|
Error **errp;
|
2012-08-11 01:00:43 +08:00
|
|
|
} 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);
|
|
|
|
void qdev_init_nofail(DeviceState *dev);
|
|
|
|
void qdev_set_legacy_instance_id(DeviceState *dev, int alias_id,
|
|
|
|
int required_for_version);
|
2017-11-02 18:10:06 +08:00
|
|
|
HotplugHandler *qdev_get_machine_hotplug_handler(DeviceState *dev);
|
2015-04-27 16:47:21 +08:00
|
|
|
HotplugHandler *qdev_get_hotplug_handler(DeviceState *dev);
|
2012-08-11 01:00:43 +08:00
|
|
|
void qdev_unplug(DeviceState *dev, Error **errp);
|
2014-09-26 17:28:21 +08:00
|
|
|
void qdev_simple_device_unplug_cb(HotplugHandler *hotplug_dev,
|
|
|
|
DeviceState *dev, Error **errp);
|
2012-08-11 01:00:43 +08:00
|
|
|
void qdev_machine_creation_done(void);
|
|
|
|
bool qdev_machine_modified(void);
|
|
|
|
|
|
|
|
qemu_irq qdev_get_gpio_in(DeviceState *dev, int n);
|
2014-05-20 14:30:58 +08:00
|
|
|
qemu_irq qdev_get_gpio_in_named(DeviceState *dev, const char *name, int n);
|
|
|
|
|
2012-08-11 01:00:43 +08:00
|
|
|
void qdev_connect_gpio_out(DeviceState *dev, int n, qemu_irq pin);
|
2014-05-20 14:30:58 +08:00
|
|
|
void qdev_connect_gpio_out_named(DeviceState *dev, const char *name, int n,
|
|
|
|
qemu_irq pin);
|
2014-09-24 18:32:17 +08:00
|
|
|
qemu_irq qdev_get_gpio_out_connector(DeviceState *dev, const char *name, int n);
|
2014-09-26 13:20:58 +08:00
|
|
|
qemu_irq qdev_intercept_gpio_out(DeviceState *dev, qemu_irq icpt,
|
|
|
|
const char *name, int n);
|
2012-08-11 01:00:43 +08:00
|
|
|
|
|
|
|
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);
|
2014-05-20 14:30:58 +08:00
|
|
|
void qdev_init_gpio_out_named(DeviceState *dev, qemu_irq *pins,
|
|
|
|
const char *name, int n);
|
2018-03-02 18:45:38 +08:00
|
|
|
/**
|
|
|
|
* qdev_init_gpio_in_named_with_opaque: create an array of input GPIO lines
|
|
|
|
* for the specified device
|
|
|
|
*
|
|
|
|
* @dev: Device to create input GPIOs for
|
|
|
|
* @handler: Function to call when GPIO line value is set
|
|
|
|
* @opaque: Opaque data pointer to pass to @handler
|
|
|
|
* @name: Name of the GPIO input (must be unique for this device)
|
|
|
|
* @n: Number of GPIO lines in this input set
|
|
|
|
*/
|
|
|
|
void qdev_init_gpio_in_named_with_opaque(DeviceState *dev,
|
|
|
|
qemu_irq_handler handler,
|
|
|
|
void *opaque,
|
|
|
|
const char *name, int n);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* qdev_init_gpio_in_named: create an array of input GPIO lines
|
|
|
|
* for the specified device
|
|
|
|
*
|
|
|
|
* Like qdev_init_gpio_in_named_with_opaque(), but the opaque pointer
|
|
|
|
* passed to the handler is @dev (which is the most commonly desired behaviour).
|
|
|
|
*/
|
|
|
|
static inline void qdev_init_gpio_in_named(DeviceState *dev,
|
|
|
|
qemu_irq_handler handler,
|
|
|
|
const char *name, int n)
|
|
|
|
{
|
|
|
|
qdev_init_gpio_in_named_with_opaque(dev, handler, dev, name, n);
|
|
|
|
}
|
2012-08-11 01:00:43 +08:00
|
|
|
|
2014-09-26 13:23:42 +08:00
|
|
|
void qdev_pass_gpios(DeviceState *dev, DeviceState *container,
|
|
|
|
const char *name);
|
|
|
|
|
2012-08-11 01:00:43 +08:00
|
|
|
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);
|
|
|
|
|
2013-08-24 06:02:27 +08:00
|
|
|
void qbus_create_inplace(void *bus, size_t size, const char *typename,
|
2012-08-11 01:00:43 +08:00
|
|
|
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. */
|
2013-12-07 00:54:26 +08:00
|
|
|
int qbus_walk_children(BusState *bus,
|
|
|
|
qdev_walkerfn *pre_devfn, qbus_walkerfn *pre_busfn,
|
|
|
|
qdev_walkerfn *post_devfn, qbus_walkerfn *post_busfn,
|
|
|
|
void *opaque);
|
|
|
|
int qdev_walk_children(DeviceState *dev,
|
|
|
|
qdev_walkerfn *pre_devfn, qbus_walkerfn *pre_busfn,
|
|
|
|
qdev_walkerfn *post_devfn, qbus_walkerfn *post_busfn,
|
|
|
|
void *opaque);
|
|
|
|
|
2012-08-11 01:00:43 +08:00
|
|
|
void qdev_reset_all(DeviceState *dev);
|
2015-07-21 14:32:07 +08:00
|
|
|
void qdev_reset_all_fn(void *opaque);
|
2013-01-10 22:49:07 +08:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @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);
|
2012-08-11 01:00:43 +08:00
|
|
|
void qbus_reset_all_fn(void *opaque);
|
|
|
|
|
|
|
|
/* 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);
|
2015-01-29 15:08:51 +08:00
|
|
|
char *qdev_get_own_fw_dev_path_from_handler(BusState *bus, DeviceState *dev);
|
2012-08-11 01:00:43 +08:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @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);
|
|
|
|
|
2018-01-14 10:04:11 +08:00
|
|
|
void device_class_set_parent_reset(DeviceClass *dc,
|
|
|
|
DeviceReset dev_reset,
|
|
|
|
DeviceReset *parent_reset);
|
|
|
|
void device_class_set_parent_realize(DeviceClass *dc,
|
|
|
|
DeviceRealize dev_realize,
|
|
|
|
DeviceRealize *parent_realize);
|
|
|
|
void device_class_set_parent_unrealize(DeviceClass *dc,
|
|
|
|
DeviceUnrealize dev_unrealize,
|
|
|
|
DeviceUnrealize *parent_unrealize);
|
|
|
|
|
2012-08-11 01:00:43 +08:00
|
|
|
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);
|
|
|
|
|
2017-03-28 17:08:52 +08:00
|
|
|
extern bool qdev_hotplug;
|
2017-03-28 17:22:10 +08:00
|
|
|
extern bool qdev_hot_removed;
|
2012-08-11 01:00:43 +08:00
|
|
|
|
|
|
|
char *qdev_get_dev_path(DeviceState *dev);
|
|
|
|
|
2014-11-26 19:50:01 +08:00
|
|
|
GSList *qdev_build_hotpluggable_device_list(Object *peripheral);
|
2014-10-21 19:46:04 +08:00
|
|
|
|
2014-09-26 17:28:22 +08:00
|
|
|
void qbus_set_hotplug_handler(BusState *bus, DeviceState *handler,
|
|
|
|
Error **errp);
|
|
|
|
|
|
|
|
void qbus_set_bus_hotplug_handler(BusState *bus, Error **errp);
|
2014-09-26 17:28:17 +08:00
|
|
|
|
|
|
|
static inline bool qbus_is_hotpluggable(BusState *bus)
|
|
|
|
{
|
2014-09-26 17:28:40 +08:00
|
|
|
return bus->hotplug_handler;
|
2014-09-26 17:28:17 +08:00
|
|
|
}
|
2015-01-20 19:05:07 +08:00
|
|
|
|
|
|
|
void device_listener_register(DeviceListener *listener);
|
|
|
|
void device_listener_unregister(DeviceListener *listener);
|
|
|
|
|
2012-08-11 01:00:43 +08:00
|
|
|
#endif
|