qemu/hw/usb/bus.c
<<
>>
Prefs
   1#include "qemu/osdep.h"
   2#include "hw/qdev-properties.h"
   3#include "hw/usb.h"
   4#include "qapi/error.h"
   5#include "qemu/error-report.h"
   6#include "qemu/module.h"
   7#include "sysemu/sysemu.h"
   8#include "migration/vmstate.h"
   9#include "monitor/monitor.h"
  10#include "trace.h"
  11#include "qemu/cutils.h"
  12
  13static void usb_bus_dev_print(Monitor *mon, DeviceState *qdev, int indent);
  14
  15static char *usb_get_dev_path(DeviceState *dev);
  16static char *usb_get_fw_dev_path(DeviceState *qdev);
  17static void usb_qdev_unrealize(DeviceState *qdev, Error **errp);
  18
  19static Property usb_props[] = {
  20    DEFINE_PROP_STRING("port", USBDevice, port_path),
  21    DEFINE_PROP_STRING("serial", USBDevice, serial),
  22    DEFINE_PROP_BIT("full-path", USBDevice, flags,
  23                    USB_DEV_FLAG_FULL_PATH, true),
  24    DEFINE_PROP_BIT("msos-desc", USBDevice, flags,
  25                    USB_DEV_FLAG_MSOS_DESC_ENABLE, true),
  26    DEFINE_PROP_END_OF_LIST()
  27};
  28
  29static void usb_bus_class_init(ObjectClass *klass, void *data)
  30{
  31    BusClass *k = BUS_CLASS(klass);
  32    HotplugHandlerClass *hc = HOTPLUG_HANDLER_CLASS(klass);
  33
  34    k->print_dev = usb_bus_dev_print;
  35    k->get_dev_path = usb_get_dev_path;
  36    k->get_fw_dev_path = usb_get_fw_dev_path;
  37    hc->unplug = qdev_simple_device_unplug_cb;
  38}
  39
  40static const TypeInfo usb_bus_info = {
  41    .name = TYPE_USB_BUS,
  42    .parent = TYPE_BUS,
  43    .instance_size = sizeof(USBBus),
  44    .class_init = usb_bus_class_init,
  45    .interfaces = (InterfaceInfo[]) {
  46        { TYPE_HOTPLUG_HANDLER },
  47        { }
  48    }
  49};
  50
  51static int next_usb_bus = 0;
  52static QTAILQ_HEAD(, USBBus) busses = QTAILQ_HEAD_INITIALIZER(busses);
  53
  54static int usb_device_post_load(void *opaque, int version_id)
  55{
  56    USBDevice *dev = opaque;
  57
  58    if (dev->state == USB_STATE_NOTATTACHED) {
  59        dev->attached = false;
  60    } else {
  61        dev->attached = true;
  62    }
  63    return 0;
  64}
  65
  66const VMStateDescription vmstate_usb_device = {
  67    .name = "USBDevice",
  68    .version_id = 1,
  69    .minimum_version_id = 1,
  70    .post_load = usb_device_post_load,
  71    .fields = (VMStateField[]) {
  72        VMSTATE_UINT8(addr, USBDevice),
  73        VMSTATE_INT32(state, USBDevice),
  74        VMSTATE_INT32(remote_wakeup, USBDevice),
  75        VMSTATE_INT32(setup_state, USBDevice),
  76        VMSTATE_INT32(setup_len, USBDevice),
  77        VMSTATE_INT32(setup_index, USBDevice),
  78        VMSTATE_UINT8_ARRAY(setup_buf, USBDevice, 8),
  79        VMSTATE_END_OF_LIST(),
  80    }
  81};
  82
  83void usb_bus_new(USBBus *bus, size_t bus_size,
  84                 USBBusOps *ops, DeviceState *host)
  85{
  86    qbus_create_inplace(bus, bus_size, TYPE_USB_BUS, host, NULL);
  87    qbus_set_bus_hotplug_handler(BUS(bus), &error_abort);
  88    bus->ops = ops;
  89    bus->busnr = next_usb_bus++;
  90    QTAILQ_INIT(&bus->free);
  91    QTAILQ_INIT(&bus->used);
  92    QTAILQ_INSERT_TAIL(&busses, bus, next);
  93}
  94
  95void usb_bus_release(USBBus *bus)
  96{
  97    assert(next_usb_bus > 0);
  98
  99    QTAILQ_REMOVE(&busses, bus, next);
 100}
 101
 102USBBus *usb_bus_find(int busnr)
 103{
 104    USBBus *bus;
 105
 106    if (-1 == busnr)
 107        return QTAILQ_FIRST(&busses);
 108    QTAILQ_FOREACH(bus, &busses, next) {
 109        if (bus->busnr == busnr)
 110            return bus;
 111    }
 112    return NULL;
 113}
 114
 115static void usb_device_realize(USBDevice *dev, Error **errp)
 116{
 117    USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
 118
 119    if (klass->realize) {
 120        klass->realize(dev, errp);
 121    }
 122}
 123
 124USBDevice *usb_device_find_device(USBDevice *dev, uint8_t addr)
 125{
 126    USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
 127    if (klass->find_device) {
 128        return klass->find_device(dev, addr);
 129    }
 130    return NULL;
 131}
 132
 133static void usb_device_unrealize(USBDevice *dev, Error **errp)
 134{
 135    USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
 136
 137    if (klass->unrealize) {
 138        klass->unrealize(dev, errp);
 139    }
 140}
 141
 142void usb_device_cancel_packet(USBDevice *dev, USBPacket *p)
 143{
 144    USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
 145    if (klass->cancel_packet) {
 146        klass->cancel_packet(dev, p);
 147    }
 148}
 149
 150void usb_device_handle_attach(USBDevice *dev)
 151{
 152    USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
 153    if (klass->handle_attach) {
 154        klass->handle_attach(dev);
 155    }
 156}
 157
 158void usb_device_handle_reset(USBDevice *dev)
 159{
 160    USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
 161    if (klass->handle_reset) {
 162        klass->handle_reset(dev);
 163    }
 164}
 165
 166void usb_device_handle_control(USBDevice *dev, USBPacket *p, int request,
 167                               int value, int index, int length, uint8_t *data)
 168{
 169    USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
 170    if (klass->handle_control) {
 171        klass->handle_control(dev, p, request, value, index, length, data);
 172    }
 173}
 174
 175void usb_device_handle_data(USBDevice *dev, USBPacket *p)
 176{
 177    USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
 178    if (klass->handle_data) {
 179        klass->handle_data(dev, p);
 180    }
 181}
 182
 183const char *usb_device_get_product_desc(USBDevice *dev)
 184{
 185    USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
 186    return klass->product_desc;
 187}
 188
 189const USBDesc *usb_device_get_usb_desc(USBDevice *dev)
 190{
 191    USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
 192    if (dev->usb_desc) {
 193        return dev->usb_desc;
 194    }
 195    return klass->usb_desc;
 196}
 197
 198void usb_device_set_interface(USBDevice *dev, int interface,
 199                              int alt_old, int alt_new)
 200{
 201    USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
 202    if (klass->set_interface) {
 203        klass->set_interface(dev, interface, alt_old, alt_new);
 204    }
 205}
 206
 207void usb_device_flush_ep_queue(USBDevice *dev, USBEndpoint *ep)
 208{
 209    USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
 210    if (klass->flush_ep_queue) {
 211        klass->flush_ep_queue(dev, ep);
 212    }
 213}
 214
 215void usb_device_ep_stopped(USBDevice *dev, USBEndpoint *ep)
 216{
 217    USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
 218    if (klass->ep_stopped) {
 219        klass->ep_stopped(dev, ep);
 220    }
 221}
 222
 223int usb_device_alloc_streams(USBDevice *dev, USBEndpoint **eps, int nr_eps,
 224                             int streams)
 225{
 226    USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
 227    if (klass->alloc_streams) {
 228        return klass->alloc_streams(dev, eps, nr_eps, streams);
 229    }
 230    return 0;
 231}
 232
 233void usb_device_free_streams(USBDevice *dev, USBEndpoint **eps, int nr_eps)
 234{
 235    USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
 236    if (klass->free_streams) {
 237        klass->free_streams(dev, eps, nr_eps);
 238    }
 239}
 240
 241static void usb_qdev_realize(DeviceState *qdev, Error **errp)
 242{
 243    USBDevice *dev = USB_DEVICE(qdev);
 244    Error *local_err = NULL;
 245
 246    pstrcpy(dev->product_desc, sizeof(dev->product_desc),
 247            usb_device_get_product_desc(dev));
 248    dev->auto_attach = 1;
 249    QLIST_INIT(&dev->strings);
 250    usb_ep_init(dev);
 251
 252    usb_claim_port(dev, &local_err);
 253    if (local_err) {
 254        error_propagate(errp, local_err);
 255        return;
 256    }
 257
 258    usb_device_realize(dev, &local_err);
 259    if (local_err) {
 260        usb_release_port(dev);
 261        error_propagate(errp, local_err);
 262        return;
 263    }
 264
 265    if (dev->auto_attach) {
 266        usb_device_attach(dev, &local_err);
 267        if (local_err) {
 268            usb_qdev_unrealize(qdev, NULL);
 269            error_propagate(errp, local_err);
 270            return;
 271        }
 272    }
 273}
 274
 275static void usb_qdev_unrealize(DeviceState *qdev, Error **errp)
 276{
 277    USBDevice *dev = USB_DEVICE(qdev);
 278    USBDescString *s, *next;
 279
 280    QLIST_FOREACH_SAFE(s, &dev->strings, next, next) {
 281        QLIST_REMOVE(s, next);
 282        g_free(s->str);
 283        g_free(s);
 284    }
 285
 286    if (dev->attached) {
 287        usb_device_detach(dev);
 288    }
 289    usb_device_unrealize(dev, errp);
 290    if (dev->port) {
 291        usb_release_port(dev);
 292    }
 293}
 294
 295typedef struct LegacyUSBFactory
 296{
 297    const char *name;
 298    const char *usbdevice_name;
 299    USBDevice *(*usbdevice_init)(USBBus *bus, const char *params);
 300} LegacyUSBFactory;
 301
 302static GSList *legacy_usb_factory;
 303
 304void usb_legacy_register(const char *typename, const char *usbdevice_name,
 305                         USBDevice *(*usbdevice_init)(USBBus *bus,
 306                                                      const char *params))
 307{
 308    if (usbdevice_name) {
 309        LegacyUSBFactory *f = g_malloc0(sizeof(*f));
 310        f->name = typename;
 311        f->usbdevice_name = usbdevice_name;
 312        f->usbdevice_init = usbdevice_init;
 313        legacy_usb_factory = g_slist_append(legacy_usb_factory, f);
 314    }
 315}
 316
 317USBDevice *usb_create(USBBus *bus, const char *name)
 318{
 319    DeviceState *dev;
 320
 321    dev = qdev_create(&bus->qbus, name);
 322    return USB_DEVICE(dev);
 323}
 324
 325static USBDevice *usb_try_create_simple(USBBus *bus, const char *name,
 326                                        Error **errp)
 327{
 328    Error *err = NULL;
 329    USBDevice *dev;
 330
 331    dev = USB_DEVICE(qdev_try_create(&bus->qbus, name));
 332    if (!dev) {
 333        error_setg(errp, "Failed to create USB device '%s'", name);
 334        return NULL;
 335    }
 336    object_property_set_bool(OBJECT(dev), true, "realized", &err);
 337    if (err) {
 338        error_propagate_prepend(errp, err,
 339                                "Failed to initialize USB device '%s': ",
 340                                name);
 341        return NULL;
 342    }
 343    return dev;
 344}
 345
 346USBDevice *usb_create_simple(USBBus *bus, const char *name)
 347{
 348    return usb_try_create_simple(bus, name, &error_abort);
 349}
 350
 351static void usb_fill_port(USBPort *port, void *opaque, int index,
 352                          USBPortOps *ops, int speedmask)
 353{
 354    port->opaque = opaque;
 355    port->index = index;
 356    port->ops = ops;
 357    port->speedmask = speedmask;
 358    usb_port_location(port, NULL, index + 1);
 359}
 360
 361void usb_register_port(USBBus *bus, USBPort *port, void *opaque, int index,
 362                       USBPortOps *ops, int speedmask)
 363{
 364    usb_fill_port(port, opaque, index, ops, speedmask);
 365    QTAILQ_INSERT_TAIL(&bus->free, port, next);
 366    bus->nfree++;
 367}
 368
 369void usb_register_companion(const char *masterbus, USBPort *ports[],
 370                            uint32_t portcount, uint32_t firstport,
 371                            void *opaque, USBPortOps *ops, int speedmask,
 372                            Error **errp)
 373{
 374    USBBus *bus;
 375    int i;
 376
 377    QTAILQ_FOREACH(bus, &busses, next) {
 378        if (strcmp(bus->qbus.name, masterbus) == 0) {
 379            break;
 380        }
 381    }
 382
 383    if (!bus) {
 384        error_setg(errp, "USB bus '%s' not found", masterbus);
 385        return;
 386    }
 387    if (!bus->ops->register_companion) {
 388        error_setg(errp, "Can't use USB bus '%s' as masterbus,"
 389                   " it doesn't support companion controllers",
 390                   masterbus);
 391        return;
 392    }
 393
 394    for (i = 0; i < portcount; i++) {
 395        usb_fill_port(ports[i], opaque, i, ops, speedmask);
 396    }
 397
 398    bus->ops->register_companion(bus, ports, portcount, firstport, errp);
 399}
 400
 401void usb_port_location(USBPort *downstream, USBPort *upstream, int portnr)
 402{
 403    if (upstream) {
 404        int l = snprintf(downstream->path, sizeof(downstream->path), "%s.%d",
 405                         upstream->path, portnr);
 406        /* Max string is nn.nn.nn.nn.nn, which fits in 16 bytes */
 407        assert(l < sizeof(downstream->path));
 408        downstream->hubcount = upstream->hubcount + 1;
 409    } else {
 410        snprintf(downstream->path, sizeof(downstream->path), "%d", portnr);
 411        downstream->hubcount = 0;
 412    }
 413}
 414
 415void usb_unregister_port(USBBus *bus, USBPort *port)
 416{
 417    if (port->dev) {
 418        object_unparent(OBJECT(port->dev));
 419    }
 420    QTAILQ_REMOVE(&bus->free, port, next);
 421    bus->nfree--;
 422}
 423
 424void usb_claim_port(USBDevice *dev, Error **errp)
 425{
 426    USBBus *bus = usb_bus_from_device(dev);
 427    USBPort *port;
 428
 429    assert(dev->port == NULL);
 430
 431    if (dev->port_path) {
 432        QTAILQ_FOREACH(port, &bus->free, next) {
 433            if (strcmp(port->path, dev->port_path) == 0) {
 434                break;
 435            }
 436        }
 437        if (port == NULL) {
 438            error_setg(errp, "usb port %s (bus %s) not found (in use?)",
 439                       dev->port_path, bus->qbus.name);
 440            return;
 441        }
 442    } else {
 443        if (bus->nfree == 1 && strcmp(object_get_typename(OBJECT(dev)), "usb-hub") != 0) {
 444            /* Create a new hub and chain it on */
 445            usb_try_create_simple(bus, "usb-hub", NULL);
 446        }
 447        if (bus->nfree == 0) {
 448            error_setg(errp, "tried to attach usb device %s to a bus "
 449                       "with no free ports", dev->product_desc);
 450            return;
 451        }
 452        port = QTAILQ_FIRST(&bus->free);
 453    }
 454    trace_usb_port_claim(bus->busnr, port->path);
 455
 456    QTAILQ_REMOVE(&bus->free, port, next);
 457    bus->nfree--;
 458
 459    dev->port = port;
 460    port->dev = dev;
 461
 462    QTAILQ_INSERT_TAIL(&bus->used, port, next);
 463    bus->nused++;
 464}
 465
 466void usb_release_port(USBDevice *dev)
 467{
 468    USBBus *bus = usb_bus_from_device(dev);
 469    USBPort *port = dev->port;
 470
 471    assert(port != NULL);
 472    trace_usb_port_release(bus->busnr, port->path);
 473
 474    QTAILQ_REMOVE(&bus->used, port, next);
 475    bus->nused--;
 476
 477    dev->port = NULL;
 478    port->dev = NULL;
 479
 480    QTAILQ_INSERT_TAIL(&bus->free, port, next);
 481    bus->nfree++;
 482}
 483
 484static void usb_mask_to_str(char *dest, size_t size,
 485                            unsigned int speedmask)
 486{
 487    static const struct {
 488        unsigned int mask;
 489        const char *name;
 490    } speeds[] = {
 491        { .mask = USB_SPEED_MASK_FULL,  .name = "full"  },
 492        { .mask = USB_SPEED_MASK_HIGH,  .name = "high"  },
 493        { .mask = USB_SPEED_MASK_SUPER, .name = "super" },
 494    };
 495    int i, pos = 0;
 496
 497    for (i = 0; i < ARRAY_SIZE(speeds); i++) {
 498        if (speeds[i].mask & speedmask) {
 499            pos += snprintf(dest + pos, size - pos, "%s%s",
 500                            pos ? "+" : "",
 501                            speeds[i].name);
 502        }
 503    }
 504
 505    if (pos == 0) {
 506        snprintf(dest, size, "unknown");
 507    }
 508}
 509
 510void usb_check_attach(USBDevice *dev, Error **errp)
 511{
 512    USBBus *bus = usb_bus_from_device(dev);
 513    USBPort *port = dev->port;
 514    char devspeed[32], portspeed[32];
 515
 516    assert(port != NULL);
 517    assert(!dev->attached);
 518    usb_mask_to_str(devspeed, sizeof(devspeed), dev->speedmask);
 519    usb_mask_to_str(portspeed, sizeof(portspeed), port->speedmask);
 520    trace_usb_port_attach(bus->busnr, port->path,
 521                          devspeed, portspeed);
 522
 523    if (!(port->speedmask & dev->speedmask)) {
 524        error_setg(errp, "Warning: speed mismatch trying to attach"
 525                   " usb device \"%s\" (%s speed)"
 526                   " to bus \"%s\", port \"%s\" (%s speed)",
 527                   dev->product_desc, devspeed,
 528                   bus->qbus.name, port->path, portspeed);
 529        return;
 530    }
 531}
 532
 533void usb_device_attach(USBDevice *dev, Error **errp)
 534{
 535    USBPort *port = dev->port;
 536    Error *local_err = NULL;
 537
 538    usb_check_attach(dev, &local_err);
 539    if (local_err) {
 540        error_propagate(errp, local_err);
 541        return;
 542    }
 543
 544    dev->attached = true;
 545    usb_attach(port);
 546}
 547
 548int usb_device_detach(USBDevice *dev)
 549{
 550    USBBus *bus = usb_bus_from_device(dev);
 551    USBPort *port = dev->port;
 552
 553    assert(port != NULL);
 554    assert(dev->attached);
 555    trace_usb_port_detach(bus->busnr, port->path);
 556
 557    usb_detach(port);
 558    dev->attached = false;
 559    return 0;
 560}
 561
 562static const char *usb_speed(unsigned int speed)
 563{
 564    static const char *txt[] = {
 565        [ USB_SPEED_LOW  ] = "1.5",
 566        [ USB_SPEED_FULL ] = "12",
 567        [ USB_SPEED_HIGH ] = "480",
 568        [ USB_SPEED_SUPER ] = "5000",
 569    };
 570    if (speed >= ARRAY_SIZE(txt))
 571        return "?";
 572    return txt[speed];
 573}
 574
 575static void usb_bus_dev_print(Monitor *mon, DeviceState *qdev, int indent)
 576{
 577    USBDevice *dev = USB_DEVICE(qdev);
 578    USBBus *bus = usb_bus_from_device(dev);
 579
 580    monitor_printf(mon, "%*saddr %d.%d, port %s, speed %s, name %s%s\n",
 581                   indent, "", bus->busnr, dev->addr,
 582                   dev->port ? dev->port->path : "-",
 583                   usb_speed(dev->speed), dev->product_desc,
 584                   dev->attached ? ", attached" : "");
 585}
 586
 587static char *usb_get_dev_path(DeviceState *qdev)
 588{
 589    USBDevice *dev = USB_DEVICE(qdev);
 590    DeviceState *hcd = qdev->parent_bus->parent;
 591    char *id = NULL;
 592
 593    if (dev->flags & (1 << USB_DEV_FLAG_FULL_PATH)) {
 594        id = qdev_get_dev_path(hcd);
 595    }
 596    if (id) {
 597        char *ret = g_strdup_printf("%s/%s", id, dev->port->path);
 598        g_free(id);
 599        return ret;
 600    } else {
 601        return g_strdup(dev->port->path);
 602    }
 603}
 604
 605static char *usb_get_fw_dev_path(DeviceState *qdev)
 606{
 607    USBDevice *dev = USB_DEVICE(qdev);
 608    char *fw_path, *in;
 609    ssize_t pos = 0, fw_len;
 610    long nr;
 611
 612    fw_len = 32 + strlen(dev->port->path) * 6;
 613    fw_path = g_malloc(fw_len);
 614    in = dev->port->path;
 615    while (fw_len - pos > 0) {
 616        nr = strtol(in, &in, 10);
 617        if (in[0] == '.') {
 618            /* some hub between root port and device */
 619            pos += snprintf(fw_path + pos, fw_len - pos, "hub@%lx/", nr);
 620            in++;
 621        } else {
 622            /* the device itself */
 623            pos += snprintf(fw_path + pos, fw_len - pos, "%s@%lx",
 624                            qdev_fw_name(qdev), nr);
 625            break;
 626        }
 627    }
 628    return fw_path;
 629}
 630
 631void hmp_info_usb(Monitor *mon, const QDict *qdict)
 632{
 633    USBBus *bus;
 634    USBDevice *dev;
 635    USBPort *port;
 636
 637    if (QTAILQ_EMPTY(&busses)) {
 638        monitor_printf(mon, "USB support not enabled\n");
 639        return;
 640    }
 641
 642    QTAILQ_FOREACH(bus, &busses, next) {
 643        QTAILQ_FOREACH(port, &bus->used, next) {
 644            dev = port->dev;
 645            if (!dev)
 646                continue;
 647            monitor_printf(mon, "  Device %d.%d, Port %s, Speed %s Mb/s, "
 648                           "Product %s%s%s\n",
 649                           bus->busnr, dev->addr, port->path,
 650                           usb_speed(dev->speed), dev->product_desc,
 651                           dev->qdev.id ? ", ID: " : "",
 652                           dev->qdev.id ?: "");
 653        }
 654    }
 655}
 656
 657/* handle legacy -usbdevice cmd line option */
 658USBDevice *usbdevice_create(const char *cmdline)
 659{
 660    USBBus *bus = usb_bus_find(-1 /* any */);
 661    LegacyUSBFactory *f = NULL;
 662    Error *err = NULL;
 663    GSList *i;
 664    char driver[32];
 665    const char *params;
 666    int len;
 667    USBDevice *dev;
 668
 669    params = strchr(cmdline,':');
 670    if (params) {
 671        params++;
 672        len = params - cmdline;
 673        if (len > sizeof(driver))
 674            len = sizeof(driver);
 675        pstrcpy(driver, len, cmdline);
 676    } else {
 677        params = "";
 678        pstrcpy(driver, sizeof(driver), cmdline);
 679    }
 680
 681    for (i = legacy_usb_factory; i; i = i->next) {
 682        f = i->data;
 683        if (strcmp(f->usbdevice_name, driver) == 0) {
 684            break;
 685        }
 686    }
 687    if (i == NULL) {
 688#if 0
 689        /* no error because some drivers are not converted (yet) */
 690        error_report("usbdevice %s not found", driver);
 691#endif
 692        return NULL;
 693    }
 694
 695    if (!bus) {
 696        error_report("Error: no usb bus to attach usbdevice %s, "
 697                     "please try -machine usb=on and check that "
 698                     "the machine model supports USB", driver);
 699        return NULL;
 700    }
 701
 702    if (f->usbdevice_init) {
 703        dev = f->usbdevice_init(bus, params);
 704    } else {
 705        if (*params) {
 706            error_report("usbdevice %s accepts no params", driver);
 707            return NULL;
 708        }
 709        dev = usb_create(bus, f->name);
 710    }
 711    if (!dev) {
 712        error_report("Failed to create USB device '%s'", f->name);
 713        return NULL;
 714    }
 715    object_property_set_bool(OBJECT(dev), true, "realized", &err);
 716    if (err) {
 717        error_reportf_err(err, "Failed to initialize USB device '%s': ",
 718                          f->name);
 719        object_unparent(OBJECT(dev));
 720        return NULL;
 721    }
 722    return dev;
 723}
 724
 725static bool usb_get_attached(Object *obj, Error **errp)
 726{
 727    USBDevice *dev = USB_DEVICE(obj);
 728
 729    return dev->attached;
 730}
 731
 732static void usb_set_attached(Object *obj, bool value, Error **errp)
 733{
 734    USBDevice *dev = USB_DEVICE(obj);
 735    Error *err = NULL;
 736
 737    if (dev->attached == value) {
 738        return;
 739    }
 740
 741    if (value) {
 742        usb_device_attach(dev, &err);
 743        error_propagate(errp, err);
 744    } else {
 745        usb_device_detach(dev);
 746    }
 747}
 748
 749static void usb_device_instance_init(Object *obj)
 750{
 751    USBDevice *dev = USB_DEVICE(obj);
 752    USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
 753
 754    if (klass->attached_settable) {
 755        object_property_add_bool(obj, "attached",
 756                                 usb_get_attached, usb_set_attached,
 757                                 NULL);
 758    } else {
 759        object_property_add_bool(obj, "attached",
 760                                 usb_get_attached, NULL,
 761                                 NULL);
 762    }
 763}
 764
 765static void usb_device_class_init(ObjectClass *klass, void *data)
 766{
 767    DeviceClass *k = DEVICE_CLASS(klass);
 768    k->bus_type = TYPE_USB_BUS;
 769    k->realize  = usb_qdev_realize;
 770    k->unrealize = usb_qdev_unrealize;
 771    k->props    = usb_props;
 772}
 773
 774static const TypeInfo usb_device_type_info = {
 775    .name = TYPE_USB_DEVICE,
 776    .parent = TYPE_DEVICE,
 777    .instance_size = sizeof(USBDevice),
 778    .instance_init = usb_device_instance_init,
 779    .abstract = true,
 780    .class_size = sizeof(USBDeviceClass),
 781    .class_init = usb_device_class_init,
 782};
 783
 784static void usb_register_types(void)
 785{
 786    type_register_static(&usb_bus_info);
 787    type_register_static(&usb_device_type_info);
 788}
 789
 790type_init(usb_register_types)
 791