1 /* 2 * Dynamic device configuration and creation. 3 * 4 * Copyright (c) 2009 CodeSourcery 5 * 6 * This library is free software; you can redistribute it and/or 7 * modify it under the terms of the GNU Lesser General Public 8 * License as published by the Free Software Foundation; either 9 * version 2 of the License, or (at your option) any later version. 10 * 11 * This library is distributed in the hope that it will be useful, 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 14 * Lesser General Public License for more details. 15 * 16 * You should have received a copy of the GNU Lesser General Public 17 * License along with this library; if not, write to the Free Software 18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301 USA 19 */ 20 21 /* The theory here is that it should be possible to create a machine without 22 knowledge of specific devices. Historically board init routines have 23 passed a bunch of arguments to each device, requiring the board know 24 exactly which device it is dealing with. This file provides an abstract 25 API for device configuration and initialization. Devices will generally 26 inherit from a particular bus (e.g. PCI or I2C) rather than 27 this API directly. */ 28 29 #include "net.h" 30 #include "qdev.h" 31 #include "sysemu.h" 32 #include "monitor.h" 33 34 struct DeviceProperty { 35 const char *name; 36 DevicePropType type; 37 union { 38 uint64_t i; 39 void *ptr; 40 } value; 41 DeviceProperty *next; 42 }; 43 44 struct DeviceType { 45 DeviceInfo *info; 46 DeviceType *next; 47 }; 48 49 /* This is a nasty hack to allow passing a NULL bus to qdev_create. */ 50 static BusState *main_system_bus; 51 52 static DeviceType *device_type_list; 53 54 /* Register a new device type. */ 55 void qdev_register(DeviceInfo *info) 56 { 57 DeviceType *t; 58 59 assert(info->size >= sizeof(DeviceState)); 60 61 t = qemu_mallocz(sizeof(DeviceType)); 62 t->next = device_type_list; 63 device_type_list = t; 64 t->info = info; 65 } 66 67 /* Create a new device. This only initializes the device state structure 68 and allows properties to be set. qdev_init should be called to 69 initialize the actual device emulation. */ 70 DeviceState *qdev_create(BusState *bus, const char *name) 71 { 72 DeviceType *t; 73 DeviceState *dev; 74 75 for (t = device_type_list; t; t = t->next) { 76 if (strcmp(t->info->name, name) == 0) { 77 break; 78 } 79 } 80 if (!t) { 81 hw_error("Unknown device '%s'\n", name); 82 } 83 84 dev = qemu_mallocz(t->info->size); 85 dev->type = t; 86 87 if (!bus) { 88 /* ???: This assumes system busses have no additional state. */ 89 if (!main_system_bus) { 90 main_system_bus = qbus_create(BUS_TYPE_SYSTEM, sizeof(BusState), 91 NULL, "main-system-bus"); 92 } 93 bus = main_system_bus; 94 } 95 if (t->info->bus_type != bus->type) { 96 /* TODO: Print bus type names. */ 97 hw_error("Device '%s' on wrong bus type (%d/%d)", name, 98 t->info->bus_type, bus->type); 99 } 100 dev->parent_bus = bus; 101 QLIST_INSERT_HEAD(&bus->children, dev, sibling); 102 return dev; 103 } 104 105 /* Initialize a device. Device properties should be set before calling 106 this function. IRQs and MMIO regions should be connected/mapped after 107 calling this function. */ 108 void qdev_init(DeviceState *dev) 109 { 110 dev->type->info->init(dev, dev->type->info); 111 } 112 113 /* Unlink device from bus and free the structure. */ 114 void qdev_free(DeviceState *dev) 115 { 116 QLIST_REMOVE(dev, sibling); 117 qemu_free(dev); 118 } 119 120 static DeviceProperty *create_prop(DeviceState *dev, const char *name, 121 DevicePropType type) 122 { 123 DeviceProperty *prop; 124 125 /* TODO: Check for duplicate properties. */ 126 prop = qemu_mallocz(sizeof(*prop)); 127 prop->name = qemu_strdup(name); 128 prop->type = type; 129 prop->next = dev->props; 130 dev->props = prop; 131 132 return prop; 133 } 134 135 void qdev_set_prop_int(DeviceState *dev, const char *name, uint64_t value) 136 { 137 DeviceProperty *prop; 138 139 prop = create_prop(dev, name, PROP_TYPE_INT); 140 prop->value.i = value; 141 } 142 143 void qdev_set_prop_dev(DeviceState *dev, const char *name, DeviceState *value) 144 { 145 DeviceProperty *prop; 146 147 prop = create_prop(dev, name, PROP_TYPE_DEV); 148 prop->value.ptr = value; 149 } 150 151 void qdev_set_prop_ptr(DeviceState *dev, const char *name, void *value) 152 { 153 DeviceProperty *prop; 154 155 prop = create_prop(dev, name, PROP_TYPE_PTR); 156 prop->value.ptr = value; 157 } 158 159 void qdev_set_netdev(DeviceState *dev, NICInfo *nd) 160 { 161 assert(!dev->nd); 162 dev->nd = nd; 163 } 164 165 166 /* Get a character (serial) device interface. */ 167 CharDriverState *qdev_init_chardev(DeviceState *dev) 168 { 169 static int next_serial; 170 static int next_virtconsole; 171 /* FIXME: This is a nasty hack that needs to go away. */ 172 if (strncmp(dev->type->info->name, "virtio", 6) == 0) { 173 return virtcon_hds[next_virtconsole++]; 174 } else { 175 return serial_hds[next_serial++]; 176 } 177 } 178 179 BusState *qdev_get_parent_bus(DeviceState *dev) 180 { 181 return dev->parent_bus; 182 } 183 184 static DeviceProperty *find_prop(DeviceState *dev, const char *name, 185 DevicePropType type) 186 { 187 DeviceProperty *prop; 188 189 for (prop = dev->props; prop; prop = prop->next) { 190 if (strcmp(prop->name, name) == 0) { 191 assert (prop->type == type); 192 return prop; 193 } 194 } 195 return NULL; 196 } 197 198 uint64_t qdev_get_prop_int(DeviceState *dev, const char *name, uint64_t def) 199 { 200 DeviceProperty *prop; 201 202 prop = find_prop(dev, name, PROP_TYPE_INT); 203 if (!prop) { 204 return def; 205 } 206 207 return prop->value.i; 208 } 209 210 void *qdev_get_prop_ptr(DeviceState *dev, const char *name) 211 { 212 DeviceProperty *prop; 213 214 prop = find_prop(dev, name, PROP_TYPE_PTR); 215 assert(prop); 216 return prop->value.ptr; 217 } 218 219 DeviceState *qdev_get_prop_dev(DeviceState *dev, const char *name) 220 { 221 DeviceProperty *prop; 222 223 prop = find_prop(dev, name, PROP_TYPE_DEV); 224 if (!prop) { 225 return NULL; 226 } 227 return prop->value.ptr; 228 } 229 230 void qdev_init_gpio_in(DeviceState *dev, qemu_irq_handler handler, int n) 231 { 232 assert(dev->num_gpio_in == 0); 233 dev->num_gpio_in = n; 234 dev->gpio_in = qemu_allocate_irqs(handler, dev, n); 235 } 236 237 void qdev_init_gpio_out(DeviceState *dev, qemu_irq *pins, int n) 238 { 239 assert(dev->num_gpio_out == 0); 240 dev->num_gpio_out = n; 241 dev->gpio_out = pins; 242 } 243 244 qemu_irq qdev_get_gpio_in(DeviceState *dev, int n) 245 { 246 assert(n >= 0 && n < dev->num_gpio_in); 247 return dev->gpio_in[n]; 248 } 249 250 void qdev_connect_gpio_out(DeviceState * dev, int n, qemu_irq pin) 251 { 252 assert(n >= 0 && n < dev->num_gpio_out); 253 dev->gpio_out[n] = pin; 254 } 255 256 VLANClientState *qdev_get_vlan_client(DeviceState *dev, 257 NetCanReceive *can_receive, 258 NetReceive *receive, 259 NetReceiveIOV *receive_iov, 260 NetCleanup *cleanup, 261 void *opaque) 262 { 263 NICInfo *nd = dev->nd; 264 assert(nd); 265 return qemu_new_vlan_client(nd->vlan, nd->model, nd->name, can_receive, 266 receive, receive_iov, cleanup, opaque); 267 } 268 269 270 void qdev_get_macaddr(DeviceState *dev, uint8_t *macaddr) 271 { 272 memcpy(macaddr, dev->nd->macaddr, 6); 273 } 274 275 static int next_block_unit[IF_COUNT]; 276 277 /* Get a block device. This should only be used for single-drive devices 278 (e.g. SD/Floppy/MTD). Multi-disk devices (scsi/ide) should use the 279 appropriate bus. */ 280 BlockDriverState *qdev_init_bdrv(DeviceState *dev, BlockInterfaceType type) 281 { 282 int unit = next_block_unit[type]++; 283 int index; 284 285 index = drive_get_index(type, 0, unit); 286 if (index == -1) { 287 return NULL; 288 } 289 return drives_table[index].bdrv; 290 } 291 292 BusState *qdev_get_child_bus(DeviceState *dev, const char *name) 293 { 294 BusState *bus; 295 296 QLIST_FOREACH(bus, &dev->child_bus, sibling) { 297 if (strcmp(name, bus->name) == 0) { 298 return bus; 299 } 300 } 301 return NULL; 302 } 303 304 static int next_scsi_bus; 305 306 /* Create a scsi bus, and attach devices to it. */ 307 /* TODO: Actually create a scsi bus for hotplug to use. */ 308 void scsi_bus_new(DeviceState *host, SCSIAttachFn attach) 309 { 310 int bus = next_scsi_bus++; 311 int unit; 312 int index; 313 314 for (unit = 0; unit < MAX_SCSI_DEVS; unit++) { 315 index = drive_get_index(IF_SCSI, bus, unit); 316 if (index == -1) { 317 continue; 318 } 319 attach(host, drives_table[index].bdrv, unit); 320 } 321 } 322 323 BusState *qbus_create(BusType type, size_t size, 324 DeviceState *parent, const char *name) 325 { 326 BusState *bus; 327 328 bus = qemu_mallocz(size); 329 bus->type = type; 330 bus->parent = parent; 331 bus->name = qemu_strdup(name); 332 QLIST_INIT(&bus->children); 333 if (parent) { 334 QLIST_INSERT_HEAD(&parent->child_bus, bus, sibling); 335 } 336 return bus; 337 } 338 339 static const char *bus_type_names[] = { 340 [ BUS_TYPE_SYSTEM ] = "System", 341 [ BUS_TYPE_PCI ] = "PCI", 342 [ BUS_TYPE_SCSI ] = "SCSI", 343 [ BUS_TYPE_I2C ] = "I2C", 344 [ BUS_TYPE_SSI ] = "SSI", 345 }; 346 347 #define qdev_printf(fmt, ...) monitor_printf(mon, "%*s" fmt, indent, "", ## __VA_ARGS__) 348 static void qbus_print(Monitor *mon, BusState *bus, int indent); 349 350 static void qdev_print(Monitor *mon, DeviceState *dev, int indent) 351 { 352 DeviceProperty *prop; 353 BusState *child; 354 qdev_printf("dev: %s\n", dev->type->info->name); 355 indent += 2; 356 if (dev->num_gpio_in) { 357 qdev_printf("gpio-in %d\n", dev->num_gpio_in); 358 } 359 if (dev->num_gpio_out) { 360 qdev_printf("gpio-out %d\n", dev->num_gpio_out); 361 } 362 for (prop = dev->props; prop; prop = prop->next) { 363 switch (prop->type) { 364 case PROP_TYPE_INT: 365 qdev_printf("prop-int %s 0x%" PRIx64 "\n", prop->name, 366 prop->value.i); 367 break; 368 case PROP_TYPE_PTR: 369 qdev_printf("prop-ptr %s\n", prop->name); 370 break; 371 case PROP_TYPE_DEV: 372 qdev_printf("prop-dev %s %s\n", prop->name, 373 ((DeviceState *)prop->value.ptr)->type->info->name); 374 break; 375 default: 376 qdev_printf("prop-unknown%d %s\n", prop->type, prop->name); 377 break; 378 } 379 } 380 switch (dev->parent_bus->type) { 381 case BUS_TYPE_SYSTEM: 382 sysbus_dev_print(mon, dev, indent); 383 break; 384 default: 385 break; 386 } 387 QLIST_FOREACH(child, &dev->child_bus, sibling) { 388 qbus_print(mon, child, indent); 389 } 390 } 391 392 static void qbus_print(Monitor *mon, BusState *bus, int indent) 393 { 394 struct DeviceState *dev; 395 396 qdev_printf("bus: %s\n", bus->name); 397 indent += 2; 398 qdev_printf("type %s\n", bus_type_names[bus->type]); 399 QLIST_FOREACH(dev, &bus->children, sibling) { 400 qdev_print(mon, dev, indent); 401 } 402 } 403 #undef qdev_printf 404 405 void do_info_qtree(Monitor *mon) 406 { 407 if (main_system_bus) 408 qbus_print(mon, main_system_bus, 0); 409 } 410