Rationale: move device information from code to data structures.
v2: Adapt the drivers missed in the first version.
Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
}
static SSISlaveInfo ads7846_info = {
+ .qdev.name ="ads7846",
+ .qdev.size = sizeof(ADS7846State),
.init = ads7846_init,
.transfer = ads7846_transfer
};
static void ads7846_register_devices(void)
{
- ssi_register_slave("ads7846", sizeof(ADS7846State), &ads7846_info);
+ ssi_register_slave(&ads7846_info);
}
device_init(ads7846_register_devices)
info->init(s);
}
-void i2c_register_slave(const char *name, int size, I2CSlaveInfo *info)
+void i2c_register_slave(I2CSlaveInfo *info)
{
- assert(size >= sizeof(i2c_slave));
+ assert(info->qdev.size >= sizeof(i2c_slave));
info->qdev.init = i2c_slave_qdev_init;
info->qdev.bus_type = BUS_TYPE_I2C;
- qdev_register(name, size, &info->qdev);
+ qdev_register(&info->qdev);
}
DeviceState *i2c_create_slave(i2c_bus *bus, const char *name, int addr)
#define I2C_SLAVE_FROM_QDEV(dev) DO_UPCAST(i2c_slave, qdev, dev)
#define FROM_I2C_SLAVE(type, dev) DO_UPCAST(type, i2c, dev)
-void i2c_register_slave(const char *name, int size, I2CSlaveInfo *type);
+void i2c_register_slave(I2CSlaveInfo *type);
DeviceState *i2c_create_slave(i2c_bus *bus, const char *name, int addr);
}
static I2CSlaveInfo lm8323_info = {
+ .qdev.name = "lm8323",
+ .qdev.size = sizeof(LM823KbdState),
.init = lm8323_init,
.event = lm_i2c_event,
.recv = lm_i2c_rx,
static void lm832x_register_devices(void)
{
- i2c_register_slave("lm8323", sizeof(LM823KbdState), &lm8323_info);
+ i2c_register_slave(&lm8323_info);
}
device_init(lm832x_register_devices)
}
static SSISlaveInfo max1110_info = {
+ .qdev.name = "max1110",
+ .qdev.size = sizeof(MAX111xState),
.init = max1110_init,
.transfer = max111x_transfer
};
static SSISlaveInfo max1111_info = {
+ .qdev.name = "max1111",
+ .qdev.size = sizeof(MAX111xState),
.init = max1111_init,
.transfer = max111x_transfer
};
static void max111x_register_devices(void)
{
- ssi_register_slave("max1110", sizeof(MAX111xState), &max1110_info);
- ssi_register_slave("max1111", sizeof(MAX111xState), &max1111_info);
+ ssi_register_slave(&max1110_info);
+ ssi_register_slave(&max1111_info);
}
device_init(max111x_register_devices)
}
static I2CSlaveInfo max7310_info = {
+ .qdev.name = "max7310",
+ .qdev.size = sizeof(MAX7310State),
.init = max7310_init,
.event = max7310_event,
.recv = max7310_rx,
static void max7310_register_devices(void)
{
- i2c_register_slave("max7310", sizeof(MAX7310State), &max7310_info);
+ i2c_register_slave(&max7310_info);
}
device_init(max7310_register_devices)
PCIDeviceInfo *info;
info = qemu_mallocz(sizeof(*info));
+ info->qdev.name = qemu_strdup(name);
+ info->qdev.size = size;
info->init = init;
info->qdev.init = pci_qdev_init;
info->qdev.bus_type = BUS_TYPE_PCI;
- qdev_register(name, size, &info->qdev);
+ qdev_register(&info->qdev);
}
PCIDevice *pci_create_simple(PCIBus *bus, int devfn, const char *name)
}
static I2CSlaveInfo pxa2xx_i2c_slave_info = {
+ .qdev.name = "pxa2xx-i2c-slave",
+ .qdev.size = sizeof(PXA2xxI2CSlaveState),
.init = pxa2xx_i2c_slave_init,
.event = pxa2xx_i2c_event,
.recv = pxa2xx_i2c_rx,
static void pxa2xx_register_devices(void)
{
- i2c_register_slave("pxa2xx-i2c-slave", sizeof(PXA2xxI2CSlaveState),
- &pxa2xx_i2c_slave_info);
+ i2c_register_slave(&pxa2xx_i2c_slave_info);
sysbus_register_dev("pxa2xx-ssp", sizeof(PXA2xxSSPState), pxa2xx_ssp_init);
}
};
struct DeviceType {
- const char *name;
DeviceInfo *info;
- int size;
DeviceType *next;
};
static DeviceType *device_type_list;
/* Register a new device type. */
-void qdev_register(const char *name, int size, DeviceInfo *info)
+void qdev_register(DeviceInfo *info)
{
DeviceType *t;
- assert(size >= sizeof(DeviceState));
+ assert(info->size >= sizeof(DeviceState));
t = qemu_mallocz(sizeof(DeviceType));
t->next = device_type_list;
device_type_list = t;
- t->name = qemu_strdup(name);
- t->size = size;
t->info = info;
}
DeviceState *dev;
for (t = device_type_list; t; t = t->next) {
- if (strcmp(t->name, name) == 0) {
+ if (strcmp(t->info->name, name) == 0) {
break;
}
}
hw_error("Unknown device '%s'\n", name);
}
- dev = qemu_mallocz(t->size);
+ dev = qemu_mallocz(t->info->size);
dev->type = t;
if (!bus) {
static int next_serial;
static int next_virtconsole;
/* FIXME: This is a nasty hack that needs to go away. */
- if (strncmp(dev->type->name, "virtio", 6) == 0) {
+ if (strncmp(dev->type->info->name, "virtio", 6) == 0) {
return virtcon_hds[next_virtconsole++];
} else {
return serial_hds[next_serial++];
{
DeviceProperty *prop;
BusState *child;
- qdev_printf("dev: %s\n", dev->type->name);
+ qdev_printf("dev: %s\n", dev->type->info->name);
indent += 2;
if (dev->num_gpio_in) {
qdev_printf("gpio-in %d\n", dev->num_gpio_in);
break;
case PROP_TYPE_DEV:
qdev_printf("prop-dev %s %s\n", prop->name,
- ((DeviceState *)prop->value.ptr)->type->name);
+ ((DeviceState *)prop->value.ptr)->type->info->name);
break;
default:
qdev_printf("prop-unknown%d %s\n", prop->type, prop->name);
int unit);
struct DeviceInfo {
+ const char *name;
+ size_t size;
+ DevicePropList *props;
+
+ /* Private to qdev / bus. */
qdev_initfn init;
BusType bus_type;
- DevicePropList *props;
};
-void qdev_register(const char *name, int size, DeviceInfo *info);
+void qdev_register(DeviceInfo *info);
/* Register device properties. */
/* GPIO inputs also double as IRQ sinks. */
t->init(dev);
}
-void smbus_register_device(const char *name, int size, SMBusDeviceInfo *info)
+void smbus_register_device(SMBusDeviceInfo *info)
{
- assert(size >= sizeof(SMBusDevice));
+ assert(info->i2c.qdev.size >= sizeof(SMBusDevice));
info->i2c.init = smbus_device_init;
info->i2c.event = smbus_i2c_event;
info->i2c.recv = smbus_i2c_recv;
info->i2c.send = smbus_i2c_send;
- i2c_register_slave(name, size, &info->i2c);
+ i2c_register_slave(&info->i2c);
}
/* Master device commands. */
uint8_t (*read_data)(SMBusDevice *dev, uint8_t cmd, int n);
} SMBusDeviceInfo;
-void smbus_register_device(const char *name, int size, SMBusDeviceInfo *info);
+void smbus_register_device(SMBusDeviceInfo *info);
/* Master device commands. */
void smbus_quick_command(i2c_bus *bus, int addr, int read);
}
static SMBusDeviceInfo smbus_eeprom_info = {
+ .i2c.qdev.name = "smbus-eeprom",
+ .i2c.qdev.size = sizeof(SMBusEEPROMDevice),
.init = smbus_eeprom_init,
.quick_cmd = eeprom_quick_cmd,
.send_byte = eeprom_send_byte,
static void smbus_eeprom_register_devices(void)
{
- smbus_register_device("smbus-eeprom", sizeof(SMBusEEPROMDevice),
- &smbus_eeprom_info);
+ smbus_register_device(&smbus_eeprom_info);
}
device_init(smbus_eeprom_register_devices)
machine_init(spitz_machine_init);
static SSISlaveInfo corgi_ssp_info = {
+ .qdev.name = "corgi-ssp",
+ .qdev.size = sizeof(CorgiSSPState),
.init = corgi_ssp_init,
.transfer = corgi_ssp_transfer
};
static SSISlaveInfo spitz_lcdtg_info = {
+ .qdev.name = "spitz-lcdtg",
+ .qdev.size = sizeof(SpitzLCDTG),
.init = spitz_lcdtg_init,
.transfer = spitz_lcdtg_transfer
};
static void spitz_register_devices(void)
{
- ssi_register_slave("corgi-ssp", sizeof(CorgiSSPState), &corgi_ssp_info);
- ssi_register_slave("spitz-lcdtg", sizeof(SpitzLCDTG), &spitz_lcdtg_info);
+ ssi_register_slave(&corgi_ssp_info);
+ ssi_register_slave(&spitz_lcdtg_info);
}
device_init(spitz_register_devices)
}
static I2CSlaveInfo ssd0303_info = {
+ .qdev.name = "ssd0303",
+ .qdev.size = sizeof(ssd0303_state),
.init = ssd0303_init,
.event = ssd0303_event,
.recv = ssd0303_recv,
static void ssd0303_register_devices(void)
{
- i2c_register_slave("ssd0303", sizeof(ssd0303_state), &ssd0303_info);
+ i2c_register_slave(&ssd0303_info);
}
device_init(ssd0303_register_devices)
}
static SSISlaveInfo ssd0323_info = {
+ .qdev.name = "ssd0323",
+ .qdev.size = sizeof(ssd0323_state),
.init = ssd0323_init,
.transfer = ssd0323_transfer
};
static void ssd03232_register_devices(void)
{
- ssi_register_slave("ssd0323", sizeof(ssd0323_state), &ssd0323_info);
+ ssi_register_slave(&ssd0323_info);
}
device_init(ssd03232_register_devices)
}
static SSISlaveInfo ssi_sd_info = {
+ .qdev.name = "ssi-sd",
+ .qdev.size = sizeof(ssi_sd_state),
.init = ssi_sd_init,
.transfer = ssi_sd_transfer
};
static void ssi_sd_register_devices(void)
{
- ssi_register_slave("ssi-sd", sizeof(ssi_sd_state), &ssi_sd_info);
+ ssi_register_slave(&ssi_sd_info);
}
device_init(ssi_sd_register_devices)
info->init(s);
}
-void ssi_register_slave(const char *name, int size, SSISlaveInfo *info)
+void ssi_register_slave(SSISlaveInfo *info)
{
- assert(size >= sizeof(SSISlave));
+ assert(info->qdev.size >= sizeof(SSISlave));
info->qdev.init = ssi_slave_init;
info->qdev.bus_type = BUS_TYPE_SSI;
- qdev_register(name, size, &info->qdev);
+ qdev_register(&info->qdev);
}
DeviceState *ssi_create_slave(SSIBus *bus, const char *name)
#define SSI_SLAVE_FROM_QDEV(dev) DO_UPCAST(SSISlave, qdev, dev)
#define FROM_SSI_SLAVE(type, dev) DO_UPCAST(type, ssidev, dev)
-void ssi_register_slave(const char *name, int size, SSISlaveInfo *info);
+void ssi_register_slave(SSISlaveInfo *info);
DeviceState *ssi_create_slave(SSIBus *bus, const char *name);
machine_init(stellaris_machine_init);
static SSISlaveInfo stellaris_ssi_bus_info = {
+ .qdev.name = "evb6965-ssi",
+ .qdev.size = sizeof(stellaris_ssi_bus_state),
.init = stellaris_ssi_bus_init,
.transfer = stellaris_ssi_bus_transfer
};
stellaris_gptm_init);
sysbus_register_dev("stellaris-adc", sizeof(stellaris_adc_state),
stellaris_adc_init);
- ssi_register_slave("evb6965-ssi", sizeof(stellaris_ssi_bus_state),
- &stellaris_ssi_bus_info);
+ ssi_register_slave(&stellaris_ssi_bus_info);
}
device_init(stellaris_register_devices)
static SysBusDeviceInfo syborg_timer_info = {
.init = syborg_timer_init,
- .qdev = {
- .props = (DevicePropList[]) {
- {.name = "frequency", .type = PROP_TYPE_INT},
- {.name = NULL}
- }
+ .qdev.name = "syborg,timer",
+ .qdev.size = sizeof(SyborgTimerState),
+ .qdev.props = (DevicePropList[]) {
+ {.name = "frequency", .type = PROP_TYPE_INT},
+ {.name = NULL}
}
};
static void syborg_timer_register_devices(void)
{
- sysbus_register_withprop("syborg,timer", sizeof(SyborgTimerState),
- &syborg_timer_info);
+ sysbus_register_withprop(&syborg_timer_info);
}
device_init(syborg_timer_register_devices)
info->init(sysbus_from_qdev(dev));
}
-void sysbus_register_withprop(const char *name, size_t size,
- SysBusDeviceInfo *info)
+void sysbus_register_withprop(SysBusDeviceInfo *info)
{
info->qdev.init = sysbus_device_init;
info->qdev.bus_type = BUS_TYPE_SYSTEM;
- assert(size >= sizeof(SysBusDevice));
- qdev_register(name, size, &info->qdev);
+ assert(info->qdev.size >= sizeof(SysBusDevice));
+ qdev_register(&info->qdev);
}
void sysbus_register_dev(const char *name, size_t size, sysbus_initfn init)
SysBusDeviceInfo *info;
info = qemu_mallocz(sizeof(*info));
+ info->qdev.name = qemu_strdup(name);
+ info->qdev.size = size;
info->init = init;
- sysbus_register_withprop(name, size, info);
+ sysbus_register_withprop(info);
}
DeviceState *sysbus_create_varargs(const char *name,
} SysBusDeviceInfo;
void sysbus_register_dev(const char *name, size_t size, sysbus_initfn init);
-void sysbus_register_withprop(const char *name, size_t size,
- SysBusDeviceInfo *info);
+void sysbus_register_withprop(SysBusDeviceInfo *info);
void *sysbus_new(void);
void sysbus_init_mmio(SysBusDevice *dev, target_phys_addr_t size, int iofunc);
void sysbus_init_mmio_cb(SysBusDevice *dev, target_phys_addr_t size,
}
static I2CSlaveInfo tmp105_info = {
+ .qdev.name = "tmp105",
+ .qdev.size = sizeof(TMP105State),
.init = tmp105_init,
.event = tmp105_event,
.recv = tmp105_rx,
static void tmp105_register_devices(void)
{
- i2c_register_slave("tmp105", sizeof(TMP105State), &tmp105_info);
+ i2c_register_slave(&tmp105_info);
}
device_init(tmp105_register_devices)
machine_init(tosapda_machine_init);
static I2CSlaveInfo tosa_dac_info = {
+ .qdev.name = "tosa_dac",
+ .qdev.size = sizeof(TosaDACState),
.init = tosa_dac_init,
.event = tosa_dac_event,
.recv = tosa_dac_recv,
};
static SSISlaveInfo tosa_ssp_info = {
+ .qdev.name = "tosa-ssp",
+ .qdev.size = sizeof(SSISlave),
.init = tosa_ssp_init,
.transfer = tosa_ssp_tansfer
};
static void tosa_register_devices(void)
{
- i2c_register_slave("tosa_dac", sizeof(TosaDACState), &tosa_dac_info);
- ssi_register_slave("tosa-ssp", sizeof(SSISlave), &tosa_ssp_info);
+ i2c_register_slave(&tosa_dac_info);
+ ssi_register_slave(&tosa_ssp_info);
}
device_init(tosa_register_devices)
}
static I2CSlaveInfo twl92230_info = {
+ .qdev.name ="twl92230",
+ .qdev.size = sizeof(MenelausState),
.init = twl92230_init,
.event = menelaus_event,
.recv = menelaus_rx,
static void twl92230_register_devices(void)
{
- i2c_register_slave("twl92230", sizeof(MenelausState), &twl92230_info);
+ i2c_register_slave(&twl92230_info);
}
device_init(twl92230_register_devices)
}
static I2CSlaveInfo wm8750_info = {
+ .qdev.name = "wm8750",
+ .qdev.size = sizeof(WM8750State),
.init = wm8750_init,
.event = wm8750_event,
.recv = wm8750_rx,
static void wm8750_register_devices(void)
{
- i2c_register_slave("wm8750", sizeof(WM8750State), &wm8750_info);
+ i2c_register_slave(&wm8750_info);
}
device_init(wm8750_register_devices)