/ - Diff - qemu - Greek Research and Technology Network's projects

     obj-y += scsi-disk.o cdrom.o
     obj-y += scsi-generic.o
     obj-y += usb.o usb-hub.o usb-$(HOST_USB).o usb-hid.o usb-msd.o usb-wacom.o
     obj-y += usb-serial.o usb-net.o
     obj-y += usb-serial.o usb-net.o usb-bus.o
     obj-y += sd.o ssi-sd.o
     obj-y += bt.o bt-host.o bt-vhci.o bt-l2cap.o bt-sdp.o bt-hci.o bt-hid.o usb-bt.o
     obj-y += bt-hci-csr.o

         bt_l2cap_device_done(&s->btdev);
         bt_l2cap_device_init(&s->btdev, net);
         s->usbdev->handle_reset(s->usbdev);
         s->usbdev->info->handle_reset(s->usbdev);
         s->proto = BT_HID_PROTO_REPORT;
         s->state = bt_state_ready;
         s->dataother.len = 0;
-...
             p.devep = 1;
             p.data = s->dataout.buffer;
             p.len = s->dataout.len;
             s->dataout.len = s->usbdev->handle_data(s->usbdev, &p);
             s->dataout.len = s->usbdev->info->handle_data(s->usbdev, &p);
             return s->dataout.len;
+        }
-...
         p.devep = 1;
         p.data = s->datain.buffer;
         p.len = sizeof(s->datain.buffer);
         s->datain.len = s->usbdev->handle_data(s->usbdev, &p);
         s->datain.len = s->usbdev->info->handle_data(s->usbdev, &p);
         return s->datain.len;
+    }
-...
                 break;
+            }
             s->proto = parameter;
             s->usbdev->handle_control(s->usbdev, SET_PROTOCOL, s->proto, 0, 0,
                                       NULL);
             s->usbdev->info->handle_control(s->usbdev, SET_PROTOCOL, s->proto, 0, 0,
                                             NULL);
             ret = BT_HS_SUCCESSFUL;
             break;
-...
                 ret = BT_HS_ERR_INVALID_PARAMETER;
                 break;
+            }
             s->usbdev->handle_control(s->usbdev, GET_IDLE, 0, 0, 1,
             s->usbdev->info->handle_control(s->usbdev, GET_IDLE, 0, 0, 1,
                             s->control->sdu_out(s->control, 1));
             s->control->sdu_submit(s->control);
             break;
-...
             /* We don't need to know about the Idle Rate here really,
              * so just pass it on to the device.  */
             ret = s->usbdev->handle_control(s->usbdev,
             ret = s->usbdev->info->handle_control(s->usbdev,
                             SET_IDLE, data[1], 0, 0, NULL) ?
                     BT_HS_SUCCESSFUL : BT_HS_ERR_INVALID_PARAMETER;
             /* XXX: Does this generate a handshake? */
-...
         hid->btdev.device.inquiry_scan = !hid->connected;
         if (hid->connected && !prev) {
             hid->usbdev->handle_reset(hid->usbdev);
             hid->usbdev->info->handle_reset(hid->usbdev);
             hid->proto = BT_HID_PROTO_REPORT;
+        }
-...
             bt_hid_send_control(hid, BT_HC_VIRTUAL_CABLE_UNPLUG);
         bt_l2cap_device_done(&hid->btdev);
         hid->usbdev->handle_destroy(hid->usbdev);
         hid->usbdev->info->handle_destroy(hid->usbdev);
         qemu_free(hid);
+    }

         qemu_free(s);
+    }
     static int usb_bt_initfn(USBDevice *dev)
+    {
         struct USBBtState *s = DO_UPCAST(struct USBBtState, dev, dev);
         s->dev.speed = USB_SPEED_HIGH;
         return 0;
+    }
     USBDevice *usb_bt_init(HCIInfo *hci)
+    {
         USBDevice *dev;
         struct USBBtState *s;
         if (!hci)
             return NULL;
         s = qemu_mallocz(sizeof(struct USBBtState));
         dev = usb_create_simple(NULL /* FIXME */, "QEMU BT dongle");
         s = DO_UPCAST(struct USBBtState, dev, dev);
         s->dev.opaque = s;
         s->dev.speed = USB_SPEED_HIGH;
         s->dev.handle_packet = usb_generic_handle_packet;
         pstrcpy(s->dev.devname, sizeof(s->dev.devname), "QEMU BT dongle");
         s->dev.handle_reset = usb_bt_handle_reset;
         s->dev.handle_control = usb_bt_handle_control;
         s->dev.handle_data = usb_bt_handle_data;
         s->dev.handle_destroy = usb_bt_handle_destroy;
         s->hci = hci;
         s->hci->opaque = s;
-...
         usb_bt_handle_reset(&s->dev);
         return &s->dev;
         return dev;
+    }
     static struct USBDeviceInfo bt_info = {
         .qdev.name      = "QEMU BT dongle",
         .qdev.size      = sizeof(struct USBBtState),
         .init           = usb_bt_initfn,
         .handle_packet  = usb_generic_handle_packet,
         .handle_reset   = usb_bt_handle_reset,
         .handle_control = usb_bt_handle_control,
         .handle_data    = usb_bt_handle_data,
         .handle_destroy = usb_bt_handle_destroy,
     };
     static void usb_bt_register_devices(void)
+    {
         usb_qdev_register(&bt_info);
+    }
     device_init(usb_bt_register_devices)

     #include "hw.h"
     #include "usb.h"
     #include "qdev.h"
     static struct BusInfo usb_bus_info = {
         .name  = "USB",
         .size  = sizeof(USBBus),
     };
     static int next_usb_bus = 0;
     static TAILQ_HEAD(, USBBus) busses = TAILQ_HEAD_INITIALIZER(busses);
     USBBus *usb_bus_new(DeviceState *host)
+    {
         USBBus *bus;
         bus = FROM_QBUS(USBBus, qbus_create(&usb_bus_info, host, NULL));
         bus->busnr = next_usb_bus++;
         TAILQ_INIT(&bus->free);
         TAILQ_INIT(&bus->used);
         TAILQ_INSERT_TAIL(&busses, bus, next);
         return bus;
+    }
     USBBus *usb_bus_find(int busnr)
+    {
         USBBus *bus;
         if (-1 == busnr)
             return TAILQ_FIRST(&busses);
         TAILQ_FOREACH(bus, &busses, next) {
             if (bus->busnr == busnr)
                 return bus;
+        }
         return NULL;
+    }
     static int usb_qdev_init(DeviceState *qdev, DeviceInfo *base)
+    {
         USBDevice *dev = DO_UPCAST(USBDevice, qdev, qdev);
         USBDeviceInfo *info = DO_UPCAST(USBDeviceInfo, qdev, base);
         int rc;
         pstrcpy(dev->devname, sizeof(dev->devname), qdev->info->name);
         dev->info = info;
         rc = dev->info->init(dev);
         return rc;
+    }
     void usb_qdev_register(USBDeviceInfo *info)
+    {
         info->qdev.bus_info = &usb_bus_info;
         info->qdev.init     = usb_qdev_init;
         qdev_register(&info->qdev);
+    }
     void usb_qdev_register_many(USBDeviceInfo *info)
+    {
         while (info->qdev.name) {
             usb_qdev_register(info);
             info++;
+        }
+    }
     USBDevice *usb_create_simple(USBBus *bus, const char *name)
+    {
         DeviceState *dev;
     #if 1
         /* temporary stopgap until all usb is properly qdev-ified */
         if (!bus) {
             bus = usb_bus_find(-1);
             if (!bus)
                 return NULL;
             fprintf(stderr, "%s: no bus specified, using \"%s\" for \"%s\"\n",
                     __FUNCTION__, bus->qbus.name, name);
+        }
     #endif
         dev = qdev_create(&bus->qbus, name);
         qdev_init(dev);
         return DO_UPCAST(USBDevice, qdev, dev);
+    }

         qemu_free(s);
+    }
     USBDevice *usb_tablet_init(void)
     static int usb_hid_initfn(USBDevice *dev, int kind)
+    {
         USBHIDState *s;
         s = qemu_mallocz(sizeof(USBHIDState));
         USBHIDState *s = DO_UPCAST(USBHIDState, dev, dev);
         s->dev.speed = USB_SPEED_FULL;
         s->dev.handle_packet = usb_generic_handle_packet;
         s->dev.handle_reset = usb_mouse_handle_reset;
         s->dev.handle_control = usb_hid_handle_control;
         s->dev.handle_data = usb_hid_handle_data;
         s->dev.handle_destroy = usb_hid_handle_destroy;
         s->kind = USB_TABLET;
         s->kind = kind;
         /* Force poll routine to be run and grab input the first time.  */
         s->changed = 1;
         pstrcpy(s->dev.devname, sizeof(s->dev.devname), "QEMU USB Tablet");
         return (USBDevice *)s;
         return 0;
+    }
     USBDevice *usb_mouse_init(void)
     static int usb_tablet_initfn(USBDevice *dev)
+    {
         USBHIDState *s;
         return usb_hid_initfn(dev, USB_TABLET);
+    }
         s = qemu_mallocz(sizeof(USBHIDState));
         s->dev.speed = USB_SPEED_FULL;
         s->dev.handle_packet = usb_generic_handle_packet;
     static int usb_mouse_initfn(USBDevice *dev)
+    {
         return usb_hid_initfn(dev, USB_MOUSE);
+    }
         s->dev.handle_reset = usb_mouse_handle_reset;
         s->dev.handle_control = usb_hid_handle_control;
         s->dev.handle_data = usb_hid_handle_data;
         s->dev.handle_destroy = usb_hid_handle_destroy;
         s->kind = USB_MOUSE;
         /* Force poll routine to be run and grab input the first time.  */
         s->changed = 1;
     static int usb_keyboard_initfn(USBDevice *dev)
+    {
         return usb_hid_initfn(dev, USB_KEYBOARD);
+    }
         pstrcpy(s->dev.devname, sizeof(s->dev.devname), "QEMU USB Mouse");
     USBDevice *usb_tablet_init(void)
+    {
         return usb_create_simple(NULL /* FIXME */, "QEMU USB Tablet");
+    }
         return (USBDevice *)s;
     USBDevice *usb_mouse_init(void)
+    {
         return usb_create_simple(NULL /* FIXME */, "QEMU USB Mouse");
+    }
     USBDevice *usb_keyboard_init(void)
+    {
         USBHIDState *s;
         s = qemu_mallocz(sizeof(USBHIDState));
         s->dev.speed = USB_SPEED_FULL;
         s->dev.handle_packet = usb_generic_handle_packet;
         s->dev.handle_reset = usb_keyboard_handle_reset;
         s->dev.handle_control = usb_hid_handle_control;
         s->dev.handle_data = usb_hid_handle_data;
         s->dev.handle_destroy = usb_hid_handle_destroy;
         s->kind = USB_KEYBOARD;
         pstrcpy(s->dev.devname, sizeof(s->dev.devname), "QEMU USB Keyboard");
         return (USBDevice *) s;
         return usb_create_simple(NULL /* FIXME */, "QEMU USB Keyboard");
+    }
     void usb_hid_datain_cb(USBDevice *dev, void *opaque, void (*datain)(void *))
-...
         s->datain_opaque = opaque;
         s->datain = datain;
+    }
     static struct USBDeviceInfo hid_info[] = {
+        {
             .qdev.name      = "QEMU USB Tablet",
             .qdev.size      = sizeof(USBHIDState),
             .init           = usb_tablet_initfn,
             .handle_packet  = usb_generic_handle_packet,
             .handle_reset   = usb_mouse_handle_reset,
             .handle_control = usb_hid_handle_control,
             .handle_data    = usb_hid_handle_data,
             .handle_destroy = usb_hid_handle_destroy,
         },{
             .qdev.name      = "QEMU USB Mouse",
             .qdev.size      = sizeof(USBHIDState),
             .init           = usb_mouse_initfn,
             .handle_packet  = usb_generic_handle_packet,
             .handle_reset   = usb_mouse_handle_reset,
             .handle_control = usb_hid_handle_control,
             .handle_data    = usb_hid_handle_data,
             .handle_destroy = usb_hid_handle_destroy,
         },{
             .qdev.name      = "QEMU USB Keyboard",
             .qdev.size      = sizeof(USBHIDState),
             .init           = usb_keyboard_initfn,
             .handle_packet  = usb_generic_handle_packet,
             .handle_reset   = usb_keyboard_handle_reset,
             .handle_control = usb_hid_handle_control,
             .handle_data    = usb_hid_handle_data,
             .handle_destroy = usb_hid_handle_destroy,
         },{
             /* end of list */
+        }
     };
     static void usb_hid_register_devices(void)
+    {
         usb_qdev_register_many(hid_info);
+    }
     device_init(usb_hid_register_devices)

             port = &s->ports[i];
             dev = port->port.dev;
             if (dev && (port->wPortStatus & PORT_STAT_ENABLE)) {
                 ret = dev->handle_packet(dev, p);
                 ret = dev->info->handle_packet(dev, p);
                 if (ret != USB_RET_NODEV) {
                     return ret;
+                }
-...
         qemu_free(s);
+    }
     USBDevice *usb_hub_init(int nb_ports)
     static int usb_hub_initfn(USBDevice *dev)
+    {
         USBHubState *s;
         USBHubState *s = DO_UPCAST(USBHubState, dev, dev);
         USBHubPort *port;
         int i;
         if (nb_ports > MAX_PORTS)
             return NULL;
         s = qemu_mallocz(sizeof(USBHubState));
         s->dev.speed = USB_SPEED_FULL;
         s->dev.handle_packet = usb_hub_handle_packet;
         /* generic USB device init */
         s->dev.handle_reset = usb_hub_handle_reset;
         s->dev.handle_control = usb_hub_handle_control;
         s->dev.handle_data = usb_hub_handle_data;
         s->dev.handle_destroy = usb_hub_handle_destroy;
         pstrcpy(s->dev.devname, sizeof(s->dev.devname), "QEMU USB Hub");
         s->nb_ports = nb_ports;
         for(i = 0; i < s->nb_ports; i++) {
         s->dev.speed  = USB_SPEED_FULL,
         s->nb_ports = MAX_PORTS; /* FIXME: make configurable */
         for (i = 0; i < s->nb_ports; i++) {
             port = &s->ports[i];
             qemu_register_usb_port(&port->port, s, i, usb_hub_attach);
             port->wPortStatus = PORT_STAT_POWER;
             port->wPortChange = 0;
+        }
         return (USBDevice *)s;
         return 0;
+    }
     USBDevice *usb_hub_init(int nb_ports)
+    {
         return usb_create_simple(NULL /* FIXME */, "QEMU USB Hub");
+    }
     static struct USBDeviceInfo hub_info = {
         .qdev.name      = "QEMU USB Hub",
         .qdev.size      = sizeof(USBHubState),
         .init           = usb_hub_initfn,
         .handle_packet  = usb_hub_handle_packet,
         .handle_reset   = usb_hub_handle_reset,
         .handle_control = usb_hub_handle_control,
         .handle_data    = usb_hub_handle_data,
         .handle_destroy = usb_hub_handle_destroy,
     };
     static void usb_hub_register_devices(void)
+    {
         usb_qdev_register(&hub_info);
+    }
     device_init(usb_hub_register_devices)

         qemu_free(s);
+    }
     static int usb_msd_initfn(USBDevice *dev)
+    {
         MSDState *s = DO_UPCAST(MSDState, dev, dev);
         s->dev.speed = USB_SPEED_FULL;
         return 0;
+    }
     USBDevice *usb_msd_init(const char *filename)
+    {
         USBDevice *dev;
         MSDState *s;
         BlockDriverState *bdrv;
         BlockDriver *drv = NULL;
-...
             return NULL;
+        }
         s = qemu_mallocz(sizeof(MSDState));
         bdrv = bdrv_new("usb");
         if (bdrv_open2(bdrv, filename, 0, drv) < 0)
             goto fail;
         s->bs = bdrv;
         s->dev.speed = USB_SPEED_FULL;
         s->dev.handle_packet = usb_generic_handle_packet;
         s->dev.handle_reset = usb_msd_handle_reset;
         s->dev.handle_control = usb_msd_handle_control;
         s->dev.handle_data = usb_msd_handle_data;
         s->dev.handle_destroy = usb_msd_handle_destroy;
             return NULL;
         dev = usb_create_simple(NULL /* FIXME */, "QEMU USB MSD");
         s = DO_UPCAST(MSDState, dev, dev);
         s->bs = bdrv;
         snprintf(s->dev.devname, sizeof(s->dev.devname), "QEMU USB MSD(%.16s)",
                  filename);
         s->scsi_dev = scsi_disk_init(bdrv, 0, usb_msd_command_complete, s);
         usb_msd_handle_reset((USBDevice *)s);
         return (USBDevice *)s;
      fail:
         qemu_free(s);
         return NULL;
+    }
     BlockDriverState *usb_msd_get_bdrv(USBDevice *dev)
-...
         return s->bs;
+    }
     static struct USBDeviceInfo msd_info = {
         .qdev.name      = "QEMU USB MSD",
         .qdev.size      = sizeof(MSDState),
         .init           = usb_msd_initfn,
         .handle_packet  = usb_generic_handle_packet,
         .handle_reset   = usb_msd_handle_reset,
         .handle_control = usb_msd_handle_control,
         .handle_data    = usb_msd_handle_data,
         .handle_destroy = usb_msd_handle_destroy,
     };
     static void usb_msd_register_devices(void)
+    {
         usb_qdev_register(&msd_info);
+    }
     device_init(usb_msd_register_devices)

         ep->packey[dir].complete_opaque = ep;
         if (s->port.dev)
             ret = s->port.dev->handle_packet(s->port.dev, &ep->packey[dir]);
             ret = s->port.dev->info->handle_packet(s->port.dev, &ep->packey[dir]);
         else
             ret = USB_RET_NODEV;

         qemu_del_vlan_client(s->vc);
+    }
     USBDevice *usb_net_init(NICInfo *nd)
     static int usb_net_initfn(USBDevice *dev)
+    {
         USBNetState *s;
         s = qemu_mallocz(sizeof(USBNetState));
         s->dev.speed = USB_SPEED_FULL;
         s->dev.handle_packet = usb_generic_handle_packet;
         USBNetState *s = DO_UPCAST(USBNetState, dev, dev);
         s->dev.handle_reset = usb_net_handle_reset;
         s->dev.handle_control = usb_net_handle_control;
         s->dev.handle_data = usb_net_handle_data;
         s->dev.handle_destroy = usb_net_handle_destroy;
         s->dev.speed  = USB_SPEED_FULL;
         s->rndis = 1;
         s->rndis_state = RNDIS_UNINITIALIZED;
         TAILQ_INIT(&s->rndis_resp);
         s->medium = 0;	/* NDIS_MEDIUM_802_3 */
         s->speed = 1000000; /* 100MBps, in 100Bps units */
         s->media_state = 0;	/* NDIS_MEDIA_STATE_CONNECTED */;
         s->filter = 0;
         s->vendorid = 0x1234;
         return 0;
+    }
     USBDevice *usb_net_init(NICInfo *nd)
+    {
         USBDevice *dev;
         USBNetState *s;
         dev = usb_create_simple(NULL /* FIXME */, "QEMU USB Network Interface");
         s = DO_UPCAST(USBNetState, dev, dev);
         memcpy(s->mac, nd->macaddr, 6);
         TAILQ_INIT(&s->rndis_resp);
         pstrcpy(s->dev.devname, sizeof(s->dev.devname),
                         "QEMU USB Network Interface");
         s->vc = nd->vc = qemu_new_vlan_client(nd->vlan, nd->model, nd->name,
                                               usbnet_can_receive,
                                               usbnet_receive,
-...
         return (USBDevice *) s;
+    }
     static struct USBDeviceInfo net_info = {
         .qdev.name      = "QEMU USB Network Interface",
         .qdev.size      = sizeof(USBNetState),
         .init           = usb_net_initfn,
         .handle_packet  = usb_generic_handle_packet,
         .handle_reset   = usb_net_handle_reset,
         .handle_control = usb_net_handle_control,
         .handle_data    = usb_net_handle_data,
         .handle_destroy = usb_net_handle_destroy,
     };
     static void usb_net_register_devices(void)
+    {
         usb_qdev_register(&net_info);
+    }
     device_init(usb_net_register_devices)

                 ohci->usb_packet.len = len;
                 ohci->usb_packet.complete_cb = ohci_async_complete_packet;
                 ohci->usb_packet.complete_opaque = ohci;
                 ret = dev->handle_packet(dev, &ohci->usb_packet);
                 ret = dev->info->handle_packet(dev, &ohci->usb_packet);
                 if (ret != USB_RET_NODEV)
                     break;
+            }
-...
                 ohci->usb_packet.len = len;
                 ohci->usb_packet.complete_cb = ohci_async_complete_packet;
                 ohci->usb_packet.complete_opaque = ohci;
                 ret = dev->handle_packet(dev, &ohci->usb_packet);
                 ret = dev->info->handle_packet(dev, &ohci->usb_packet);
                 if (ret != USB_RET_NODEV)
                     break;
+            }

+        }
+    }
     static int usb_serial_initfn(USBDevice *dev)
+    {
         USBSerialState *s = DO_UPCAST(USBSerialState, dev, dev);
         s->dev.speed = USB_SPEED_FULL;
         return 0;
+    }
     USBDevice *usb_serial_init(const char *filename)
+    {
         USBDevice *dev;
         USBSerialState *s;
         CharDriverState *cdrv;
         unsigned short vendorid = 0x0403, productid = 0x6001;
-...
             return NULL;
+        }
         filename++;
         s = qemu_mallocz(sizeof(USBSerialState));
         snprintf(label, sizeof(label), "usbserial%d", index++);
         cdrv = qemu_chr_open(label, filename, NULL);
         if (!cdrv)
             goto fail;
         s->cs = cdrv;
         qemu_chr_add_handlers(cdrv, usb_serial_can_read, usb_serial_read, usb_serial_event, s);
         s->dev.speed = USB_SPEED_FULL;
         s->dev.handle_packet = usb_generic_handle_packet;
         s->dev.handle_reset = usb_serial_handle_reset;
         s->dev.handle_control = usb_serial_handle_control;
         s->dev.handle_data = usb_serial_handle_data;
         s->dev.handle_destroy = usb_serial_handle_destroy;
             return NULL;
         dev = usb_create_simple(NULL /* FIXME */, "QEMU USB Serial");
         s = DO_UPCAST(USBSerialState, dev, dev);
         s->cs = cdrv;
         s->vendorid = vendorid;
         s->productid = productid;
         snprintf(s->dev.devname, sizeof(s->dev.devname), "QEMU USB Serial(%.16s)",
                  filename);
         qemu_chr_add_handlers(cdrv, usb_serial_can_read, usb_serial_read,
                               usb_serial_event, s);
         usb_serial_handle_reset((USBDevice *)s);
         return (USBDevice *)s;
      fail:
         qemu_free(s);
         return NULL;
+    }
     static struct USBDeviceInfo serial_info = {
         .qdev.name      = "QEMU USB Serial",
         .qdev.size      = sizeof(USBSerialState),
         .init           = usb_serial_initfn,
         .handle_packet  = usb_generic_handle_packet,
         .handle_reset   = usb_serial_handle_reset,
         .handle_control = usb_serial_handle_control,
         .handle_data    = usb_serial_handle_data,
         .handle_destroy = usb_serial_handle_destroy,
     };
     static void usb_serial_register_devices(void)
+    {
         usb_qdev_register(&serial_info);
+    }
     device_init(usb_serial_register_devices)

             USBDevice *dev = port->port.dev;
             if (dev && (port->ctrl & UHCI_PORT_EN))
                 ret = dev->handle_packet(dev, p);
                 ret = dev->info->handle_packet(dev, p);
+        }
         dprintf("uhci: packet exit. ret %d len %d\n", ret, p->len);

         qemu_free(s);
+    }
     USBDevice *usb_wacom_init(void)
     static int usb_wacom_initfn(USBDevice *dev)
+    {
         USBWacomState *s;
         s = qemu_mallocz(sizeof(USBWacomState));
         USBWacomState *s = DO_UPCAST(USBWacomState, dev, dev);
         s->dev.speed = USB_SPEED_FULL;
         s->dev.handle_packet = usb_generic_handle_packet;
         return 0;
+    }
         s->dev.handle_reset = usb_wacom_handle_reset;
         s->dev.handle_control = usb_wacom_handle_control;
         s->dev.handle_data = usb_wacom_handle_data;
         s->dev.handle_destroy = usb_wacom_handle_destroy;
     USBDevice *usb_wacom_init(void)
+    {
         return usb_create_simple(NULL /* FIXME */, "QEMU PenPartner Tablet");
+    }
         pstrcpy(s->dev.devname, sizeof(s->dev.devname),
                 "QEMU PenPartner Tablet");
     static struct USBDeviceInfo wacom_info = {
         .qdev.name      = "QEMU PenPartner Tablet",
         .qdev.size      = sizeof(USBWacomState),
         .init           = usb_wacom_initfn,
         .handle_packet  = usb_generic_handle_packet,
         .handle_reset   = usb_wacom_handle_reset,
         .handle_control = usb_wacom_handle_control,
         .handle_data    = usb_wacom_handle_data,
         .handle_destroy = usb_wacom_handle_destroy,
     };
         return (USBDevice *) s;
     static void usb_wacom_register_devices(void)
+    {
         usb_qdev_register(&wacom_info);
+    }
     device_init(usb_wacom_register_devices)

         index   = (s->setup_buf[5] << 8) | s->setup_buf[4];
         if (s->setup_buf[0] & USB_DIR_IN) {
             ret = s->handle_control(s, request, value, index,
                                     s->setup_len, s->data_buf);
             ret = s->info->handle_control(s, request, value, index,
                                           s->setup_len, s->data_buf);
             if (ret < 0)
                 return ret;
-...
         int ret = 0;
         if (p->devep != 0)
             return s->handle_data(s, p);
             return s->info->handle_data(s, p);
         request = (s->setup_buf[0] << 8) | s->setup_buf[1];
         value   = (s->setup_buf[3] << 8) | s->setup_buf[2];
-...
         case SETUP_STATE_ACK:
             if (!(s->setup_buf[0] & USB_DIR_IN)) {
                 s->setup_state = SETUP_STATE_IDLE;
                 ret = s->handle_control(s, request, value, index,
                                         s->setup_len, s->data_buf);
                 ret = s->info->handle_control(s, request, value, index,
                                               s->setup_len, s->data_buf);
                 if (ret > 0)
                     return 0;
                 return ret;
-...
     static int do_token_out(USBDevice *s, USBPacket *p)
+    {
         if (p->devep != 0)
             return s->handle_data(s, p);
             return s->info->handle_data(s, p);
         switch(s->setup_state) {
         case SETUP_STATE_ACK:
-...
             s->remote_wakeup = 0;
             s->addr = 0;
             s->state = USB_STATE_DEFAULT;
             s->handle_reset(s);
             s->info->handle_reset(s);
             return 0;
+        }
-...
         USBPacket p;
         memset(&p, 0, sizeof(p));
         p.pid = msg;
         dev->handle_packet(dev, &p);
         dev->info->handle_packet(dev, &p);
         /* This _must_ be synchronous */
+    }

      */
     #include "block.h"
     #include "qdev.h"
     #define USB_TOKEN_SETUP 0x2d
     #define USB_TOKEN_IN    0x69 /* device -> host */
-...
     #define USB_ENDPOINT_XFER_BULK		2
     #define USB_ENDPOINT_XFER_INT		3
     typedef struct USBBus USBBus;
     typedef struct USBPort USBPort;
     typedef struct USBDevice USBDevice;
     typedef struct USBDeviceInfo USBDeviceInfo;
     typedef struct USBPacket USBPacket;
     /* definition of a USB device */
     struct USBDevice {
         DeviceState qdev;
         USBDeviceInfo *info;
         void *opaque;
         /*
          * Process USB packet.
         int speed;
         uint8_t addr;
         char devname[32];
         int state;
         uint8_t setup_buf[8];
         uint8_t data_buf[1024];
         int remote_wakeup;
         int setup_state;
         int setup_len;
         int setup_index;
     };
     struct USBDeviceInfo {
         DeviceInfo qdev;
         int (*init)(USBDevice *dev);
         /*
          * Process USB packet.
          * Called by the HC (Host Controller).
+         *
          * Returns length of the transaction
          * Returns length of the transaction
          * or one of the USB_RET_XXX codes.
          */
          */
         int (*handle_packet)(USBDevice *dev, USBPacket *p);
         /*
         /*
          * Called when device is destroyed.
          */
         void (*handle_destroy)(USBDevice *dev);
         int speed;
         /* The following fields are used by the generic USB device
            layer. They are here just to avoid creating a new structure
            for them. */
         /*
          * Reset the device
          */
          */
         void (*handle_reset)(USBDevice *dev);
         /*
-...
          * Returns length or one of the USB_RET_ codes.
          */
         int (*handle_data)(USBDevice *dev, USBPacket *p);
         uint8_t addr;
         char devname[32];
         int state;
         uint8_t setup_buf[8];
         uint8_t data_buf[1024];
         int remote_wakeup;
         int setup_state;
         int setup_len;
         int setup_index;
     };
     typedef void (*usb_attachfn)(USBPort *port, USBDevice *dev);
-...
     uint32_t musb_core_intr_get(MUSBState *s);
     void musb_core_intr_clear(MUSBState *s, uint32_t mask);
     void musb_set_size(MUSBState *s, int epnum, int size, int is_tx);
     /* usb-bus.c */
     struct USBBus {
         BusState qbus;
         int busnr;
         int nfree;
         int nused;
         TAILQ_HEAD(, USBPort) free;
         TAILQ_HEAD(, USBPort) used;
         TAILQ_ENTRY(USBBus) next;
     };
     USBBus *usb_bus_new(DeviceState *host);
     USBBus *usb_bus_find(int busnr);
     void usb_qdev_register(USBDeviceInfo *info);
     void usb_qdev_register_many(USBDeviceInfo *info);
     USBDevice *usb_create_simple(USBBus *bus, const char *name);

             s->remote_wakeup = 0;
             s->addr = 0;
             s->state = USB_STATE_DEFAULT;
             s->handle_reset(s);
             s->info->handle_reset(s);
             return 0;
+        }
-...
         return 0;
+    }
     static int usb_host_initfn(USBDevice *dev)
+    {
         return 0;
+    }
     static USBDevice *usb_host_device_open_addr(int bus_num, int addr, const char *prod_name)
+    {
         int fd = -1, ret;
         USBHostDevice *dev = NULL;
         USBDevice *d = NULL;
         USBHostDevice *dev;
         struct usbdevfs_connectinfo ci;
         char buf[1024];
         dev = qemu_mallocz(sizeof(USBHostDevice));
         dev->bus_num = bus_num;
         dev->addr = addr;
         printf("husb: open device %d.%d\n", bus_num, addr);
         if (!usb_host_device_path) {
-...
+        }
         dprintf("husb: opened %s\n", buf);
         d = usb_create_simple(NULL /* FIXME */, "USB Host Device");
         dev = DO_UPCAST(USBHostDevice, dev, d);
         dev->bus_num = bus_num;
         dev->addr = addr;
         /* read the device description */
         dev->descr_len = read(fd, dev->descr, sizeof(dev->descr));
         if (dev->descr_len <= 0) {
-...
+        }
     #endif
         dev->fd = fd;
         /*
          * Initial configuration is -1 which makes us claim first
-...
         else
             dev->dev.speed = USB_SPEED_HIGH;
         dev->dev.handle_packet  = usb_host_handle_packet;
         dev->dev.handle_reset   = usb_host_handle_reset;
         dev->dev.handle_destroy = usb_host_handle_destroy;
         if (!prod_name || prod_name[0] == '\0')
             snprintf(dev->dev.devname, sizeof(dev->dev.devname),
                      "host:%d.%d", bus_num, addr);
-...
         return (USBDevice *) dev;
     fail:
         if (dev)
             qemu_free(dev);
         close(fd);
         if (d)
             qdev_free(&d->qdev);
         if (fd != -1)
             close(fd);
         return NULL;
+    }
     static struct USBDeviceInfo usb_host_dev_info = {
         .qdev.name      = "USB Host Device",
         .qdev.size      = sizeof(USBHostDevice),
         .init           = usb_host_initfn,
         .handle_packet  = usb_host_handle_packet,
         .handle_reset   = usb_host_handle_reset,
     #if 0
         .handle_control = usb_host_handle_control,
         .handle_data    = usb_host_handle_data,
     #endif
         .handle_destroy = usb_host_handle_destroy,
     };
     static void usb_host_register_devices(void)
+    {
         usb_qdev_register(&usb_host_dev_info);
+    }
     device_init(usb_host_register_devices)
     static int usb_host_auto_add(const char *spec);
     static int usb_host_auto_del(const char *spec);

         if (!err)
             usb_device_add_dev(dev);
         else
             dev->handle_destroy(dev);
             dev->info->handle_destroy(dev);
+    }
     static int usb_device_add(const char *devname, int is_hotplug)
-...
         dev = port->dev;
         *lastp = port->next;
         usb_attach(port, NULL);
         dev->handle_destroy(dev);
         dev->info->handle_destroy(dev);
         port->next = free_usb_ports;
         free_usb_ports = port;
         return 0;

Archipelago » qemu

Revision 806b6024