--- qemu-0.10.5/block-vvfat.c.orig 2009-05-20 22:46:58.000000000 +0200 +++ qemu-0.10.5/block-vvfat.c 2009-05-28 11:16:51.531545800 +0200 @@ -813,7 +813,13 @@ static inline uint32_t sector2cluster(BDRVVVFATState* s,off_t sector_num) { - return (sector_num-s->faked_sectors)/s->sectors_per_cluster; + uint32_t ret; + + if (sector_num < s->faked_sectors) + ret = 0; + else + ret = (sector_num-s->faked_sectors)/s->sectors_per_cluster; + return ret; } static inline off_t cluster2sector(BDRVVVFATState* s, uint32_t cluster_num) --- qemu-0.10.5/configure.orig 2009-05-20 22:46:58.000000000 +0200 +++ qemu-0.10.5/configure 2009-05-28 13:28:12.282918400 +0200 @@ -201,17 +201,21 @@ CYGWIN*) mingw32="yes" OS_CFLAGS="-mno-cygwin" +VL_OS_LDFLAGS="-mno-cygwin" +usb="generic" if [ "$cpu" = "i386" ] ; then kqemu="yes" fi -audio_possible_drivers="sdl" +audio_possible_drivers="dsound sdl fmod" ;; MINGW32*) mingw32="yes" +usb="generic" if [ "$cpu" = "i386" ] ; then kqemu="yes" fi audio_possible_drivers="dsound sdl fmod" +audio_drv_list="dsound sdl fmod" ;; GNU/kFreeBSD) audio_drv_list="oss" @@ -1464,19 +1468,6 @@ echo "#define CONFIG_UNAME_RELEASE \"$uname_release\"" >> $config_h -# USB host support -case "$usb" in -linux) - echo "HOST_USB=linux" >> $config_mak -;; -bsd) - echo "HOST_USB=bsd" >> $config_mak -;; -*) - echo "HOST_USB=stub" >> $config_mak -;; -esac - tools= if test `expr "$target_list" : ".*softmmu.*"` != 0 ; then tools="qemu-img\$(EXESUF) $tools" @@ -1488,6 +1479,38 @@ test -f ${config_h}~ && cmp -s $config_h ${config_h}~ && mv ${config_h}~ $config_h +# USB host support +if [ "$usb" = "generic" ]; then + if `libusb-config --libs 1>&2> /dev/null`; then + LIBUSB_LIBS=`libusb-config --libs 2> /dev/null` + LIBUSB_CFLAGS=`libusb-config --cflags 2> /dev/null` + else + LIBUSB_LIBS=-lusb + fi + + # libusb probe + cat > $TMPC << EOF +#include +int main( void ) { usb_set_debug(0); return 0; } +EOF + + if ! $cc -o $TMPE $TMPC $LIBUSB_LIBS $LIBUSB_CFLAGS $LDFLAGS 2> /dev/null ; then + usb="stub" + fi +fi +case "$usb" in +linux) + echo "HOST_USB=linux" >> $config_mak +;; +generic) + echo "HOST_USB=libusb" >> $config_mak + echo "LIBUSB_LIBS=$LIBUSB_LIBS" >> $config_mak +;; +*) + echo "HOST_USB=stub" >> $config_mak +;; +esac + for target in $target_list; do target_dir="$target" config_mak=$target_dir/config.mak --- qemu-0.10.5/Makefile.target.orig 2009-05-20 22:46:58.000000000 +0200 +++ qemu-0.10.5/Makefile.target 2009-05-28 11:16:51.609668800 +0200 @@ -564,6 +564,10 @@ # USB layer OBJS+= usb-ohci.o +ifeq ($(HOST_USB), libusb) +LIBS+=$(LIBUSB_LIBS) +endif + # EEPROM emulation OBJS += eeprom93xx.o --- qemu-0.10.5/osdep.c.orig 2009-05-20 22:46:59.000000000 +0200 +++ qemu-0.10.5/osdep.c 2009-05-28 11:16:51.640918000 +0200 @@ -224,9 +224,10 @@ fd = open(filename, O_RDWR | O_CREAT, 0600); if (fd == -1) return -1; - +#ifndef __CYGWIN__ if (lockf(fd, F_TLOCK, 0) == -1) return -1; +#endif len = snprintf(buffer, sizeof(buffer), "%ld\n", (long)getpid()); if (write(fd, buffer, len) != len) --- qemu-0.10.5/qemu_socket.h.orig 2009-05-20 22:47:00.000000000 +0200 +++ qemu-0.10.5/qemu_socket.h 2009-05-28 11:16:51.672167200 +0200 @@ -14,6 +14,7 @@ #define EWOULDBLOCK WSAEWOULDBLOCK #define EINTR WSAEINTR #define EINPROGRESS WSAEINPROGRESS +#define EADDRNOTAVAIL WSAEADDRNOTAVAIL int inet_aton(const char *cp, struct in_addr *ia); --- qemu-0.10.5/slirp/bootp.c.orig 2009-05-20 22:47:00.000000000 +0200 +++ qemu-0.10.5/slirp/bootp.c 2009-05-28 11:16:51.719041000 +0200 @@ -66,6 +66,18 @@ return bc; } +/* From VirtualBox */ +static void release_addr(struct in_addr *paddr) +{ + int i; + + i = ntohl(paddr->s_addr) - START_ADDR - ntohl(special_addr.s_addr); + if (i >= NB_ADDR) + return; + memset(bootp_clients[i].macaddr, '\0', 6); + bootp_clients[i].allocated = 0; +} + static BOOTPClient *find_addr(struct in_addr *paddr, const uint8_t *macaddr) { BOOTPClient *bc; @@ -133,6 +145,7 @@ struct in_addr dns_addr; int dhcp_msg_type, val; uint8_t *q; + int freply_nack = 0; /* extract exact DHCP msg type */ dhcp_decode(bp->bp_vend, DHCP_OPT_LEN, &dhcp_msg_type); @@ -141,6 +154,13 @@ if (dhcp_msg_type == 0) dhcp_msg_type = DHCPREQUEST; /* Force reply for old BOOTP clients */ + if (dhcp_msg_type == DHCPRELEASE) { + release_addr(&bp->bp_ciaddr); + dprintf("released addr=%08lx\n", ntohl(bp->bp_ciaddr.s_addr)); + /* This message is not to be answered in any way. */ + return; + } + if (dhcp_msg_type != DHCPDISCOVER && dhcp_msg_type != DHCPREQUEST) return; @@ -155,7 +175,6 @@ memset(rbp, 0, sizeof(struct bootp_t)); if (dhcp_msg_type == DHCPDISCOVER) { - new_addr: bc = get_new_addr(&daddr.sin_addr); if (!bc) { dprintf("no address left\n"); @@ -165,9 +184,11 @@ } else { bc = find_addr(&daddr.sin_addr, bp->bp_hwaddr); if (!bc) { - /* if never assigned, behaves as if it was already - assigned (windows fix because it remembers its address) */ - goto new_addr; + /* if never assigned, reply DHCPNACK to BROADCAST. + (windows fix because it remembers its address). */ + daddr.sin_addr.s_addr = htonl(0xffffffff); + freply_nack = 1; + dprintf("reply NACK\n"); } } @@ -188,6 +209,9 @@ rbp->bp_hlen = 6; memcpy(rbp->bp_hwaddr, bp->bp_hwaddr, 6); + if (freply_nack) + rbp->bp_yiaddr.s_addr = htonl(0); /* When NACK, IP address is 0. */ + else rbp->bp_yiaddr = daddr.sin_addr; /* Client IP address */ rbp->bp_siaddr = saddr.sin_addr; /* Server IP address */ @@ -204,11 +228,14 @@ } else if (dhcp_msg_type == DHCPREQUEST) { *q++ = RFC2132_MSG_TYPE; *q++ = 1; + if (freply_nack) + *q++ = DHCPNACK; + else *q++ = DHCPACK; } if (dhcp_msg_type == DHCPDISCOVER || - dhcp_msg_type == DHCPREQUEST) { + ((dhcp_msg_type == DHCPREQUEST) && !freply_nack)) { *q++ = RFC2132_SRV_ID; *q++ = 4; memcpy(q, &saddr.sin_addr, 4); --- qemu-0.10.5/slirp/bootp.h.orig 2009-05-20 22:47:00.000000000 +0200 +++ qemu-0.10.5/slirp/bootp.h 2009-05-28 11:16:51.734665600 +0200 @@ -71,6 +71,8 @@ #define DHCPOFFER 2 #define DHCPREQUEST 3 #define DHCPACK 5 +#define DHCPNACK 6 +#define DHCPRELEASE 7 #define RFC1533_VENDOR_MAJOR 0 #define RFC1533_VENDOR_MINOR 0 --- qemu-0.10.5/usb-libusb.c.orig 2009-05-28 11:16:51.734665600 +0200 +++ qemu-0.10.5/usb-libusb.c 2009-05-28 11:16:51.734665600 +0200 @@ -0,0 +1,536 @@ +/* + * Generic libusb host USB redirector + * + * Copyright (c) 2006 Lonnie Mendez + * Code adapted from and modified from usb-linux.c + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ + +#include "qemu-common.h" +#include "hw/usb.h" +#include "console.h" + +#include +#if !defined(ETIMEDOUT) && defined(_WIN32) +#define ETIMEDOUT 116 +#endif + + +typedef int USBScanFunc(void *opaque, int bus_num, int addr, int class_id, + int vendor_id, int product_id, + const char *product_name, int speed); +static int usb_host_find_device(int *pbus_num, int *paddr, + const char *devname, struct usb_device **device); + + +//#define DEBUG +/* should be adjustable for interrupt endpoints */ +#define TRANS_TIMEOUT 50 + +typedef struct USBHostDevice { + USBDevice dev; + int num_interfaces; + struct usb_dev_handle *udev; +} USBHostDevice; +static USBHostDevice *hostdev_find(int bus_num, int addr); +static void usb_host_handle_reset(USBDevice *dev) +{ +#ifdef DEBUG + printf("usb_host_handle_reset called\n"); +#endif + +#if 0 + USBHostDevice *s = (USBHostDevice *)dev; + /* USBDEVFS_RESET, but not the first time as it has already be + * done by the host OS - usb_reset() - must reopen handle + */ + usb_reset(s->udev); +#endif +} + +static int usb_host_handle_control(USBDevice *dev, + int request, + int value, + int index, + int length, + uint8_t *data) +{ + USBHostDevice *s = (USBHostDevice *)dev; + int ret; + + if (request == (DeviceOutRequest | USB_REQ_SET_ADDRESS)) { + /* specific SET_ADDRESS support */ + dev->addr = value; + return 0; + } else { + ret = usb_control_msg(s->udev, request >> 8, request & 0xff, value, index, + data, length, TRANS_TIMEOUT); + if (ret < 0) { +#ifdef DEBUG + printf("handle_control: ret is %d - %s\n", ret, usb_strerror()); +#endif + // TODO: figure out how usb_clear_halt()/etc fit in for different host OS + switch(ret) { + case -ETIMEDOUT: + return USB_RET_NAK; + case -EIO: + default: + return USB_RET_STALL; + } + } else { + return ret; + } + } +} + +static int usb_host_handle_data(USBDevice *dev, USBPacket *p) +{ + USBHostDevice *s = (USBHostDevice *)dev; + int ret = 0; +#ifdef DEBUG + int i; +#endif + uint8_t devep = p->devep; + int pid = p->pid; + uint8_t *data = p->data; + int len = p->len; + + /* XXX: optimize and handle all data types by looking at the + config descriptor */ + if (pid == USB_TOKEN_IN) + devep |= 0x80; + +#ifdef DEBUG + if (pid != USB_TOKEN_IN) { + printf("writing(%d bytes - to ep %x):\n", len, devep); + for (i = 0; i < len; i++) + printf("%x ", data[i]); + printf("\n"); + } +#endif + + /* most libusb backends channel interrupt packets to a bulk transfer + * handler, with the exception of bsd.c */ + switch(pid) { + case USB_TOKEN_IN: + ret = usb_bulk_read(s->udev, devep, data, len, TRANS_TIMEOUT); + break; + case USB_TOKEN_OUT: + ret = usb_bulk_write(s->udev, devep, data, len, TRANS_TIMEOUT); + break; + } + +#ifdef DEBUG + if (pid == USB_TOKEN_IN) { + printf("reading(%d bytes - from ep %x):\n", ret, devep); + for (i = 0; i < ret; i++) + printf("%x ", data[i]); + printf("\n"); + } +#endif + + if (ret < 0) { +#ifdef DEBUG + printf("handle_data: ret is %d - %s\n", ret, usb_strerror()); +#endif + // TODO: figure out how usb_clear_halt()/etc fit in for different host OS + switch(ret) { + case -ETIMEDOUT: + return USB_RET_NAK; + case -EIO: /* stall condition on win32 - same for mac os x? */ + usb_clear_halt(s->udev, devep); + case -EPIPE: + default: + return USB_RET_STALL; + } + } else { + return ret; + } +} + +static void usb_host_handle_destroy(USBDevice *dev) +{ + USBHostDevice *s = (USBHostDevice *)dev; + int i; + + if (!s) + return; + + for (i = 0; i < s->num_interfaces; i++) + usb_release_interface(s->udev, i); + usb_close(s->udev); + s->udev = NULL; + qemu_free(s); +} + +/* XXX: exclude high speed devices or implement EHCI */ +USBDevice *usb_host_device_open(const char *devname) +{ + USBHostDevice *dev; + struct usb_dev_handle *udev = NULL; + struct usb_device *device = NULL; + struct usb_config_descriptor config_desc; + int config_descr_len, nb_interfaces; + int bus_num, addr, interface, ret; + char product_name[32] ; + + if ((ret = usb_host_find_device(&bus_num, &addr, devname, &device)) < 0) + return NULL; + + if (!device) + return NULL; + + udev = usb_open(device); + + if (!udev) { +#ifdef DEBUG + printf("couldn't open usb device at %d.%d\n", bus_num, addr); +#endif + return NULL; + } + + /* read the 1st config descriptor */ + config_descr_len = usb_get_descriptor(udev, 2, 0, &config_desc, sizeof(config_desc)); + if (config_descr_len <= 0) { + printf("read config_desc: %s", usb_strerror()); + goto fail; + } + + if (config_descr_len > sizeof(config_desc)) { + printf("config_desc size mismatch\n"); + goto fail; + } + + nb_interfaces = config_desc.bNumInterfaces; + usb_set_configuration(udev, config_desc.bConfigurationValue); + + for (interface = 0; interface < nb_interfaces; interface++) { + /* might as well */ +#ifdef LIBUSB_HAS_DETACH_KERNEL_DRIVER_NP + usb_detach_kernel_driver_np(udev, interface); +#endif + + ret = usb_claim_interface(udev, interface); + + if (ret < 0) { + printf("usb_claim_interface: %s", usb_strerror()); + fail: + if (udev) + usb_close(udev); + return NULL; + } + } + +#ifdef DEBUG + printf("host USB device %d.%d grabbed\n", bus_num, addr); +#endif + + dev = qemu_mallocz(sizeof(USBHostDevice)); + if (!dev) + goto fail; + + /* not accurate - might be better off reporting only low/full */ + switch (device->descriptor.bcdUSB) { + case 0x0110: + dev->dev.speed = USB_SPEED_FULL; + break; + case 0x0200: + dev->dev.speed = USB_SPEED_HIGH; + break; + case 0x0100: + dev->dev.speed = USB_SPEED_LOW; + break; + default: + dev->dev.speed = USB_SPEED_FULL; + } + + dev->udev = udev; + dev->num_interfaces = nb_interfaces; + dev->dev.handle_packet = usb_generic_handle_packet; + + dev->dev.handle_reset = usb_host_handle_reset; + dev->dev.handle_control = usb_host_handle_control; + dev->dev.handle_data = usb_host_handle_data; + dev->dev.handle_destroy = usb_host_handle_destroy; + + /* get product string if available */ + usb_get_string_simple(udev, device->descriptor.iProduct, + product_name, sizeof(product_name)); + + if (product_name[0] == '\0') + snprintf(dev->dev.devname, sizeof(dev->dev.devname), + "host:%s", devname); + else + pstrcpy(dev->dev.devname, sizeof(dev->dev.devname), + product_name); + + return (USBDevice *)dev; +} + +int usb_host_device_close(const char *devname) +{ + USBHostDevice *dev; + struct usb_device *device = NULL; + int bus_num, addr, ret; + + if ((ret = usb_host_find_device(&bus_num, &addr, devname, &device)) < 0) + return -1; + + if (!device) + return -1; + dev = hostdev_find(bus_num, addr); + if (dev) { + usb_device_del_addr(0, dev->dev.addr); + return 0; + } + + return -1; +} +static USBHostDevice *hostdev_find(int bus_num, int addr) +{ + return NULL; +} + +static int usb_host_scan(void *opaque, struct usb_device **device, + USBScanFunc *func) +{ + struct usb_bus *busses, *bus; + struct usb_dev_handle *udev; + struct usb_device *dev; + uint16_t vendor_id, product_id, class_id, speed; + char product_name[256]; + int ret = 0; + +#ifdef DEBUG + usb_set_debug(255); +#else + usb_set_debug(0); +#endif + + usb_init(); + usb_find_busses(); + usb_find_devices(); + + busses = usb_get_busses(); + + for (bus = busses; bus; bus = bus->next) { + for (dev = bus->devices; dev; dev = dev->next) { + vendor_id = dev->descriptor.idVendor; + product_id = dev->descriptor.idProduct; + + /* only find devices - not root hubs */ + if (vendor_id == 0x0000 && product_id == 0x0000) + continue; + + udev = usb_open(dev); + if (!udev) + continue; + + class_id = dev->descriptor.bDeviceClass; + + /* not accurate - might be better off reporting only low/full */ + switch (dev->descriptor.bcdUSB) { + case 0x0110: + speed = USB_SPEED_FULL; + break; + case 0x0200: + speed = USB_SPEED_HIGH; + break; + case 0x0100: + speed = USB_SPEED_LOW; + break; + default: + speed = USB_SPEED_FULL; + } + + ret = usb_get_string_simple(udev, dev->descriptor.iProduct, + product_name, sizeof(product_name)); + if (ret < 0) + product_name[0] = '\0'; + + ret = func(opaque, bus->location, dev->devnum, class_id, vendor_id, + product_id, product_name, speed); + + usb_close(udev); + + if (ret) { + *device = dev; + goto the_end; + } + } + } + +the_end: + return ret; + +} + +typedef struct FindDeviceState { + int vendor_id; + int product_id; + int bus_num; + int addr; +} FindDeviceState; + +static int usb_host_find_device_scan(void *opaque, int bus_num, int addr, + int class_id, + int vendor_id, int product_id, + const char *product_name, int speed) +{ + FindDeviceState *s = opaque; + if (s->vendor_id == -1 && + s->product_id == -1 && + bus_num == s->bus_num && + addr == s->addr) { + s->vendor_id = vendor_id; + s->product_id = product_id; + return 1; + } else if (vendor_id == s->vendor_id && + product_id == s->product_id) { + s->bus_num = bus_num; + s->addr = addr; + return 1; + } else { + return 0; + } +} + +/* the syntax is : + 'bus.addr' (decimal numbers) or + 'vendor_id:product_id' (hexa numbers) */ +static int usb_host_find_device(int *pbus_num, int *paddr, + const char *devname, struct usb_device **device) +{ + const char *p; + int ret; + FindDeviceState fs; + + p = strchr(devname, '.'); + if (p) { + fs.vendor_id = -1; + fs.product_id = -1; + fs.bus_num = strtoul(devname, NULL, 0); + fs.addr = strtoul(p + 1, NULL, 0); + ret = usb_host_scan(&fs, device, usb_host_find_device_scan); + if (ret) { + *pbus_num = fs.bus_num; + *paddr = fs.addr; + return 0; + } + } + p = strchr(devname, ':'); + if (p) { + fs.vendor_id = strtoul(devname, NULL, 16); + fs.product_id = strtoul(p + 1, NULL, 16); + ret = usb_host_scan(&fs, device, usb_host_find_device_scan); + if (ret) { + *pbus_num = fs.bus_num; + *paddr = fs.addr; + return 0; + } + } + return -1; +} + +/**********************/ +/* USB host device info */ + +struct usb_class_info { + int class; + const char *class_name; +}; + +static const struct usb_class_info usb_class_info[] = { + { USB_CLASS_AUDIO, "Audio"}, + { USB_CLASS_COMM, "Communication"}, + { USB_CLASS_HID, "HID"}, + { USB_CLASS_HUB, "Hub" }, + { USB_CLASS_PHYSICAL, "Physical" }, + { USB_CLASS_PRINTER, "Printer" }, + { USB_CLASS_MASS_STORAGE, "Storage" }, + { USB_CLASS_CDC_DATA, "Data" }, + { USB_CLASS_APP_SPEC, "Application Specific" }, + { USB_CLASS_VENDOR_SPEC, "Vendor Specific" }, + { USB_CLASS_STILL_IMAGE, "Still Image" }, + { USB_CLASS_CSCID, "Smart Card" }, + { USB_CLASS_CONTENT_SEC, "Content Security" }, + { -1, NULL } +}; + +static const char *usb_class_str(uint8_t class) +{ + const struct usb_class_info *p; + for(p = usb_class_info; p->class != -1; p++) { + if (p->class == class) + break; + } + return p->class_name; +} + +void usb_info_device(int bus_num, int addr, int class_id, + int vendor_id, int product_id, + const char *product_name, + int speed) +{ + const char *class_str, *speed_str; + + switch(speed) { + case USB_SPEED_LOW: + speed_str = "1.5"; + break; + case USB_SPEED_FULL: + speed_str = "12"; + break; + case USB_SPEED_HIGH: + speed_str = "480"; + break; + default: + speed_str = "?"; + break; + } + + term_printf(" Device %d.%d, speed %s Mb/s\n", + bus_num, addr, speed_str); + class_str = usb_class_str(class_id); + if (class_str) + term_printf(" %s:", class_str); + else + term_printf(" Class %02x:", class_id); + term_printf(" USB device %04x:%04x", vendor_id, product_id); + if (product_name[0] != '\0') + term_printf(", %s", product_name); + term_printf("\n"); +} + +static int usb_host_info_device(void *opaque, int bus_num, int addr, + int class_id, + int vendor_id, int product_id, + const char *product_name, + int speed) +{ + usb_info_device(bus_num, addr, class_id, vendor_id, product_id, + product_name, speed); + return 0; +} + +void usb_host_info(void) +{ + usb_host_scan(NULL, NULL, usb_host_info_device); +}