usb: move usb_{hi,lo} helpers to header file.

Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
usb: add vendor request defines
2013-11-28 15:39:27 +01:00 · 2013-11-28 15:39:27 +01:00 · 2013-11-28 15:39:27 +01:00 · 2013-11-28 15:39:27 +01:00 · 2013-11-28 15:39:27 +01:00 · 2013-11-26 09:21:17 +01:00
76 changed files with 397 additions and 5487 deletions
--- a/Makefile.target
+++ b/Makefile.target
@@ -31,10 +31,6 @@ PROGS+=$(QEMU_PROGW)
 endif
 STPFILES=

-ifdef CONFIG_LINUX_USER
-PROGS+=$(QEMU_PROG)-binfmt
-endif
-
 config-target.h: config-target.h-timestamp
 config-target.h-timestamp: config-target.mak

@@ -96,8 +92,6 @@ QEMU_CFLAGS+=-I$(SRC_PATH)/linux-user/$(TARGET_ABI_DIR) -I$(SRC_PATH)/linux-user
 obj-y += linux-user/
 obj-y += gdbstub.o thunk.o user-exec.o

-obj-binfmt-y += linux-user/
-
 endif #CONFIG_LINUX_USER

 #########################################################
@@ -146,9 +140,6 @@ endif # CONFIG_SOFTMMU
 %/translate.o: QEMU_CFLAGS += $(TRANSLATE_OPT_CFLAGS)

 nested-vars += obj-y
-ifdef CONFIG_LINUX_USER
-nested-vars += obj-binfmt-y
-endif

 # This resolves all nested paths, so it must come last
 include $(SRC_PATH)/Makefile.objs
@@ -171,9 +162,6 @@ $(QEMU_PROG): $(all-obj-y) ../libqemuutil.a ../libqemustub.a
 	$(call LINK,$^)
 endif

-$(QEMU_PROG)-binfmt: $(obj-binfmt-y)
-	$(call LINK,$^)
-
 gdbstub-xml.c: $(TARGET_XML_FILES) $(SRC_PATH)/scripts/feature_to_c.sh
 	$(call quiet-command,rm -f $@ && $(SHELL) $(SRC_PATH)/scripts/feature_to_c.sh $@ $(TARGET_XML_FILES),"  GEN   $(TARGET_DIR)$@")

--- a/2
+++ b/2
@@ -1 +1 @@
-1.7.0
+1.6.92
--- a/block.c
+++ b/block.c
@@ -4503,7 +4503,7 @@ void bdrv_img_create(const char *filename, const char *fmt,
                     Error **errp, bool quiet)
 {
    QEMUOptionParameter *param = NULL, *create_options = NULL;
-    QEMUOptionParameter *backing_fmt, *backing_file, *size, *scsi;
+    QEMUOptionParameter *backing_fmt, *backing_file, *size;
    BlockDriverState *bs = NULL;
    BlockDriver *drv, *proto_drv;
    BlockDriver *backing_drv = NULL;
@@ -4617,10 +4617,6 @@ void bdrv_img_create(const char *filename, const char *fmt,
    if (!quiet) {
        printf("Formatting '%s', fmt=%s ", filename, fmt);
        print_option_parameters(param);
-        scsi = get_option_parameter(param, BLOCK_OPT_SCSI);
-        if (scsi && scsi->value.n) {
-            printf(", SCSI");
-        }
        puts("");
    }
    ret = bdrv_create(drv, filename, param, &local_err);
--- a/block/Makefile.objs
+++ b/block/Makefile.objs
@@ -22,7 +22,5 @@ common-obj-y += stream.o
 common-obj-y += commit.o
 common-obj-y += mirror.o
 common-obj-y += backup.o
-common-obj-y += dictzip.o
-common-obj-y += tar.o

 $(obj)/curl.o: QEMU_CFLAGS+=$(CURL_CFLAGS)
--- a/block/dictzip.c
+++ b/block/dictzip.c
@@ -1,596 +0,0 @@
-/*
- * DictZip Block driver for dictzip enabled gzip files
- *
- * Use the "dictzip" tool from the "dictd" package to create gzip files that
- * contain the extra DictZip headers.
- *
- * dictzip(1) is a compression program which creates compressed files in the
- * gzip format (see RFC 1952). However, unlike gzip(1), dictzip(1) compresses
- * the file in pieces and stores an index to the pieces in the gzip header.
- * This allows random access to the file at the granularity of the compressed
- * pieces (currently about 64kB) while maintaining good compression ratios
- * (within 5% of the expected ratio for dictionary data).
- * dictd(8) uses files stored in this format.
- *
- * For details on DictZip see http://dict.org/.
- *
- * Copyright (c) 2009 Alexander Graf <agraf@suse.de>
- *
- * 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 "block/block_int.h"
-#include <zlib.h>
-
-// #define DEBUG
-
-#ifdef DEBUG
-#define dprintf(fmt, ...) do { printf("dzip: " fmt, ## __VA_ARGS__); } while (0)
-#else
-#define dprintf(fmt, ...) do { } while (0)
-#endif
-
-#define SECTOR_SIZE 512
-#define Z_STREAM_COUNT 4
-#define CACHE_COUNT 20
-
-/* magic values */
-
-#define GZ_MAGIC1     0x1f
-#define GZ_MAGIC2     0x8b
-#define DZ_MAGIC1      'R'
-#define DZ_MAGIC2      'A'
-
-#define GZ_FEXTRA     0x04      /* Optional field (random access index)    */
-#define GZ_FNAME      0x08      /* Original name                           */
-#define GZ_COMMENT    0x10      /* Zero-terminated, human-readable comment */
-#define GZ_FHCRC      0x02      /* Header CRC16                            */
-
-/* offsets */
-
-#define GZ_ID            0      /* GZ_MAGIC (16bit)                        */
-#define GZ_FLG           3      /* FLaGs (see above)                       */
-#define GZ_XLEN         10      /* eXtra LENgth (16bit)                    */
-#define GZ_SI           12      /* Subfield ID (16bit)                     */
-#define GZ_VERSION      16      /* Version for subfield format             */
-#define GZ_CHUNKSIZE    18      /* Chunk size (16bit)                      */
-#define GZ_CHUNKCNT     20      /* Number of chunks (16bit)                */
-#define GZ_RNDDATA      22      /* Random access data (16bit)              */
-
-#define GZ_99_CHUNKSIZE 18      /* Chunk size (32bit)                      */
-#define GZ_99_CHUNKCNT  22      /* Number of chunks (32bit)                */
-#define GZ_99_FILESIZE  26      /* Size of unpacked file (64bit)           */
-#define GZ_99_RNDDATA   34      /* Random access data (32bit)              */
-
-struct BDRVDictZipState;
-
-typedef struct DictZipAIOCB {
-    BlockDriverAIOCB common;
-    struct BDRVDictZipState *s;
-    QEMUIOVector *qiov;          /* QIOV of the original request */
-    QEMUIOVector *qiov_gz;       /* QIOV of the gz subrequest */
-    QEMUBH *bh;                  /* BH for cache */
-    z_stream *zStream;           /* stream to use for decoding */
-    int zStream_id;              /* stream id of the above pointer */
-    size_t start;                /* offset into the uncompressed file */
-    size_t len;                  /* uncompressed bytes to read */
-    uint8_t *gzipped;            /* the gzipped data */
-    uint8_t *buf;                /* cached result */
-    size_t gz_len;               /* amount of gzip data */
-    size_t gz_start;             /* uncompressed starting point of gzip data */
-    uint64_t offset;             /* offset for "start" into the uncompressed chunk */
-    int chunks_len;              /* amount of uncompressed data in all gzip data */
-} DictZipAIOCB;
-
-typedef struct dict_cache {
-    size_t start;
-    size_t len;
-    uint8_t *buf;
-} DictCache;
-
-typedef struct BDRVDictZipState {
-    BlockDriverState *hd;
-    z_stream zStream[Z_STREAM_COUNT];
-    DictCache cache[CACHE_COUNT];
-    int cache_index;
-    uint8_t  stream_in_use;
-    uint64_t chunk_len;
-    uint32_t chunk_cnt;
-    uint16_t *chunks;
-    uint32_t *chunks32;
-    uint64_t *offsets;
-    int64_t file_len;
-} BDRVDictZipState;
-
-static int dictzip_probe(const uint8_t *buf, int buf_size, const char *filename)
-{
-    if (buf_size < 2)
-        return 0;
-
-    /* We match on every gzip file */
-    if ((buf[0] == GZ_MAGIC1) && (buf[1] == GZ_MAGIC2))
-        return 100;
-
-    return 0;
-}
-
-static int start_zStream(z_stream *zStream)
-{
-    zStream->zalloc    = NULL;
-    zStream->zfree     = NULL;
-    zStream->opaque    = NULL;
-    zStream->next_in   = 0;
-    zStream->avail_in  = 0;
-    zStream->next_out  = NULL;
-    zStream->avail_out = 0;
-
-    return inflateInit2( zStream, -15 );
-}
-
-static QemuOptsList runtime_opts = {
-    .name = "dzip",
-    .head = QTAILQ_HEAD_INITIALIZER(runtime_opts.head),
-    .desc = {
-        {
-            .name = "filename",
-            .type = QEMU_OPT_STRING,
-            .help = "URL to the dictzip file",
-        },
-        { /* end of list */ }
-    },
-};
-
-static int dictzip_open(BlockDriverState *bs, QDict *options, int flags, Error **errp)
-{
-    BDRVDictZipState *s = bs->opaque;
-    const char *err = "Unknown (read error?)";
-    uint8_t magic[2];
-    char buf[100];
-    uint8_t header_flags;
-    uint16_t chunk_len16;
-    uint16_t chunk_cnt16;
-    uint16_t header_ver;
-    uint16_t tmp_short;
-    uint64_t offset;
-    int chunks_len;
-    int headerLength = GZ_XLEN - 1;
-    int rnd_offs;
-    int ret;
-    int i;
-    QemuOpts *opts;
-    Error *local_err = NULL;
-    const char *filename;
-
-    opts = qemu_opts_create_nofail(&runtime_opts);
-    qemu_opts_absorb_qdict(opts, options, &local_err);
-    if (error_is_set(&local_err)) {
-        error_propagate(errp, local_err);
-        ret = -EINVAL;
-        goto fail;
-    }
-
-    filename = qemu_opt_get(opts, "filename");
-
-    if (!strncmp(filename, "dzip://", 7))
-        filename += 7;
-    else if (!strncmp(filename, "dzip:", 5))
-        filename += 5;
-
-    ret = bdrv_file_open(&s->hd, filename, NULL, flags, &local_err);
-    if (ret < 0) {
-        error_propagate(errp, local_err);
-        qemu_opts_del(opts);
-        return ret;
-    }
-
-    /* initialize zlib streams */
-    for (i = 0; i < Z_STREAM_COUNT; i++) {
-        if (start_zStream( &s->zStream[i] ) != Z_OK) {
-            err = s->zStream[i].msg;
-            goto fail;
-        }
-    }
-
-    /* gzip header */
-    if (bdrv_pread(s->hd, GZ_ID, &magic, sizeof(magic)) != sizeof(magic))
-        goto fail;
-
-    if (!((magic[0] == GZ_MAGIC1) && (magic[1] == GZ_MAGIC2))) {
-        err = "No gzip file";
-        goto fail;
-    }
-
-    /* dzip header */
-    if (bdrv_pread(s->hd, GZ_FLG, &header_flags, 1) != 1)
-        goto fail;
-
-    if (!(header_flags & GZ_FEXTRA)) {
-        err = "Not a dictzip file (wrong flags)";
-        goto fail;
-    }
-
-    /* extra length */
-    if (bdrv_pread(s->hd, GZ_XLEN, &tmp_short, 2) != 2)
-        goto fail;
-
-    headerLength += le16_to_cpu(tmp_short) + 2;
-
-    /* DictZip magic */
-    if (bdrv_pread(s->hd, GZ_SI, &magic, 2) != 2)
-        goto fail;
-
-    if (magic[0] != DZ_MAGIC1 || magic[1] != DZ_MAGIC2) {
-        err = "Not a dictzip file (missing extra magic)";
-        goto fail;
-    }
-
-    /* DictZip version */
-    if (bdrv_pread(s->hd, GZ_VERSION, &header_ver, 2) != 2)
-        goto fail;
-
-    header_ver = le16_to_cpu(header_ver);
-
-    switch (header_ver) {
-        case 1: /* Normal DictZip */
-            /* number of chunks */
-            if (bdrv_pread(s->hd, GZ_CHUNKSIZE, &chunk_len16, 2) != 2)
-                goto fail;
-
-            s->chunk_len = le16_to_cpu(chunk_len16);
-
-            /* chunk count */
-            if (bdrv_pread(s->hd, GZ_CHUNKCNT, &chunk_cnt16, 2) != 2)
-                goto fail;
-
-            s->chunk_cnt = le16_to_cpu(chunk_cnt16);
-            chunks_len = sizeof(short) * s->chunk_cnt;
-            rnd_offs = GZ_RNDDATA;
-            break;
-        case 99: /* Special Alex pigz version */
-            /* number of chunks */
-            if (bdrv_pread(s->hd, GZ_99_CHUNKSIZE, &s->chunk_len, 4) != 4)
-                goto fail;
-
-            dprintf("chunk len [%#x] = %d\n", GZ_99_CHUNKSIZE, s->chunk_len);
-            s->chunk_len = le32_to_cpu(s->chunk_len);
-
-            /* chunk count */
-            if (bdrv_pread(s->hd, GZ_99_CHUNKCNT, &s->chunk_cnt, 4) != 4)
-                goto fail;
-
-            s->chunk_cnt = le32_to_cpu(s->chunk_cnt);
-
-            dprintf("chunk len | count = %d | %d\n", s->chunk_len, s->chunk_cnt);
-
-            /* file size */
-            if (bdrv_pread(s->hd, GZ_99_FILESIZE, &s->file_len, 8) != 8)
-                goto fail;
-
-            s->file_len = le64_to_cpu(s->file_len);
-            chunks_len = sizeof(int) * s->chunk_cnt;
-            rnd_offs = GZ_99_RNDDATA;
-            break;
-        default:
-            err = "Invalid DictZip version";
-            goto fail;
-    }
-
-    /* random access data */
-    s->chunks = g_malloc(chunks_len);
-    if (header_ver == 99)
-        s->chunks32 = (uint32_t *)s->chunks;
-
-    if (bdrv_pread(s->hd, rnd_offs, s->chunks, chunks_len) != chunks_len)
-        goto fail;
-
-    /* orig filename */
-    if (header_flags & GZ_FNAME) {
-        if (bdrv_pread(s->hd, headerLength + 1, buf, sizeof(buf)) != sizeof(buf))
-            goto fail;
-
-        buf[sizeof(buf) - 1] = '\0';
-        headerLength += strlen(buf) + 1;
-
-        if (strlen(buf) == sizeof(buf))
-            goto fail;
-
-        dprintf("filename: %s\n", buf);
-    }
-
-    /* comment field */
-    if (header_flags & GZ_COMMENT) {
-        if (bdrv_pread(s->hd, headerLength, buf, sizeof(buf)) != sizeof(buf))
-            goto fail;
-
-        buf[sizeof(buf) - 1] = '\0';
-        headerLength += strlen(buf) + 1;
-
-        if (strlen(buf) == sizeof(buf))
-            goto fail;
-
-        dprintf("comment: %s\n", buf);
-    }
-
-    if (header_flags & GZ_FHCRC)
-        headerLength += 2;
-
-    /* uncompressed file length*/
-    if (!s->file_len) {
-        uint32_t file_len;
-
-        if (bdrv_pread(s->hd, bdrv_getlength(s->hd) - 4, &file_len, 4) != 4)
-            goto fail;
-
-        s->file_len = le32_to_cpu(file_len);
-    }
-
-    /* compute offsets */
-    s->offsets = g_malloc(sizeof( *s->offsets ) * s->chunk_cnt);
-
-    for (offset = headerLength + 1, i = 0; i < s->chunk_cnt; i++) {
-        s->offsets[i] = offset;
-        switch (header_ver) {
-        case 1:
-            offset += s->chunks[i];
-            break;
-        case 99:
-            offset += s->chunks32[i];
-            break;
-        }
-
-        dprintf("chunk %#x - %#x = offset %#x -> %#x\n", i * s->chunk_len, (i+1) * s->chunk_len, s->offsets[i], offset);
-    }
-    qemu_opts_del(opts);
-
-    return 0;
-
-fail:
-    fprintf(stderr, "DictZip: Error opening file: %s\n", err);
-    bdrv_unref(s->hd);
-    if (s->chunks)
-        g_free(s->chunks);
-    qemu_opts_del(opts);
-    return -EINVAL;
-}
-
-/* This callback gets invoked when we have the result in cache already */
-static void dictzip_cache_cb(void *opaque)
-{
-    DictZipAIOCB *acb = (DictZipAIOCB *)opaque;
-
-    qemu_iovec_from_buf(acb->qiov, 0, acb->buf, acb->len);
-    acb->common.cb(acb->common.opaque, 0);
-    qemu_bh_delete(acb->bh);
-    qemu_aio_release(acb);
-}
-
-/* This callback gets invoked by the underlying block reader when we have
- * all compressed data. We uncompress in here. */
-static void dictzip_read_cb(void *opaque, int ret)
-{
-    DictZipAIOCB *acb = (DictZipAIOCB *)opaque;
-    struct BDRVDictZipState *s = acb->s;
-    uint8_t *buf;
-    DictCache *cache;
-    int r;
-
-    buf = g_malloc(acb->chunks_len);
-
-    /* uncompress the chunk */
-    acb->zStream->next_in   = acb->gzipped;
-    acb->zStream->avail_in  = acb->gz_len;
-    acb->zStream->next_out  = buf;
-    acb->zStream->avail_out = acb->chunks_len;
-
-    r = inflate( acb->zStream,  Z_PARTIAL_FLUSH );
-    if ( (r != Z_OK) && (r != Z_STREAM_END) )
-        fprintf(stderr, "Error inflating: [%d] %s\n", r, acb->zStream->msg);
-
-    if ( r == Z_STREAM_END )
-        inflateReset(acb->zStream);
-
-    dprintf("inflating [%d] left: %d | %d bytes\n", r, acb->zStream->avail_in, acb->zStream->avail_out);
-    s->stream_in_use &= ~(1 << acb->zStream_id);
-
-    /* nofity the caller */
-    qemu_iovec_from_buf(acb->qiov, 0, buf + acb->offset, acb->len);
-    acb->common.cb(acb->common.opaque, 0);
-
-    /* fill the cache */
-    cache = &s->cache[s->cache_index];
-    s->cache_index++;
-    if (s->cache_index == CACHE_COUNT)
-        s->cache_index = 0;
-
-    cache->len = 0;
-    if (cache->buf)
-        g_free(cache->buf);
-    cache->start = acb->gz_start;
-    cache->buf = buf;
-    cache->len = acb->chunks_len;
-
-    /* free occupied ressources */
-    g_free(acb->qiov_gz);
-    qemu_aio_release(acb);
-}
-
-static void dictzip_aio_cancel(BlockDriverAIOCB *blockacb)
-{
-}
-
-static const AIOCBInfo dictzip_aiocb_info = {
-    .aiocb_size         = sizeof(DictZipAIOCB),
-    .cancel             = dictzip_aio_cancel,
-};
-
-/* This is where we get a request from a caller to read something */
-static BlockDriverAIOCB *dictzip_aio_readv(BlockDriverState *bs,
-        int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
-        BlockDriverCompletionFunc *cb, void *opaque)
-{
-    BDRVDictZipState *s = bs->opaque;
-    DictZipAIOCB *acb;
-    QEMUIOVector *qiov_gz;
-    struct iovec *iov;
-    uint8_t *buf;
-    size_t  start = sector_num * SECTOR_SIZE;
-    size_t  len = nb_sectors * SECTOR_SIZE;
-    size_t  end = start + len;
-    size_t  gz_start;
-    size_t  gz_len;
-    int64_t gz_sector_num;
-    int     gz_nb_sectors;
-    int     first_chunk, last_chunk;
-    int     first_offset;
-    int     i;
-
-    acb = qemu_aio_get(&dictzip_aiocb_info, bs, cb, opaque);
-    if (!acb)
-        return NULL;
-
-    /* Search Cache */
-    for (i = 0; i < CACHE_COUNT; i++) {
-        if (!s->cache[i].len)
-            continue;
-
-        if ((start >= s->cache[i].start) &&
-            (end <= (s->cache[i].start + s->cache[i].len))) {
-            acb->buf = s->cache[i].buf + (start - s->cache[i].start);
-            acb->len = len;
-            acb->qiov = qiov;
-            acb->bh = qemu_bh_new(dictzip_cache_cb, acb);
-            qemu_bh_schedule(acb->bh);
-
-            return &acb->common;
-        }
-    }
-
-    /* No cache, so let's decode */
-    do {
-        for (i = 0; i < Z_STREAM_COUNT; i++) {
-            if (!(s->stream_in_use & (1 << i))) {
-                s->stream_in_use |= (1 << i);
-                acb->zStream_id = i;
-                acb->zStream = &s->zStream[i];
-                break;
-            }
-        }
-    } while(!acb->zStream);
-
-    /* We need to read these chunks */
-    first_chunk  = start / s->chunk_len;
-    first_offset = start - first_chunk * s->chunk_len;
-    last_chunk   = end / s->chunk_len;
-
-    gz_start = s->offsets[first_chunk];
-    gz_len = 0;
-    for (i = first_chunk; i <= last_chunk; i++) {
-        if (s->chunks32)
-            gz_len += s->chunks32[i];
-        else
-            gz_len += s->chunks[i];
-    }
-
-    gz_sector_num = gz_start / SECTOR_SIZE;
-    gz_nb_sectors = (gz_len / SECTOR_SIZE);
-
-    /* account for tail and heads */
-    while ((gz_start + gz_len) > ((gz_sector_num + gz_nb_sectors) * SECTOR_SIZE))
-        gz_nb_sectors++;
-
-    /* Allocate qiov, iov and buf in one chunk so we only need to free qiov */
-    qiov_gz = g_malloc0(sizeof(QEMUIOVector) + sizeof(struct iovec) +
-                           (gz_nb_sectors * SECTOR_SIZE));
-    iov = (struct iovec *)(((char *)qiov_gz) + sizeof(QEMUIOVector));
-    buf = ((uint8_t *)iov) + sizeof(struct iovec *);
-
-    /* Kick off the read by the backing file, so we can start decompressing */
-    iov->iov_base = (void *)buf;
-    iov->iov_len = gz_nb_sectors * 512;
-    qemu_iovec_init_external(qiov_gz, iov, 1);
-
-    dprintf("read %d - %d => %d - %d\n", start, end, gz_start, gz_start + gz_len);
-
-    acb->s = s;
-    acb->qiov = qiov;
-    acb->qiov_gz = qiov_gz;
-    acb->start = start;
-    acb->len = len;
-    acb->gzipped = buf + (gz_start % SECTOR_SIZE);
-    acb->gz_len = gz_len;
-    acb->gz_start = first_chunk * s->chunk_len;
-    acb->offset = first_offset;
-    acb->chunks_len = (last_chunk - first_chunk + 1) * s->chunk_len;
-
-    return bdrv_aio_readv(s->hd, gz_sector_num, qiov_gz, gz_nb_sectors,
-                          dictzip_read_cb, acb);
-}
-
-static void dictzip_close(BlockDriverState *bs)
-{
-    BDRVDictZipState *s = bs->opaque;
-    int i;
-
-    for (i = 0; i < CACHE_COUNT; i++) {
-        if (!s->cache[i].len)
-            continue;
-
-        g_free(s->cache[i].buf);
-    }
-
-    for (i = 0; i < Z_STREAM_COUNT; i++) {
-        inflateEnd(&s->zStream[i]);
-    }
-
-    if (s->chunks)
-        g_free(s->chunks);
-
-    if (s->offsets)
-        g_free(s->offsets);
-
-    dprintf("Close\n");
-}
-
-static int64_t dictzip_getlength(BlockDriverState *bs)
-{
-    BDRVDictZipState *s = bs->opaque;
-    dprintf("getlength -> %ld\n", s->file_len);
-    return s->file_len;
-}
-
-static BlockDriver bdrv_dictzip = {
-    .format_name     = "dzip",
-    .protocol_name   = "dzip",
-
-    .instance_size   = sizeof(BDRVDictZipState),
-    .bdrv_file_open  = dictzip_open,
-    .bdrv_close      = dictzip_close,
-    .bdrv_getlength  = dictzip_getlength,
-    .bdrv_probe      = dictzip_probe,
-
-    .bdrv_aio_readv  = dictzip_aio_readv,
-};
-
-static void dictzip_block_init(void)
-{
-    bdrv_register(&bdrv_dictzip);
-}
-
-block_init(dictzip_block_init);
--- a/block/tar.c
+++ b/block/tar.c
@@ -1,395 +0,0 @@
-/*
- * Tar block driver
- *
- * Copyright (c) 2009 Alexander Graf <agraf@suse.de>
- *
- * 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 "block/block_int.h"
-
-// #define DEBUG
-
-#ifdef DEBUG
-#define dprintf(fmt, ...) do { printf("tar: " fmt, ## __VA_ARGS__); } while (0)
-#else
-#define dprintf(fmt, ...) do { } while (0)
-#endif
-
-#define SECTOR_SIZE      512
-
-#define POSIX_TAR_MAGIC  "ustar"
-#define OFFS_LENGTH      0x7c
-#define OFFS_TYPE        0x9c
-#define OFFS_MAGIC       0x101
-
-#define OFFS_S_SP        0x182
-#define OFFS_S_EXT       0x1e2
-#define OFFS_S_LENGTH    0x1e3
-#define OFFS_SX_EXT      0x1f8
-
-typedef struct SparseCache {
-    uint64_t start;
-    uint64_t end;
-} SparseCache;
-
-typedef struct BDRVTarState {
-    BlockDriverState *hd;
-    size_t file_sec;
-    uint64_t file_len;
-    SparseCache *sparse;
-    int sparse_num;
-    uint64_t last_end;
-    char longfile[2048];
-} BDRVTarState;
-
-static int tar_probe(const uint8_t *buf, int buf_size, const char *filename)
-{
-    if (buf_size < OFFS_MAGIC + 5)
-        return 0;
-
-    /* we only support newer tar */
-    if (!strncmp((char*)buf + OFFS_MAGIC, POSIX_TAR_MAGIC, 5))
-        return 100;
-
-    return 0;
-}
-
-static int str_ends(char *str, const char *end)
-{
-    int end_len = strlen(end);
-    int str_len = strlen(str);
-
-    if (str_len < end_len)
-        return 0;
-
-    return !strncmp(str + str_len - end_len, end, end_len);
-}
-
-static int is_target_file(BlockDriverState *bs, char *filename,
-                          char *header)
-{
-    int retval = 0;
-
-    if (str_ends(filename, ".raw"))
-        retval = 1;
-
-    if (str_ends(filename, ".qcow"))
-        retval = 1;
-
-    if (str_ends(filename, ".qcow2"))
-        retval = 1;
-
-    if (str_ends(filename, ".vmdk"))
-        retval = 1;
-
-    if (retval &&
-        (header[OFFS_TYPE] != '0') &&
-        (header[OFFS_TYPE] != 'S')) {
-        retval = 0;
-    }
-
-    dprintf("does filename %s match? %s\n", filename, retval ? "yes" : "no");
-
-    /* make sure we're not using this name again */
-    filename[0] = '\0';
-
-    return retval;
-}
-
-static uint64_t tar2u64(char *ptr)
-{
-    uint64_t retval;
-    char oldend = ptr[12];
-
-    ptr[12] = '\0';
-    if (*ptr & 0x80) {
-        /* XXX we only support files up to 64 bit length */
-        retval = be64_to_cpu(*(uint64_t *)(ptr+4));
-        dprintf("Convert %lx -> %#lx\n", *(uint64_t*)(ptr+4), retval);
-    } else {
-        retval = strtol(ptr, NULL, 8);
-        dprintf("Convert %s -> %#lx\n", ptr, retval);
-    }
-
-    ptr[12] = oldend;
-
-    return retval;
-}
-
-static void tar_sparse(BDRVTarState *s, uint64_t offs, uint64_t len)
-{
-    SparseCache *sparse;
-
-    if (!len)
-        return;
-    if (!(offs - s->last_end)) {
-        s->last_end += len;
-        return;
-    }
-    if (s->last_end > offs)
-        return;
-
-    dprintf("Last chunk until %lx new chunk at %lx\n", s->last_end, offs);
-
-    s->sparse = g_realloc(s->sparse, (s->sparse_num + 1) * sizeof(SparseCache));
-    sparse = &s->sparse[s->sparse_num];
-    sparse->start = s->last_end;
-    sparse->end = offs;
-    s->last_end = offs + len;
-    s->sparse_num++;
-    dprintf("Sparse at %lx end=%lx\n", sparse->start,
-                                       sparse->end);
-}
-
-static QemuOptsList runtime_opts = {
-    .name = "tar",
-    .head = QTAILQ_HEAD_INITIALIZER(runtime_opts.head),
-    .desc = {
-        {
-            .name = "filename",
-            .type = QEMU_OPT_STRING,
-            .help = "URL to the tar file",
-        },
-        { /* end of list */ }
-    },
-};
-
-static int tar_open(BlockDriverState *bs, QDict *options, int flags, Error **errp)
-{
-    BDRVTarState *s = bs->opaque;
-    char header[SECTOR_SIZE];
-    char *real_file = header;
-    char *magic;
-    size_t header_offs = 0;
-    int ret;
-    QemuOpts *opts;
-    Error *local_err = NULL;
-    const char *filename;
-
-    opts = qemu_opts_create_nofail(&runtime_opts);
-    qemu_opts_absorb_qdict(opts, options, &local_err);
-    if (error_is_set(&local_err)) {
-        error_propagate(errp, local_err);
-        ret = -EINVAL;
-        goto fail;
-    }
-
-    filename = qemu_opt_get(opts, "filename");
-
-    if (!strncmp(filename, "tar://", 6))
-        filename += 6;
-    else if (!strncmp(filename, "tar:", 4))
-        filename += 4;
-
-    ret = bdrv_file_open(&s->hd, filename, NULL, flags, &local_err);
-    if (ret < 0) {
-        error_propagate(errp, local_err);
-        qemu_opts_del(opts);
-        return ret;
-    }
-
-    /* Search the file for an image */
-
-    do {
-        /* tar header */
-        if (bdrv_pread(s->hd, header_offs, header, SECTOR_SIZE) != SECTOR_SIZE)
-            goto fail;
-
-        if ((header_offs > 1) && !header[0]) {
-            fprintf(stderr, "Tar: No image file found in archive\n");
-            goto fail;
-        }
-
-        magic = &header[OFFS_MAGIC];
-        if (strncmp(magic, POSIX_TAR_MAGIC, 5)) {
-            fprintf(stderr, "Tar: Invalid magic: %s\n", magic);
-            goto fail;
-        }
-
-        dprintf("file type: %c\n", header[OFFS_TYPE]);
-
-        /* file length*/
-        s->file_len = (tar2u64(&header[OFFS_LENGTH]) + (SECTOR_SIZE - 1)) &
-                      ~(SECTOR_SIZE - 1);
-        s->file_sec = (header_offs / SECTOR_SIZE) + 1;
-
-        header_offs += s->file_len + SECTOR_SIZE;
-
-        if (header[OFFS_TYPE] == 'L') {
-            bdrv_pread(s->hd, header_offs - s->file_len, s->longfile,
-                       sizeof(s->longfile));
-            s->longfile[sizeof(s->longfile)-1] = '\0';
-            real_file = header;
-        } else if (s->longfile[0]) {
-            real_file = s->longfile;
-        } else {
-            real_file = header;
-        }
-    } while(!is_target_file(bs, real_file, header));
-
-    /* We found an image! */
-
-    if (header[OFFS_TYPE] == 'S') {
-        uint8_t isextended;
-        int i;
-
-        for (i = OFFS_S_SP; i < (OFFS_S_SP + (4 * 24)); i += 24)
-            tar_sparse(s, tar2u64(&header[i]), tar2u64(&header[i+12]));
-
-        s->file_len = tar2u64(&header[OFFS_S_LENGTH]);
-        isextended = header[OFFS_S_EXT];
-
-        while (isextended) {
-            if (bdrv_pread(s->hd, s->file_sec * SECTOR_SIZE, header,
-                           SECTOR_SIZE) != SECTOR_SIZE)
-                goto fail;
-
-            for (i = 0; i < (21 * 24); i += 24)
-                tar_sparse(s, tar2u64(&header[i]), tar2u64(&header[i+12]));
-            isextended = header[OFFS_SX_EXT];
-            s->file_sec++;
-        }
-        tar_sparse(s, s->file_len, 1);
-    }
-    qemu_opts_del(opts);
-
-    return 0;
-
-fail:
-    fprintf(stderr, "Tar: Error opening file\n");
-    bdrv_unref(s->hd);
-    qemu_opts_del(opts);
-    return -EINVAL;
-}
-
-typedef struct TarAIOCB {
-    BlockDriverAIOCB common;
-    QEMUBH *bh;
-} TarAIOCB;
-
-/* This callback gets invoked when we have pure sparseness */
-static void tar_sparse_cb(void *opaque)
-{
-    TarAIOCB *acb = (TarAIOCB *)opaque;
-
-    acb->common.cb(acb->common.opaque, 0);
-    qemu_bh_delete(acb->bh);
-    qemu_aio_release(acb);
-}
-
-static void tar_aio_cancel(BlockDriverAIOCB *blockacb)
-{
-}
-
-static AIOCBInfo tar_aiocb_info = {
-    .aiocb_size         = sizeof(TarAIOCB),
-    .cancel             = tar_aio_cancel,
-};
-
-/* This is where we get a request from a caller to read something */
-static BlockDriverAIOCB *tar_aio_readv(BlockDriverState *bs,
-        int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
-        BlockDriverCompletionFunc *cb, void *opaque)
-{
-    BDRVTarState *s = bs->opaque;
-    SparseCache *sparse;
-    int64_t sec_file = sector_num + s->file_sec;
-    int64_t start = sector_num * SECTOR_SIZE;
-    int64_t end = start + (nb_sectors * SECTOR_SIZE);
-    int i;
-    TarAIOCB *acb;
-
-    for (i = 0; i < s->sparse_num; i++) {
-        sparse = &s->sparse[i];
-        if (sparse->start > end) {
-            /* We expect the cache to be start increasing */
-            break;
-        } else if ((sparse->start < start) && (sparse->end <= start)) {
-            /* sparse before our offset */
-            sec_file -= (sparse->end - sparse->start) / SECTOR_SIZE;
-        } else if ((sparse->start <= start) && (sparse->end >= end)) {
-            /* all our sectors are sparse */
-            char *buf = g_malloc0(nb_sectors * SECTOR_SIZE);
-
-            acb = qemu_aio_get(&tar_aiocb_info, bs, cb, opaque);
-            qemu_iovec_from_buf(qiov, 0, buf, nb_sectors * SECTOR_SIZE);
-            g_free(buf);
-            acb->bh = qemu_bh_new(tar_sparse_cb, acb);
-            qemu_bh_schedule(acb->bh);
-
-            return &acb->common;
-        } else if (((sparse->start >= start) && (sparse->start < end)) ||
-                   ((sparse->end >= start) && (sparse->end < end))) {
-            /* we're semi-sparse (worst case) */
-            /* let's go synchronous and read all sectors individually */
-            char *buf = g_malloc(nb_sectors * SECTOR_SIZE);
-            uint64_t offs;
-
-            for (offs = 0; offs < (nb_sectors * SECTOR_SIZE);
-                 offs += SECTOR_SIZE) {
-                bdrv_pread(bs, (sector_num * SECTOR_SIZE) + offs,
-                           buf + offs, SECTOR_SIZE);
-            }
-
-            qemu_iovec_from_buf(qiov, 0, buf, nb_sectors * SECTOR_SIZE);
-            acb = qemu_aio_get(&tar_aiocb_info, bs, cb, opaque);
-            acb->bh = qemu_bh_new(tar_sparse_cb, acb);
-            qemu_bh_schedule(acb->bh);
-
-            return &acb->common;
-        }
-    }
-
-    return bdrv_aio_readv(s->hd, sec_file, qiov, nb_sectors,
-                          cb, opaque);
-}
-
-static void tar_close(BlockDriverState *bs)
-{
-    dprintf("Close\n");
-}
-
-static int64_t tar_getlength(BlockDriverState *bs)
-{
-    BDRVTarState *s = bs->opaque;
-    dprintf("getlength -> %ld\n", s->file_len);
-    return s->file_len;
-}
-
-static BlockDriver bdrv_tar = {
-    .format_name     = "tar",
-    .protocol_name   = "tar",
-
-    .instance_size   = sizeof(BDRVTarState),
-    .bdrv_file_open  = tar_open,
-    .bdrv_close      = tar_close,
-    .bdrv_getlength  = tar_getlength,
-    .bdrv_probe      = tar_probe,
-
-    .bdrv_aio_readv  = tar_aio_readv,
-};
-
-static void tar_block_init(void)
-{
-    bdrv_register(&bdrv_tar);
-}
-
-block_init(tar_block_init);
--- a/block/vmdk.c
+++ b/block/vmdk.c
@@ -1641,13 +1641,11 @@ static int vmdk_create(const char *filename, QEMUOptionParameter *options,
            fmt = options->value.s;
        } else if (!strcmp(options->name, BLOCK_OPT_ZEROED_GRAIN)) {
            zeroed_grain |= options->value.n;
-        } else if (!strcmp(options->name, BLOCK_OPT_SCSI)) {
-            flags |= options->value.n ? BLOCK_FLAG_SCSI: 0;
        }
        options++;
    }
    if (!adapter_type) {
-        adapter_type = flags & BLOCK_FLAG_SCSI ? "lsilogic" : "ide";
+        adapter_type = "ide";
    } else if (strcmp(adapter_type, "ide") &&
               strcmp(adapter_type, "buslogic") &&
               strcmp(adapter_type, "lsilogic") &&
@@ -1928,11 +1926,6 @@ static QEMUOptionParameter vmdk_create_options[] = {
        .type = OPT_FLAG,
        .help = "Enable efficient zero writes using the zeroed-grain GTE feature"
    },
-    {
-        .name = BLOCK_OPT_SCSI,
-        .type = OPT_FLAG,
-        .help = "SCSI image"
-    },
    { NULL }
 };

--- a/blockdev.c
+++ b/blockdev.c
@@ -2021,9 +2021,6 @@ void qmp_drive_mirror(const char *device, const char *target,
    if (!source && sync == MIRROR_SYNC_MODE_TOP) {
        sync = MIRROR_SYNC_MODE_FULL;
    }
-    if (sync == MIRROR_SYNC_MODE_NONE) {
-        source = bs;
-    }

    size = bdrv_getlength(bs);
    if (size < 0) {
--- a/2
+++ b/2
@@ -1320,7 +1320,7 @@ fi

 if test "$pie" = ""; then
  case "$cpu-$targetos" in
-    i386-Linux|x86_64-Linux|x32-Linux|ppc*-Linux|i386-OpenBSD|x86_64-OpenBSD)
+    i386-Linux|x86_64-Linux|x32-Linux|i386-OpenBSD|x86_64-OpenBSD)
      ;;
    *)
      pie="no"
--- a/exec.c
+++ b/exec.c
@@ -927,12 +927,10 @@ static void *file_ram_alloc(RAMBlock *block,
        return NULL;
    }

-#ifndef TARGET_PPC
    if (kvm_enabled() && !kvm_has_sync_mmu()) {
        fprintf(stderr, "host lacks kvm mmu notifiers, -mem-path unsupported\n");
        return NULL;
    }
-#endif

    /* Make name safe to use with mkstemp by replacing '/' with '_'. */
    sanitized_name = g_strdup(block->mr->name);
--- a/fsdev/virtfs-proxy-helper.c
+++ b/fsdev/virtfs-proxy-helper.c
@@ -9,13 +9,6 @@
 * the COPYING file in the top-level directory.
 */

-/* work around a broken sys/capability.h */
-#if defined(__i386__)
-typedef unsigned long long __u64;
-#endif
-#if defined(__powerpc64__)
-#include <asm/types.h>
-#endif
 #include <sys/resource.h>
 #include <getopt.h>
 #include <syslog.h>
--- a/hw/block/xen_blkif.h
+++ b/hw/block/xen_blkif.h
@@ -79,12 +79,6 @@ static inline void blkif_get_x86_32_req(blkif_request_t *dst, blkif_x86_32_reque
 	dst->handle = src->handle;
 	dst->id = src->id;
 	dst->sector_number = src->sector_number;
-	if (src->operation == BLKIF_OP_DISCARD) {
-		struct blkif_request_discard *s = (void *)src;
-		struct blkif_request_discard *d = (void *)dst;
-		d->nr_sectors = s->nr_sectors;
-		return;
-	}
 	if (n > src->nr_segments)
 		n = src->nr_segments;
 	for (i = 0; i < n; i++)
@@ -100,12 +94,6 @@ static inline void blkif_get_x86_64_req(blkif_request_t *dst, blkif_x86_64_reque
 	dst->handle = src->handle;
 	dst->id = src->id;
 	dst->sector_number = src->sector_number;
-	if (src->operation == BLKIF_OP_DISCARD) {
-		struct blkif_request_discard *s = (void *)src;
-		struct blkif_request_discard *d = (void *)dst;
-		d->nr_sectors = s->nr_sectors;
-		return;
-	}
 	if (n > src->nr_segments)
 		n = src->nr_segments;
 	for (i = 0; i < n; i++)
--- a/hw/block/xen_disk.c
+++ b/hw/block/xen_disk.c
@@ -114,7 +114,6 @@ struct XenBlkDev {
    int                 requests_finished;

    /* Persistent grants extension */
-    gboolean            feature_discard;
    gboolean            feature_persistent;
    GTree               *persistent_gnts;
    unsigned int        persistent_gnt_count;
@@ -254,8 +253,6 @@ static int ioreq_parse(struct ioreq *ioreq)
    case BLKIF_OP_WRITE:
        ioreq->prot = PROT_READ; /* from memory */
        break;
-    case BLKIF_OP_DISCARD:
-        return 0;
    default:
        xen_be_printf(&blkdev->xendev, 0, "error: unknown operation (%d)\n",
                      ioreq->req.operation);
@@ -524,17 +521,6 @@ static int ioreq_runio_qemu_aio(struct ioreq *ioreq)
                        &ioreq->v, ioreq->v.size / BLOCK_SIZE,
                        qemu_aio_complete, ioreq);
        break;
-    case BLKIF_OP_DISCARD:
-    {
-        struct blkif_request_discard *discard_req = (void *)&ioreq->req;
-        bdrv_acct_start(blkdev->bs, &ioreq->acct,
-                        discard_req->nr_sectors * BLOCK_SIZE, BDRV_ACCT_WRITE);
-        ioreq->aio_inflight++;
-        bdrv_aio_discard(blkdev->bs,
-                        discard_req->sector_number, discard_req->nr_sectors,
-                        qemu_aio_complete, ioreq);
-        break;
-    }
    default:
        /* unknown operation (shouldn't happen -- parse catches this) */
        goto err;
@@ -713,21 +699,6 @@ static void blk_alloc(struct XenDevice *xendev)
    }
 }

-static void blk_parse_discard(struct XenBlkDev *blkdev)
-{
-    int enable;
-
-    blkdev->feature_discard = true;
-
-    if (xenstore_read_be_int(&blkdev->xendev, "discard-enable", &enable) == 0) {
-        blkdev->feature_discard = !!enable;
-    }
-
-    if (blkdev->feature_discard) {
-        xenstore_write_be_int(&blkdev->xendev, "feature-discard", 1);
-    }
-}
-
 static int blk_init(struct XenDevice *xendev)
 {
    struct XenBlkDev *blkdev = container_of(xendev, struct XenBlkDev, xendev);
@@ -795,8 +766,6 @@ static int blk_init(struct XenDevice *xendev)
    xenstore_write_be_int(&blkdev->xendev, "feature-persistent", 1);
    xenstore_write_be_int(&blkdev->xendev, "info", info);

-    blk_parse_discard(blkdev);
-
    g_free(directiosafe);
    return 0;

@@ -832,9 +801,6 @@ static int blk_connect(struct XenDevice *xendev)
        qflags |= BDRV_O_RDWR;
        readonly = false;
    }
-    if (blkdev->feature_discard) {
-        qflags |= BDRV_O_UNMAP;
-    }

    /* init qemu block driver */
    index = (blkdev->xendev.dev - 202 * 256) / 16;
--- a/hw/scsi/scsi-bus.c
+++ b/hw/scsi/scsi-bus.c
@@ -1293,6 +1293,11 @@ const struct SCSISense sense_code_ILLEGAL_REQ_REMOVAL_PREVENTED = {
    .key = ILLEGAL_REQUEST, .asc = 0x53, .ascq = 0x02
 };

+/* Illegal request, Invalid Transfer Tag */
+const struct SCSISense sense_code_INVALID_TAG = {
+    .key = ILLEGAL_REQUEST, .asc = 0x4b, .ascq = 0x01
+};
+
 /* Command aborted, I/O process terminated */
 const struct SCSISense sense_code_IO_ERROR = {
    .key = ABORTED_COMMAND, .asc = 0x00, .ascq = 0x06
@@ -1308,6 +1313,11 @@ const struct SCSISense sense_code_LUN_FAILURE = {
    .key = ABORTED_COMMAND, .asc = 0x3e, .ascq = 0x01
 };

+/* Command aborted, Overlapped Commands Attempted */
+const struct SCSISense sense_code_OVERLAPPED_COMMANDS = {
+    .key = ABORTED_COMMAND, .asc = 0x4e, .ascq = 0x00
+};
+
 /* Unit attention, Capacity data has changed */
 const struct SCSISense sense_code_CAPACITY_CHANGED = {
    .key = UNIT_ATTENTION, .asc = 0x2a, .ascq = 0x09
--- a/hw/usb/bus.c
+++ b/hw/usb/bus.c
@@ -203,6 +203,24 @@ void usb_device_ep_stopped(USBDevice *dev, USBEndpoint *ep)
    }
 }

+int usb_device_alloc_streams(USBDevice *dev, USBEndpoint **eps, int nr_eps,
+                             int streams)
+{
+    USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
+    if (klass->alloc_streams) {
+        return klass->alloc_streams(dev, eps, nr_eps, streams);
+    }
+    return 0;
+}
+
+void usb_device_free_streams(USBDevice *dev, USBEndpoint **eps, int nr_eps)
+{
+    USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
+    if (klass->free_streams) {
+        klass->free_streams(dev, eps, nr_eps);
+    }
+}
+
 static int usb_qdev_init(DeviceState *qdev)
 {
    USBDevice *dev = USB_DEVICE(qdev);
--- a/hw/usb/core.c
+++ b/hw/usb/core.c
@@ -623,6 +623,7 @@ void usb_ep_reset(USBDevice *dev)
    dev->ep_ctl.type = USB_ENDPOINT_XFER_CONTROL;
    dev->ep_ctl.ifnum = 0;
    dev->ep_ctl.max_packet_size = 64;
+    dev->ep_ctl.max_streams = 0;
    dev->ep_ctl.dev = dev;
    dev->ep_ctl.pipeline = false;
    for (ep = 0; ep < USB_MAX_ENDPOINTS; ep++) {
@@ -636,6 +637,8 @@ void usb_ep_reset(USBDevice *dev)
        dev->ep_out[ep].ifnum = USB_INTERFACE_INVALID;
        dev->ep_in[ep].max_packet_size = 0;
        dev->ep_out[ep].max_packet_size = 0;
+        dev->ep_in[ep].max_streams = 0;
+        dev->ep_out[ep].max_streams = 0;
        dev->ep_in[ep].dev = dev;
        dev->ep_out[ep].dev = dev;
        dev->ep_in[ep].pipeline = false;
@@ -764,6 +767,25 @@ int usb_ep_get_max_packet_size(USBDevice *dev, int pid, int ep)
    return uep->max_packet_size;
 }

+void usb_ep_set_max_streams(USBDevice *dev, int pid, int ep, uint8_t raw)
+{
+    struct USBEndpoint *uep = usb_ep_get(dev, pid, ep);
+    int MaxStreams;
+
+    MaxStreams = raw & 0x1f;
+    if (MaxStreams) {
+        uep->max_streams = 1 << MaxStreams;
+    } else {
+        uep->max_streams = 0;
+    }
+}
+
+int usb_ep_get_max_streams(USBDevice *dev, int pid, int ep)
+{
+    struct USBEndpoint *uep = usb_ep_get(dev, pid, ep);
+    return uep->max_streams;
+}
+
 void usb_ep_set_pipeline(USBDevice *dev, int pid, int ep, bool enabled)
 {
    struct USBEndpoint *uep = usb_ep_get(dev, pid, ep);
--- a/hw/usb/desc.c
+++ b/hw/usb/desc.c
@@ -6,16 +6,6 @@

 /* ------------------------------------------------------------------ */

-static uint8_t usb_lo(uint16_t val)
-{
-    return val & 0xff;
-}
-
-static uint8_t usb_hi(uint16_t val)
-{
-    return (val >> 8) & 0xff;
-}
-
 int usb_desc_device(const USBDescID *id, const USBDescDevice *dev,
                    uint8_t *dest, size_t len)
 {
@@ -385,6 +375,8 @@ static void usb_desc_ep_init(USBDevice *dev)
            usb_ep_set_ifnum(dev, pid, ep, iface->bInterfaceNumber);
            usb_ep_set_max_packet_size(dev, pid, ep,
                                       iface->eps[e].wMaxPacketSize);
+            usb_ep_set_max_streams(dev, pid, ep,
+                                   iface->eps[e].bmAttributes_super);
        }
    }
 }
--- a/hw/usb/desc.h
+++ b/hw/usb/desc.h
@@ -194,6 +194,17 @@ struct USBDesc {

 #define USB_DESC_FLAG_SUPER (1 << 1)

+/* little helpers */
+static inline uint8_t usb_lo(uint16_t val)
+{
+    return val & 0xff;
+}
+
+static inline uint8_t usb_hi(uint16_t val)
+{
+    return (val >> 8) & 0xff;
+}
+
 /* generate usb packages from structs */
 int usb_desc_device(const USBDescID *id, const USBDescDevice *dev,
                    uint8_t *dest, size_t len);
--- a/hw/usb/dev-hid.c
+++ b/hw/usb/dev-hid.c
@@ -236,7 +236,7 @@ static const USBDescDevice desc_device_tablet2 = {
            .bNumInterfaces        = 1,
            .bConfigurationValue   = 1,
            .iConfiguration        = STR_CONFIG_TABLET,
-            .bmAttributes          = 0x80,
+            .bmAttributes          = 0xa0,
            .bMaxPower             = 50,
            .nif = 1,
            .ifs = &desc_iface_tablet2,
--- a/hw/usb/dev-uas.c
+++ b/hw/usb/dev-uas.c
@@ -55,7 +55,7 @@ typedef struct {
    uint8_t    id;
    uint8_t    reserved;
    uint16_t   tag;
-} QEMU_PACKED  uas_ui_header;
+} QEMU_PACKED  uas_iu_header;

 typedef struct {
    uint8_t    prio_taskattr;   /* 6:3 priority, 2:0 task attribute   */
@@ -65,7 +65,7 @@ typedef struct {
    uint64_t   lun;
    uint8_t    cdb[16];
    uint8_t    add_cdb[];
-} QEMU_PACKED  uas_ui_command;
+} QEMU_PACKED  uas_iu_command;

 typedef struct {
    uint16_t   status_qualifier;
@@ -73,29 +73,29 @@ typedef struct {
    uint8_t    reserved[7];
    uint16_t   sense_length;
    uint8_t    sense_data[18];
-} QEMU_PACKED  uas_ui_sense;
+} QEMU_PACKED  uas_iu_sense;

 typedef struct {
-    uint16_t   add_response_info;
+    uint8_t    add_response_info[3];
    uint8_t    response_code;
-} QEMU_PACKED  uas_ui_response;
+} QEMU_PACKED  uas_iu_response;

 typedef struct {
    uint8_t    function;
    uint8_t    reserved;
    uint16_t   task_tag;
    uint64_t   lun;
-} QEMU_PACKED  uas_ui_task_mgmt;
+} QEMU_PACKED  uas_iu_task_mgmt;

 typedef struct {
-    uas_ui_header  hdr;
+    uas_iu_header  hdr;
    union {
-        uas_ui_command   command;
-        uas_ui_sense     sense;
-        uas_ui_task_mgmt task;
-        uas_ui_response  response;
+        uas_iu_command   command;
+        uas_iu_sense     sense;
+        uas_iu_task_mgmt task;
+        uas_iu_response  response;
    };
-} QEMU_PACKED  uas_ui;
+} QEMU_PACKED  uas_iu;

 /* --------------------------------------------------------------------- */

@@ -122,8 +122,8 @@ struct UASDevice {
    UASRequest                *dataout2;

    /* usb 3.0 only */
-    USBPacket                 *data3[UAS_MAX_STREAMS];
-    USBPacket                 *status3[UAS_MAX_STREAMS];
+    USBPacket                 *data3[UAS_MAX_STREAMS + 1];
+    USBPacket                 *status3[UAS_MAX_STREAMS + 1];
 };

 struct UASRequest {
@@ -145,7 +145,7 @@ struct UASRequest {

 struct UASStatus {
    uint32_t                  stream;
-    uas_ui                    status;
+    uas_iu                    status;
    uint32_t                  length;
    QTAILQ_ENTRY(UASStatus)   next;
 };
@@ -338,7 +338,7 @@ static UASStatus *usb_uas_alloc_status(UASDevice *uas, uint8_t id, uint16_t tag)

    st->status.hdr.id = id;
    st->status.hdr.tag = cpu_to_be16(tag);
-    st->length = sizeof(uas_ui_header);
+    st->length = sizeof(uas_iu_header);
    if (uas_using_streams(uas)) {
        st->stream = tag;
    }
@@ -392,15 +392,13 @@ static void usb_uas_queue_status(UASDevice *uas, UASStatus *st, int length)
    }
 }

-static void usb_uas_queue_response(UASDevice *uas, uint16_t tag,
-                                   uint8_t code, uint16_t add_info)
+static void usb_uas_queue_response(UASDevice *uas, uint16_t tag, uint8_t code)
 {
    UASStatus *st = usb_uas_alloc_status(uas, UAS_UI_RESPONSE, tag);

    trace_usb_uas_response(uas->dev.addr, tag, code);
    st->status.response.response_code = code;
-    st->status.response.add_response_info = cpu_to_be16(add_info);
-    usb_uas_queue_status(uas, st, sizeof(uas_ui_response));
+    usb_uas_queue_status(uas, st, sizeof(uas_iu_response));
 }

 static void usb_uas_queue_sense(UASRequest *req, uint8_t status)
@@ -416,10 +414,28 @@ static void usb_uas_queue_sense(UASRequest *req, uint8_t status)
                                  sizeof(st->status.sense.sense_data));
        st->status.sense.sense_length = cpu_to_be16(slen);
    }
-    len = sizeof(uas_ui_sense) - sizeof(st->status.sense.sense_data) + slen;
+    len = sizeof(uas_iu_sense) - sizeof(st->status.sense.sense_data) + slen;
    usb_uas_queue_status(req->uas, st, len);
 }

+static void usb_uas_queue_fake_sense(UASDevice *uas, uint16_t tag,
+                                     struct SCSISense sense)
+{
+    UASStatus *st = usb_uas_alloc_status(uas, UAS_UI_SENSE, tag);
+    int len, slen = 0;
+
+    st->status.sense.status = CHECK_CONDITION;
+    st->status.sense.status_qualifier = cpu_to_be16(0);
+    st->status.sense.sense_data[0] = 0x70;
+    st->status.sense.sense_data[2] = sense.key;
+    st->status.sense.sense_data[7] = 10;
+    st->status.sense.sense_data[12] = sense.asc;
+    st->status.sense.sense_data[13] = sense.ascq;
+    slen = 18;
+    len = sizeof(uas_iu_sense) - sizeof(st->status.sense.sense_data) + slen;
+    usb_uas_queue_status(uas, st, len);
+}
+
 static void usb_uas_queue_read_ready(UASRequest *req)
 {
    UASStatus *st = usb_uas_alloc_status(req->uas, UAS_UI_READ_READY,
@@ -518,14 +534,14 @@ static void usb_uas_start_next_transfer(UASDevice *uas)
    }
 }

-static UASRequest *usb_uas_alloc_request(UASDevice *uas, uas_ui *ui)
+static UASRequest *usb_uas_alloc_request(UASDevice *uas, uas_iu *iu)
 {
    UASRequest *req;

    req = g_new0(UASRequest, 1);
    req->uas = uas;
-    req->tag = be16_to_cpu(ui->hdr.tag);
-    req->lun = be64_to_cpu(ui->command.lun);
+    req->tag = be16_to_cpu(iu->hdr.tag);
+    req->lun = be64_to_cpu(iu->command.lun);
    req->dev = usb_uas_get_dev(req->uas, req->lun);
    return req;
 }
@@ -648,7 +664,7 @@ static void usb_uas_cancel_io(USBDevice *dev, USBPacket *p)
        return;
    }
    if (uas_using_streams(uas)) {
-        for (i = 0; i < UAS_MAX_STREAMS; i++) {
+        for (i = 0; i <= UAS_MAX_STREAMS; i++) {
            if (uas->status3[i] == p) {
                uas->status3[i] = NULL;
                return;
@@ -668,16 +684,20 @@ static void usb_uas_cancel_io(USBDevice *dev, USBPacket *p)
    assert(!"canceled usb packet not found");
 }

-static void usb_uas_command(UASDevice *uas, uas_ui *ui)
+static void usb_uas_command(UASDevice *uas, uas_iu *iu)
 {
    UASRequest *req;
    uint32_t len;
+    uint16_t tag = be16_to_cpu(iu->hdr.tag);

-    req = usb_uas_find_request(uas, be16_to_cpu(ui->hdr.tag));
+    if (uas_using_streams(uas) && tag > UAS_MAX_STREAMS) {
+        goto invalid_tag;
+    }
+    req = usb_uas_find_request(uas, tag);
    if (req) {
        goto overlapped_tag;
    }
-    req = usb_uas_alloc_request(uas, ui);
+    req = usb_uas_alloc_request(uas, iu);
    if (req->dev == NULL) {
        goto bad_target;
    }
@@ -694,7 +714,7 @@ static void usb_uas_command(UASDevice *uas, uas_ui *ui)

    req->req = scsi_req_new(req->dev, req->tag,
                            usb_uas_get_lun(req->lun),
-                            ui->command.cdb, req);
+                            iu->command.cdb, req);
    if (uas->requestlog) {
        scsi_req_print(req->req);
    }
@@ -705,105 +725,97 @@ static void usb_uas_command(UASDevice *uas, uas_ui *ui)
    }
    return;

+invalid_tag:
+    usb_uas_queue_fake_sense(uas, tag, sense_code_INVALID_TAG);
+    return;
+
 overlapped_tag:
-    usb_uas_queue_response(uas, req->tag, UAS_RC_OVERLAPPED_TAG, 0);
+    usb_uas_queue_fake_sense(uas, tag, sense_code_OVERLAPPED_COMMANDS);
    return;

 bad_target:
-    /*
-     * FIXME: Seems to upset linux, is this wrong?
-     * NOTE: Happens only with no scsi devices at the bus, not sure
-     *       this is a valid UAS setup in the first place.
-     */
-    usb_uas_queue_response(uas, req->tag, UAS_RC_INVALID_INFO_UNIT, 0);
+    usb_uas_queue_fake_sense(uas, tag, sense_code_LUN_NOT_SUPPORTED);
    g_free(req);
 }

-static void usb_uas_task(UASDevice *uas, uas_ui *ui)
+static void usb_uas_task(UASDevice *uas, uas_iu *iu)
 {
-    uint16_t tag = be16_to_cpu(ui->hdr.tag);
-    uint64_t lun64 = be64_to_cpu(ui->task.lun);
+    uint16_t tag = be16_to_cpu(iu->hdr.tag);
+    uint64_t lun64 = be64_to_cpu(iu->task.lun);
    SCSIDevice *dev = usb_uas_get_dev(uas, lun64);
    int lun = usb_uas_get_lun(lun64);
    UASRequest *req;
    uint16_t task_tag;

-    req = usb_uas_find_request(uas, be16_to_cpu(ui->hdr.tag));
+    if (uas_using_streams(uas) && tag > UAS_MAX_STREAMS) {
+        goto invalid_tag;
+    }
+    req = usb_uas_find_request(uas, be16_to_cpu(iu->hdr.tag));
    if (req) {
        goto overlapped_tag;
    }
+    if (dev == NULL) {
+        goto incorrect_lun;
+    }

-    switch (ui->task.function) {
+    switch (iu->task.function) {
    case UAS_TMF_ABORT_TASK:
-        task_tag = be16_to_cpu(ui->task.task_tag);
+        task_tag = be16_to_cpu(iu->task.task_tag);
        trace_usb_uas_tmf_abort_task(uas->dev.addr, tag, task_tag);
-        if (dev == NULL) {
-            goto bad_target;
-        }
-        if (dev->lun != lun) {
-            goto incorrect_lun;
-        }
        req = usb_uas_find_request(uas, task_tag);
        if (req && req->dev == dev) {
            scsi_req_cancel(req->req);
        }
-        usb_uas_queue_response(uas, tag, UAS_RC_TMF_COMPLETE, 0);
+        usb_uas_queue_response(uas, tag, UAS_RC_TMF_COMPLETE);
        break;

    case UAS_TMF_LOGICAL_UNIT_RESET:
        trace_usb_uas_tmf_logical_unit_reset(uas->dev.addr, tag, lun);
-        if (dev == NULL) {
-            goto bad_target;
-        }
-        if (dev->lun != lun) {
-            goto incorrect_lun;
-        }
        qdev_reset_all(&dev->qdev);
-        usb_uas_queue_response(uas, tag, UAS_RC_TMF_COMPLETE, 0);
+        usb_uas_queue_response(uas, tag, UAS_RC_TMF_COMPLETE);
        break;

    default:
-        trace_usb_uas_tmf_unsupported(uas->dev.addr, tag, ui->task.function);
-        usb_uas_queue_response(uas, tag, UAS_RC_TMF_NOT_SUPPORTED, 0);
+        trace_usb_uas_tmf_unsupported(uas->dev.addr, tag, iu->task.function);
+        usb_uas_queue_response(uas, tag, UAS_RC_TMF_NOT_SUPPORTED);
        break;
    }
    return;

-overlapped_tag:
-    usb_uas_queue_response(uas, req->tag, UAS_RC_OVERLAPPED_TAG, 0);
+invalid_tag:
+    usb_uas_queue_response(uas, tag, UAS_RC_INVALID_INFO_UNIT);
    return;

-bad_target:
-    /* FIXME: correct?  [see long comment in usb_uas_command()] */
-    usb_uas_queue_response(uas, tag, UAS_RC_INVALID_INFO_UNIT, 0);
+overlapped_tag:
+    usb_uas_queue_response(uas, req->tag, UAS_RC_OVERLAPPED_TAG);
    return;

 incorrect_lun:
-    usb_uas_queue_response(uas, tag, UAS_RC_INCORRECT_LUN, 0);
+    usb_uas_queue_response(uas, tag, UAS_RC_INCORRECT_LUN);
 }

 static void usb_uas_handle_data(USBDevice *dev, USBPacket *p)
 {
    UASDevice *uas = DO_UPCAST(UASDevice, dev, dev);
-    uas_ui ui;
+    uas_iu iu;
    UASStatus *st;
    UASRequest *req;
    int length;

    switch (p->ep->nr) {
    case UAS_PIPE_ID_COMMAND:
-        length = MIN(sizeof(ui), p->iov.size);
-        usb_packet_copy(p, &ui, length);
-        switch (ui.hdr.id) {
+        length = MIN(sizeof(iu), p->iov.size);
+        usb_packet_copy(p, &iu, length);
+        switch (iu.hdr.id) {
        case UAS_UI_COMMAND:
-            usb_uas_command(uas, &ui);
+            usb_uas_command(uas, &iu);
            break;
        case UAS_UI_TASK_MGMT:
-            usb_uas_task(uas, &ui);
+            usb_uas_task(uas, &iu);
            break;
        default:
-            fprintf(stderr, "%s: unknown command ui: id 0x%x\n",
-                    __func__, ui.hdr.id);
+            fprintf(stderr, "%s: unknown command iu: id 0x%x\n",
+                    __func__, iu.hdr.id);
            p->status = USB_RET_STALL;
            break;
        }
--- a/hw/usb/hcd-ehci.c
+++ b/hw/usb/hcd-ehci.c
@@ -826,9 +826,9 @@ static void ehci_child_detach(USBPort *port, USBDevice *child)
 static void ehci_wakeup(USBPort *port)
 {
    EHCIState *s = port->opaque;
-    uint32_t portsc = s->portsc[port->index];
+    uint32_t *portsc = &s->portsc[port->index];

-    if (portsc & PORTSC_POWNER) {
+    if (*portsc & PORTSC_POWNER) {
        USBPort *companion = s->companion_ports[port->index];
        if (companion->ops->wakeup) {
            companion->ops->wakeup(companion);
@@ -836,6 +836,12 @@ static void ehci_wakeup(USBPort *port)
        return;
    }

+    if (*portsc & PORTSC_SUSPEND) {
+        trace_usb_ehci_port_wakeup(port->index);
+        *portsc |= PORTSC_FPRES;
+        ehci_raise_irq(s, USBSTS_PCD);
+    }
+
    qemu_bh_schedule(s->async_bh);
 }

@@ -1067,6 +1073,14 @@ static void ehci_port_write(void *ptr, hwaddr addr,
        }
    }

+    if ((val & PORTSC_SUSPEND) && !(*portsc & PORTSC_SUSPEND)) {
+        trace_usb_ehci_port_suspend(port);
+    }
+    if (!(val & PORTSC_FPRES) && (*portsc & PORTSC_FPRES)) {
+        trace_usb_ehci_port_resume(port);
+        val &= ~PORTSC_SUSPEND;
+    }
+
    *portsc &= ~PORTSC_RO_MASK;
    *portsc |= val;
    trace_usb_ehci_portsc_change(addr + s->portscbase, addr >> 2, *portsc, old);
--- a/hw/usb/hcd-xhci.c
+++ b/hw/usb/hcd-xhci.c
@@ -1150,6 +1150,111 @@ static void xhci_free_streams(XHCIEPContext *epctx)
    epctx->nr_pstreams = 0;
 }

+static int xhci_epmask_to_eps_with_streams(XHCIState *xhci,
+                                           unsigned int slotid,
+                                           uint32_t epmask,
+                                           XHCIEPContext **epctxs,
+                                           USBEndpoint **eps)
+{
+    XHCISlot *slot;
+    XHCIEPContext *epctx;
+    USBEndpoint *ep;
+    int i, j;
+
+    assert(slotid >= 1 && slotid <= xhci->numslots);
+
+    slot = &xhci->slots[slotid - 1];
+
+    for (i = 2, j = 0; i <= 31; i++) {
+        if (!(epmask & (1 << i))) {
+            continue;
+        }
+
+        epctx = slot->eps[i - 1];
+        ep = xhci_epid_to_usbep(xhci, slotid, i);
+        if (!epctx || !epctx->nr_pstreams || !ep) {
+            continue;
+        }
+
+        if (epctxs) {
+            epctxs[j] = epctx;
+        }
+        eps[j++] = ep;
+    }
+    return j;
+}
+
+static void xhci_free_device_streams(XHCIState *xhci, unsigned int slotid,
+                                     uint32_t epmask)
+{
+    USBEndpoint *eps[30];
+    int nr_eps;
+
+    nr_eps = xhci_epmask_to_eps_with_streams(xhci, slotid, epmask, NULL, eps);
+    if (nr_eps) {
+        usb_device_free_streams(eps[0]->dev, eps, nr_eps);
+    }
+}
+
+static TRBCCode xhci_alloc_device_streams(XHCIState *xhci, unsigned int slotid,
+                                          uint32_t epmask)
+{
+    XHCIEPContext *epctxs[30];
+    USBEndpoint *eps[30];
+    int i, r, nr_eps, req_nr_streams, dev_max_streams;
+
+    nr_eps = xhci_epmask_to_eps_with_streams(xhci, slotid, epmask, epctxs,
+                                             eps);
+    if (nr_eps == 0) {
+        return CC_SUCCESS;
+    }
+
+    req_nr_streams = epctxs[0]->nr_pstreams;
+    dev_max_streams = eps[0]->max_streams;
+
+    for (i = 1; i < nr_eps; i++) {
+        /*
+         * HdG: I don't expect these to ever trigger, but if they do we need
+         * to come up with another solution, ie group identical endpoints
+         * together and make an usb_device_alloc_streams call per group.
+         */
+        if (epctxs[i]->nr_pstreams != req_nr_streams) {
+            FIXME("guest streams config not identical for all eps");
+            return CC_RESOURCE_ERROR;
+        }
+        if (eps[i]->max_streams != dev_max_streams) {
+            FIXME("device streams config not identical for all eps");
+            return CC_RESOURCE_ERROR;
+        }
+    }
+
+    /*
+     * max-streams in both the device descriptor and in the controller is a
+     * power of 2. But stream id 0 is reserved, so if a device can do up to 4
+     * streams the guest will ask for 5 rounded up to the next power of 2 which
+     * becomes 8. For emulated devices usb_device_alloc_streams is a nop.
+     *
+     * For redirected devices however this is an issue, as there we must ask
+     * the real xhci controller to alloc streams, and the host driver for the
+     * real xhci controller will likely disallow allocating more streams then
+     * the device can handle.
+     *
+     * So we limit the requested nr_streams to the maximum number the device
+     * can handle.
+     */
+    if (req_nr_streams > dev_max_streams) {
+        req_nr_streams = dev_max_streams;
+    }
+
+    r = usb_device_alloc_streams(eps[0]->dev, eps, nr_eps, req_nr_streams);
+    if (r != 0) {
+        fprintf(stderr, "xhci: alloc streams failed\n");
+        return CC_RESOURCE_ERROR;
+    }
+
+    return CC_SUCCESS;
+}
+
 static XHCIStreamContext *xhci_find_stream(XHCIEPContext *epctx,
                                           unsigned int streamid,
                                           uint32_t *cc_error)
@@ -1495,7 +1600,8 @@ static TRBCCode xhci_reset_ep(XHCIState *xhci, unsigned int slotid,
    }

    if (!xhci->slots[slotid-1].uport ||
-        !xhci->slots[slotid-1].uport->dev) {
+        !xhci->slots[slotid-1].uport->dev ||
+        !xhci->slots[slotid-1].uport->dev->attached) {
        return CC_USB_TRANSACTION_ERROR;
    }

@@ -1982,6 +2088,14 @@ static void xhci_kick_ep(XHCIState *xhci, unsigned int slotid,
        return;
    }

+    /* If the device has been detached, but the guest has not noticed this
+       yet the 2 above checks will succeed, but we must NOT continue */
+    if (!xhci->slots[slotid - 1].uport ||
+        !xhci->slots[slotid - 1].uport->dev ||
+        !xhci->slots[slotid - 1].uport->dev->attached) {
+        return;
+    }
+
    if (epctx->retry) {
        XHCITransfer *xfer = epctx->retry;

@@ -2206,7 +2320,7 @@ static TRBCCode xhci_address_slot(XHCIState *xhci, unsigned int slotid,
    trace_usb_xhci_slot_address(slotid, uport->path);

    dev = uport->dev;
-    if (!dev) {
+    if (!dev || !dev->attached) {
        fprintf(stderr, "xhci: port %s not connected\n", uport->path);
        return CC_USB_TRANSACTION_ERROR;
    }
@@ -2313,6 +2427,8 @@ static TRBCCode xhci_configure_slot(XHCIState *xhci, unsigned int slotid,
        return CC_CONTEXT_STATE_ERROR;
    }

+    xhci_free_device_streams(xhci, slotid, ictl_ctx[0] | ictl_ctx[1]);
+
    for (i = 2; i <= 31; i++) {
        if (ictl_ctx[0] & (1<<i)) {
            xhci_disable_ep(xhci, slotid, i);
@@ -2334,6 +2450,16 @@ static TRBCCode xhci_configure_slot(XHCIState *xhci, unsigned int slotid,
        }
    }

+    res = xhci_alloc_device_streams(xhci, slotid, ictl_ctx[1]);
+    if (res != CC_SUCCESS) {
+        for (i = 2; i <= 31; i++) {
+            if (ictl_ctx[1] & (1 << i)) {
+                xhci_disable_ep(xhci, slotid, i);
+            }
+        }
+        return res;
+    }
+
    slot_ctx[3] &= ~(SLOT_STATE_MASK << SLOT_STATE_SHIFT);
    slot_ctx[3] |= SLOT_CONFIGURED << SLOT_STATE_SHIFT;
    slot_ctx[0] &= ~(SLOT_CONTEXT_ENTRIES_MASK << SLOT_CONTEXT_ENTRIES_SHIFT);
@@ -3016,6 +3142,14 @@ static void xhci_oper_write(void *ptr, hwaddr reg,
        } else if (!(val & USBCMD_RS) && (xhci->usbcmd & USBCMD_RS)) {
            xhci_stop(xhci);
        }
+        if (val & USBCMD_CSS) {
+            /* save state */
+            xhci->usbsts &= ~USBSTS_SRE;
+        }
+        if (val & USBCMD_CRS) {
+            /* restore state */
+            xhci->usbsts |= USBSTS_SRE;
+        }
        xhci->usbcmd = val & 0xc0f;
        xhci_mfwrap_update(xhci);
        if (val & USBCMD_HCRST) {
--- a/include/block/block_int.h
+++ b/include/block/block_int.h
@@ -40,12 +40,10 @@
 #define BLOCK_FLAG_ENCRYPT          1
 #define BLOCK_FLAG_COMPAT6          4
 #define BLOCK_FLAG_LAZY_REFCOUNTS   8
-#define BLOCK_FLAG_SCSI             16

 #define BLOCK_OPT_SIZE              "size"
 #define BLOCK_OPT_ENCRYPT           "encryption"
 #define BLOCK_OPT_COMPAT6           "compat6"
-#define BLOCK_OPT_SCSI              "scsi"
 #define BLOCK_OPT_BACKING_FILE      "backing_file"
 #define BLOCK_OPT_BACKING_FMT       "backing_fmt"
 #define BLOCK_OPT_CLUSTER_SIZE      "cluster_size"
--- a/include/exec/spinlock.h
+++ b/include/exec/spinlock.h
@@ -24,12 +24,6 @@
 #include <pthread.h>
 #define spin_lock pthread_mutex_lock
 #define spin_unlock pthread_mutex_unlock
-static inline void spin_unlock_safe(pthread_mutex_t *lock)
-{
-    /* unlocking an unlocked mutex results in undefined behavior */
-    pthread_mutex_trylock(lock);
-    pthread_mutex_unlock(lock);
-}
 #define spinlock_t pthread_mutex_t
 #define SPIN_LOCK_UNLOCKED PTHREAD_MUTEX_INITIALIZER

@@ -52,8 +46,4 @@ static inline void spin_unlock(spinlock_t *lock)
 {
 }

-static inline void spin_unlock_safe(spinlock_t *lock)
-{
-}
-
 #endif
--- a/include/exec/user/thunk.h
+++ b/include/exec/user/thunk.h
@@ -38,7 +38,6 @@ typedef enum argtype {
    TYPE_ARRAY,
    TYPE_STRUCT,
    TYPE_OLDDEVT,
-    TYPE_INTBITFIELD,
 } argtype;

 #define MK_PTR(type) TYPE_PTR, type
@@ -92,7 +91,6 @@ static inline int thunk_type_size(const argtype *type_ptr, int is_host)
    case TYPE_SHORT:
        return 2;
    case TYPE_INT:
-    case TYPE_INTBITFIELD:
        return 4;
    case TYPE_LONGLONG:
    case TYPE_ULONGLONG:
@@ -155,7 +153,6 @@ static inline int thunk_type_align(const argtype *type_ptr, int is_host)
    case TYPE_SHORT:
        return 2;
    case TYPE_INT:
-    case TYPE_INTBITFIELD:
        return 4;
    case TYPE_LONGLONG:
    case TYPE_ULONGLONG:
--- a/include/hw/scsi/scsi.h
+++ b/include/hw/scsi/scsi.h
@@ -199,12 +199,16 @@ extern const struct SCSISense sense_code_SAVING_PARAMS_NOT_SUPPORTED;
 extern const struct SCSISense sense_code_INCOMPATIBLE_FORMAT;
 /* Illegal request, medium removal prevented */
 extern const struct SCSISense sense_code_ILLEGAL_REQ_REMOVAL_PREVENTED;
+/* Illegal request, Invalid Transfer Tag */
+extern const struct SCSISense sense_code_INVALID_TAG;
 /* Command aborted, I/O process terminated */
 extern const struct SCSISense sense_code_IO_ERROR;
 /* Command aborted, I_T Nexus loss occurred */
 extern const struct SCSISense sense_code_I_T_NEXUS_LOSS;
 /* Command aborted, Logical Unit failure */
 extern const struct SCSISense sense_code_LUN_FAILURE;
+/* Command aborted, Overlapped Commands Attempted */
+extern const struct SCSISense sense_code_OVERLAPPED_COMMANDS;
 /* LUN not ready, Capacity data has changed */
 extern const struct SCSISense sense_code_CAPACITY_CHANGED;
 /* LUN not ready, Medium not present */
--- a/include/hw/usb.h
+++ b/include/hw/usb.h
@@ -102,17 +102,26 @@

 #define DeviceRequest ((USB_DIR_IN|USB_TYPE_STANDARD|USB_RECIP_DEVICE)<<8)
 #define DeviceOutRequest ((USB_DIR_OUT|USB_TYPE_STANDARD|USB_RECIP_DEVICE)<<8)
-#define InterfaceRequest \
+#define VendorDeviceRequest ((USB_DIR_IN|USB_TYPE_VENDOR|USB_RECIP_DEVICE)<<8)
+#define VendorDeviceOutRequest \
+        ((USB_DIR_OUT|USB_TYPE_VENDOR|USB_RECIP_DEVICE)<<8)
+
+#define InterfaceRequest                                        \
        ((USB_DIR_IN|USB_TYPE_STANDARD|USB_RECIP_INTERFACE)<<8)
 #define InterfaceOutRequest \
        ((USB_DIR_OUT|USB_TYPE_STANDARD|USB_RECIP_INTERFACE)<<8)
-#define EndpointRequest ((USB_DIR_IN|USB_TYPE_STANDARD|USB_RECIP_ENDPOINT)<<8)
-#define EndpointOutRequest \
-        ((USB_DIR_OUT|USB_TYPE_STANDARD|USB_RECIP_ENDPOINT)<<8)
 #define ClassInterfaceRequest \
        ((USB_DIR_IN|USB_TYPE_CLASS|USB_RECIP_INTERFACE)<<8)
 #define ClassInterfaceOutRequest \
        ((USB_DIR_OUT|USB_TYPE_CLASS|USB_RECIP_INTERFACE)<<8)
+#define VendorInterfaceRequest \
+        ((USB_DIR_IN|USB_TYPE_VENDOR|USB_RECIP_INTERFACE)<<8)
+#define VendorInterfaceOutRequest \
+        ((USB_DIR_OUT|USB_TYPE_VENDOR|USB_RECIP_INTERFACE)<<8)
+
+#define EndpointRequest ((USB_DIR_IN|USB_TYPE_STANDARD|USB_RECIP_ENDPOINT)<<8)
+#define EndpointOutRequest \
+        ((USB_DIR_OUT|USB_TYPE_STANDARD|USB_RECIP_ENDPOINT)<<8)

 #define USB_REQ_GET_STATUS		0x00
 #define USB_REQ_CLEAR_FEATURE		0x01
@@ -189,6 +198,7 @@ struct USBEndpoint {
    uint8_t type;
    uint8_t ifnum;
    int max_packet_size;
+    int max_streams;
    bool pipeline;
    bool halted;
    USBDevice *dev;
@@ -314,6 +324,14 @@ typedef struct USBDeviceClass {
     */
    void (*ep_stopped)(USBDevice *dev, USBEndpoint *ep);

+    /*
+     * Called by the hcd to alloc / free streams on a bulk endpoint.
+     * Optional may be NULL.
+     */
+    int (*alloc_streams)(USBDevice *dev, USBEndpoint **eps, int nr_eps,
+                         int streams);
+    void (*free_streams)(USBDevice *dev, USBEndpoint **eps, int nr_eps);
+
    const char *product_desc;
    const USBDesc *usb_desc;
 } USBDeviceClass;
@@ -421,6 +439,8 @@ void usb_ep_set_ifnum(USBDevice *dev, int pid, int ep, uint8_t ifnum);
 void usb_ep_set_max_packet_size(USBDevice *dev, int pid, int ep,
                                uint16_t raw);
 int usb_ep_get_max_packet_size(USBDevice *dev, int pid, int ep);
+void usb_ep_set_max_streams(USBDevice *dev, int pid, int ep, uint8_t raw);
+int usb_ep_get_max_streams(USBDevice *dev, int pid, int ep);
 void usb_ep_set_pipeline(USBDevice *dev, int pid, int ep, bool enabled);
 void usb_ep_set_halted(USBDevice *dev, int pid, int ep, bool halted);
 USBPacket *usb_ep_find_packet_by_id(USBDevice *dev, int pid, int ep,
@@ -550,6 +570,10 @@ void usb_device_flush_ep_queue(USBDevice *dev, USBEndpoint *ep);

 void usb_device_ep_stopped(USBDevice *dev, USBEndpoint *ep);

+int usb_device_alloc_streams(USBDevice *dev, USBEndpoint **eps, int nr_eps,
+                             int streams);
+void usb_device_free_streams(USBDevice *dev, USBEndpoint **eps, int nr_eps);
+
 const char *usb_device_get_product_desc(USBDevice *dev);

 const USBDesc *usb_device_get_usb_desc(USBDevice *dev);
--- a/linux-user/Makefile.objs
+++ b/linux-user/Makefile.objs
@@ -5,5 +5,3 @@ obj-$(TARGET_HAS_BFLT) += flatload.o
 obj-$(TARGET_I386) += vm86.o
 obj-$(TARGET_ARM) += arm/nwfpe/
 obj-$(TARGET_M68K) += m68k-sim.o
-
-obj-binfmt-y = binfmt.o
--- a/linux-user/alpha/syscall_nr.h
+++ b/linux-user/alpha/syscall_nr.h
@@ -433,10 +433,3 @@
 #define TARGET_NR_open_by_handle_at             498
 #define TARGET_NR_clock_adjtime                 499
 #define TARGET_NR_syncfs                        500
-#define TARGET_NR_setns                         501
-#define TARGET_NR_accept4                       502
-#define TARGET_NR_sendmmsg                      503
-#define TARGET_NR_process_vm_readv              504
-#define TARGET_NR_process_vm_writev             505
-#define TARGET_NR_kcmp                          506
-#define TARGET_NR_finit_module                  507
--- a/linux-user/arm/syscall_nr.h
+++ b/linux-user/arm/syscall_nr.h
@@ -378,9 +378,3 @@
 #define TARGET_NR_open_by_handle_at            (371)
 #define TARGET_NR_clock_adjtime                (372)
 #define TARGET_NR_syncfs                       (373)
-#define TARGET_NR_sendmmsg                     (374)
-#define TARGET_NR_setns                        (375)
-#define TARGET_NR_process_vm_readv             (376)
-#define TARGET_NR_process_vm_writev            (377)
-#define TARGET_NR_kcmp                         (378)
-#define TARGET_NR_finit_module                 (379)
--- a/linux-user/binfmt.c
+++ b/linux-user/binfmt.c
@@ -1,67 +0,0 @@
-#include <stdio.h>
-#include <stdarg.h>
-#include <unistd.h>
-#include <libgen.h>
-#include <string.h>
-#include <stdlib.h>
-
-#ifdef __x86_64__
-#define ARCH_NAME "x86_64"
-#endif
-
-int main(int argc, char **argv, char **envp)
-{
-    char *binfmt;
-    char **new_argv;
-
-    /*
-     * Check if our file name ends with -binfmt
-     */
-    binfmt = argv[0] + strlen(argv[0]) - strlen("-binfmt");
-    if (strcmp(binfmt, "-binfmt")) {
-        fprintf(stderr, "%s: Invalid executable name\n", argv[0]);
-        exit(1);
-    }
-    if (argc < 3) {
-        fprintf(stderr, "%s: Please use me through binfmt with P flag\n",
-                argv[0]);
-        exit(1);
-    }
-
-    binfmt[0] = '\0';
-    /* Now argv[0] is the real qemu binary name */
-
-#ifdef ARCH_NAME
-    {
-        char *hostbin;
-        char *guestarch;
-
-        guestarch = strrchr(argv[0], '-') ;
-        if (!guestarch) {
-            goto skip;
-        }
-        guestarch++;
-        asprintf(&hostbin, "/emul/" ARCH_NAME "-for-%s/%s", guestarch, argv[1]);
-        if (!access(hostbin, X_OK)) {
-            /*
-             * We found a host binary replacement for the non-host binary. Let's
-             * use that instead!
-             */
-            return execve(hostbin, &argv[2], envp);
-        }
-    }
-skip:
-#endif
-
-    new_argv = (char **)malloc((argc + 2) * sizeof(*new_argv));
-    if (argc > 3) {
-        memcpy(&new_argv[4], &argv[3], (argc - 3) * sizeof(*new_argv));
-    }
-    new_argv[0] = argv[0];
-    new_argv[1] = (char *)"-0";
-    new_argv[2] = argv[2];
-    new_argv[3] = argv[1];
-    new_argv[argc + 1] = NULL;
-
-    return execve(new_argv[0], new_argv, envp);
-}
--- a/linux-user/cris/syscall_nr.h
+++ b/linux-user/cris/syscall_nr.h
@@ -335,4 +335,3 @@
 #define TARGET_NR_inotify_init1      332
 #define TARGET_NR_preadv             333
 #define TARGET_NR_pwritev            334
-#define TARGET_NR_setns              335
--- a/linux-user/i386/syscall_nr.h
+++ b/linux-user/i386/syscall_nr.h
@@ -347,9 +347,3 @@
 #define TARGET_NR_open_by_handle_at     342
 #define TARGET_NR_clock_adjtime         343
 #define TARGET_NR_syncfs                344
-#define TARGET_NR_sendmmsg              345
-#define TARGET_NR_setns                 346
-#define TARGET_NR_process_vm_readv      347
-#define TARGET_NR_process_vm_writev     348
-#define TARGET_NR_kcmp                  349
-#define TARGET_NR_finit_module          350
--- a/linux-user/ioctls.h
+++ b/linux-user/ioctls.h
@@ -71,31 +71,12 @@
     IOCTL(BLKGETSIZE, IOC_R, MK_PTR(TYPE_ULONG))
 #ifdef BLKGETSIZE64
     IOCTL(BLKGETSIZE64, IOC_R, MK_PTR(TYPE_ULONGLONG))
-#endif
-#ifdef BLKDISCARD
-     IOCTL(BLKDISCARD, IOC_W, MK_PTR(MK_STRUCT(STRUCT_blkdiscard)))
-#endif
-#ifdef BLKIOMIN
-     IOCTL(BLKIOMIN, IOC_R, MK_PTR(TYPE_INT))
-#endif
-#ifdef BLKIOOPT
-     IOCTL(BLKIOOPT, IOC_R, MK_PTR(TYPE_INT))
-#endif
-#ifdef BLKALIGNOFF
-     IOCTL(BLKALIGNOFF, IOC_R, MK_PTR(TYPE_INT))
-#endif
-#ifdef BLKPBSZGET
-     IOCTL(BLKPBSZGET, IOC_R, MK_PTR(TYPE_INT))
-#endif
-#ifdef BLKDISCARDZEROES
-     IOCTL(BLKDISCARDZEROES, IOC_R, MK_PTR(TYPE_INT))
 #endif
     IOCTL(BLKFLSBUF, 0, TYPE_NULL)
     IOCTL(BLKRASET, 0, TYPE_INT)
     IOCTL(BLKRAGET, IOC_R, MK_PTR(TYPE_LONG))
     IOCTL(BLKSSZGET, IOC_R, MK_PTR(TYPE_LONG))
     IOCTL(BLKBSZGET, IOC_R, MK_PTR(TYPE_INT))
-     IOCTL(BLKPG, IOC_W, MK_PTR(MK_STRUCT(STRUCT_blkpg_ioctl_arg)))
 #ifdef FIBMAP
     IOCTL(FIBMAP, IOC_W | IOC_R, MK_PTR(TYPE_LONG))
 #endif
@@ -106,8 +87,6 @@
     IOCTL_SPECIAL(FS_IOC_FIEMAP, IOC_W | IOC_R, do_ioctl_fs_ioc_fiemap,
                   MK_PTR(MK_STRUCT(STRUCT_fiemap)))
 #endif
-  IOCTL(FS_IOC_GETFLAGS, IOC_R, MK_PTR(TYPE_LONG))
-  IOCTL(FS_IOC_SETFLAGS, IOC_W, MK_PTR(TYPE_LONG))

  IOCTL(SIOCATMARK, 0, TYPE_NULL)
  IOCTL(SIOCGIFNAME, IOC_RW, MK_PTR(TYPE_INT))
@@ -336,11 +315,6 @@
  IOCTL(VFAT_IOCTL_READDIR_BOTH, IOC_R, MK_PTR(MK_ARRAY(MK_STRUCT(STRUCT_dirent), 2)))
  IOCTL(VFAT_IOCTL_READDIR_SHORT, IOC_R, MK_PTR(MK_ARRAY(MK_STRUCT(STRUCT_dirent), 2)))

-/* FIXME: including these on x86 / x86_64 breaks qemu-i386 */
-#ifdef __powerpc__
-#include "ioctls_alsa.h"
-#endif
-
  IOCTL(LOOP_SET_FD, 0, TYPE_INT)
  IOCTL(LOOP_CLR_FD, 0, TYPE_INT)
  IOCTL(LOOP_SET_STATUS, IOC_W, MK_PTR(MK_STRUCT(STRUCT_loop_info)))
@@ -348,7 +322,6 @@
  IOCTL(LOOP_SET_STATUS64, IOC_W, MK_PTR(MK_STRUCT(STRUCT_loop_info64)))
  IOCTL(LOOP_GET_STATUS64, IOC_W, MK_PTR(MK_STRUCT(STRUCT_loop_info64)))
  IOCTL(LOOP_CHANGE_FD, 0, TYPE_INT)
-  IOCTL_SPECIAL(LOOP_BOGUS_CMD, 0, do_ioctl_fail, TYPE_INT)

  IOCTL(MTIOCTOP, IOC_W, MK_PTR(MK_STRUCT(STRUCT_mtop)))
  IOCTL(MTIOCGET, IOC_R, MK_PTR(MK_STRUCT(STRUCT_mtget)))
--- a/linux-user/ioctls_alsa.h
+++ b/linux-user/ioctls_alsa.h
@@ -1,467 +0,0 @@
-#define SNDRV_SEQ_IOCTL_PVERSION	_IOR ('S', 0x00, int)
-#define SNDRV_SEQ_IOCTL_CLIENT_ID	_IOR ('S', 0x01, int)
-#define SNDRV_SEQ_IOCTL_SYSTEM_INFO	_IOWR('S', 0x02, struct sndrv_seq_system_info)
-#define SNDRV_SEQ_IOCTL_RUNNING_MODE	_IOWR('S', 0x03, struct sndrv_seq_running_info)
-#define SNDRV_SEQ_IOCTL_GET_CLIENT_INFO	_IOWR('S', 0x10, struct sndrv_seq_client_info)
-#define SNDRV_SEQ_IOCTL_SET_CLIENT_INFO	_IOW ('S', 0x11, struct sndrv_seq_client_info)
-#define SNDRV_SEQ_IOCTL_CREATE_PORT	_IOWR('S', 0x20, struct sndrv_seq_port_info)
-#define SNDRV_SEQ_IOCTL_DELETE_PORT	_IOW ('S', 0x21, struct sndrv_seq_port_info)
-#define SNDRV_SEQ_IOCTL_GET_PORT_INFO	_IOWR('S', 0x22, struct sndrv_seq_port_info)
-#define SNDRV_SEQ_IOCTL_SET_PORT_INFO	_IOW ('S', 0x23, struct sndrv_seq_port_info)
-#define SNDRV_SEQ_IOCTL_SUBSCRIBE_PORT	_IOW ('S', 0x30, struct sndrv_seq_port_subscribe)
-#define SNDRV_SEQ_IOCTL_UNSUBSCRIBE_PORT _IOW ('S', 0x31, struct sndrv_seq_port_subscribe)
-#define SNDRV_SEQ_IOCTL_CREATE_QUEUE	_IOWR('S', 0x32, struct sndrv_seq_queue_info)
-#define SNDRV_SEQ_IOCTL_DELETE_QUEUE	_IOW ('S', 0x33, struct sndrv_seq_queue_info)
-#define SNDRV_SEQ_IOCTL_GET_QUEUE_INFO	_IOWR('S', 0x34, struct sndrv_seq_queue_info)
-#define SNDRV_SEQ_IOCTL_SET_QUEUE_INFO	_IOWR('S', 0x35, struct sndrv_seq_queue_info)
-#define SNDRV_SEQ_IOCTL_GET_NAMED_QUEUE	_IOWR('S', 0x36, struct sndrv_seq_queue_info)
-#define SNDRV_SEQ_IOCTL_GET_QUEUE_STATUS _IOWR('S', 0x40, struct sndrv_seq_queue_status)
-#define SNDRV_SEQ_IOCTL_GET_QUEUE_TEMPO	_IOWR('S', 0x41, struct sndrv_seq_queue_tempo)
-#define SNDRV_SEQ_IOCTL_SET_QUEUE_TEMPO	_IOW ('S', 0x42, struct sndrv_seq_queue_tempo)
-#define SNDRV_SEQ_IOCTL_GET_QUEUE_OWNER	_IOWR('S', 0x43, struct sndrv_seq_queue_owner)
-#define SNDRV_SEQ_IOCTL_SET_QUEUE_OWNER	_IOW ('S', 0x44, struct sndrv_seq_queue_owner)
-#define SNDRV_SEQ_IOCTL_GET_QUEUE_TIMER	_IOWR('S', 0x45, struct sndrv_seq_queue_timer)
-#define SNDRV_SEQ_IOCTL_SET_QUEUE_TIMER	_IOW ('S', 0x46, struct sndrv_seq_queue_timer)
-#define SNDRV_SEQ_IOCTL_GET_QUEUE_SYNC	_IOWR('S', 0x53, struct sndrv_seq_queue_sync)
-#define SNDRV_SEQ_IOCTL_SET_QUEUE_SYNC	_IOW ('S', 0x54, struct sndrv_seq_queue_sync)
-#define SNDRV_SEQ_IOCTL_GET_QUEUE_CLIENT	_IOWR('S', 0x49, struct sndrv_seq_queue_client)
-#define SNDRV_SEQ_IOCTL_SET_QUEUE_CLIENT	_IOW ('S', 0x4a, struct sndrv_seq_queue_client)
-#define SNDRV_SEQ_IOCTL_GET_CLIENT_POOL	_IOWR('S', 0x4b, struct sndrv_seq_client_pool)
-#define SNDRV_SEQ_IOCTL_SET_CLIENT_POOL	_IOW ('S', 0x4c, struct sndrv_seq_client_pool)
-#define SNDRV_SEQ_IOCTL_REMOVE_EVENTS	_IOW ('S', 0x4e, struct sndrv_seq_remove_events)
-#define SNDRV_SEQ_IOCTL_QUERY_SUBS	_IOWR('S', 0x4f, struct sndrv_seq_query_subs)
-#define SNDRV_SEQ_IOCTL_GET_SUBSCRIPTION	_IOWR('S', 0x50, struct sndrv_seq_port_subscribe)
-#define SNDRV_SEQ_IOCTL_QUERY_NEXT_CLIENT	_IOWR('S', 0x51, struct sndrv_seq_client_info)
-#define SNDRV_SEQ_IOCTL_QUERY_NEXT_PORT	_IOWR('S', 0x52, struct sndrv_seq_port_info)
-#define SNDRV_DM_FM_IOCTL_INFO		_IOR('H', 0x20, snd_dm_fm_info_t)
-#define SNDRV_DM_FM_IOCTL_RESET		_IO ('H', 0x21)
-#define SNDRV_DM_FM_IOCTL_PLAY_NOTE	_IOW('H', 0x22, snd_dm_fm_note_t)
-#define SNDRV_DM_FM_IOCTL_SET_VOICE	_IOW('H', 0x23, snd_dm_fm_voice_t)
-#define SNDRV_DM_FM_IOCTL_SET_PARAMS	_IOW('H', 0x24, snd_dm_fm_params_t)
-#define SNDRV_DM_FM_IOCTL_SET_MODE	_IOW('H', 0x25, int)
-#define SNDRV_DM_FM_IOCTL_SET_CONNECTION	_IOW('H', 0x26, int)
-#define SNDRV_DM_FM_OSS_IOCTL_RESET		0x20
-#define SNDRV_DM_FM_OSS_IOCTL_PLAY_NOTE		0x21
-#define SNDRV_DM_FM_OSS_IOCTL_SET_VOICE		0x22
-#define SNDRV_DM_FM_OSS_IOCTL_SET_PARAMS	0x23
-#define SNDRV_DM_FM_OSS_IOCTL_SET_MODE		0x24
-#define SNDRV_DM_FM_OSS_IOCTL_SET_OPL		0x25
-#define SNDRV_HWDEP_IOCTL_PVERSION _IOR ('H', 0x00, int)
-#define SNDRV_HWDEP_IOCTL_INFO _IOR ('H', 0x01, struct sndrv_hwdep_info)
-#define SNDRV_HWDEP_IOCTL_DSP_STATUS _IOR('H', 0x02, struct sndrv_hwdep_dsp_status)
-#define SNDRV_HWDEP_IOCTL_DSP_LOAD   _IOW('H', 0x03, struct sndrv_hwdep_dsp_image)
-#define SNDRV_PCM_IOCTL_PVERSION _IOR('A', 0x00, int)
-#define SNDRV_PCM_IOCTL_INFO _IOR('A', 0x01, struct sndrv_pcm_info)
-#define SNDRV_PCM_IOCTL_TSTAMP _IOW('A', 0x02, int)
-#define SNDRV_PCM_IOCTL_HW_REFINE _IOWR('A', 0x10, struct sndrv_pcm_hw_params)
-#define SNDRV_PCM_IOCTL_HW_PARAMS _IOWR('A', 0x11, struct sndrv_pcm_hw_params)
-#define SNDRV_PCM_IOCTL_HW_FREE _IO('A', 0x12)
-#define SNDRV_PCM_IOCTL_SW_PARAMS _IOWR('A', 0x13, struct sndrv_pcm_sw_params)
-#define SNDRV_PCM_IOCTL_STATUS _IOR('A', 0x20, struct sndrv_pcm_status)
-#define SNDRV_PCM_IOCTL_DELAY _IOR('A', 0x21, sndrv_pcm_sframes_t)
-#define SNDRV_PCM_IOCTL_HWSYNC _IO('A', 0x22)
-#define SNDRV_PCM_IOCTL_SYNC_PTR _IOWR('A', 0x23, struct sndrv_pcm_sync_ptr)
-#define SNDRV_PCM_IOCTL_CHANNEL_INFO _IOR('A', 0x32, struct sndrv_pcm_channel_info)
-#define SNDRV_PCM_IOCTL_PREPARE _IO('A', 0x40)
-#define SNDRV_PCM_IOCTL_RESET _IO('A', 0x41)
-#define SNDRV_PCM_IOCTL_START _IO('A', 0x42)
-#define SNDRV_PCM_IOCTL_DROP _IO('A', 0x43)
-#define SNDRV_PCM_IOCTL_DRAIN _IO('A', 0x44)
-#define SNDRV_PCM_IOCTL_PAUSE _IOW('A', 0x45, int)
-#define SNDRV_PCM_IOCTL_REWIND _IOW('A', 0x46, sndrv_pcm_uframes_t)
-#define SNDRV_PCM_IOCTL_RESUME _IO('A', 0x47)
-#define SNDRV_PCM_IOCTL_XRUN _IO('A', 0x48)
-#define SNDRV_PCM_IOCTL_FORWARD _IOW('A', 0x49, sndrv_pcm_uframes_t)
-#define SNDRV_PCM_IOCTL_WRITEI_FRAMES _IOW('A', 0x50, struct sndrv_xferi)
-#define SNDRV_PCM_IOCTL_READI_FRAMES _IOR('A', 0x51, struct sndrv_xferi)
-#define SNDRV_PCM_IOCTL_WRITEN_FRAMES _IOW('A', 0x52, struct sndrv_xfern)
-#define SNDRV_PCM_IOCTL_READN_FRAMES _IOR('A', 0x53, struct sndrv_xfern)
-#define SNDRV_PCM_IOCTL_LINK _IOW('A', 0x60, int)
-#define SNDRV_PCM_IOCTL_UNLINK _IO('A', 0x61)
-#define SNDRV_RAWMIDI_IOCTL_PVERSION _IOR('W', 0x00, int)
-#define SNDRV_RAWMIDI_IOCTL_INFO _IOR('W', 0x01, struct sndrv_rawmidi_info)
-#define SNDRV_RAWMIDI_IOCTL_PARAMS _IOWR('W', 0x10, struct sndrv_rawmidi_params)
-#define SNDRV_RAWMIDI_IOCTL_STATUS _IOWR('W', 0x20, struct sndrv_rawmidi_status)
-#define SNDRV_RAWMIDI_IOCTL_DROP _IOW('W', 0x30, int)
-#define SNDRV_RAWMIDI_IOCTL_DRAIN _IOW('W', 0x31, int)
-#define SNDRV_TIMER_IOCTL_PVERSION _IOR('T', 0x00, int)
-#define SNDRV_TIMER_IOCTL_NEXT_DEVICE _IOWR('T', 0x01, struct sndrv_timer_id)
-#define SNDRV_TIMER_IOCTL_TREAD _IOW('T', 0x02, int)
-#define SNDRV_TIMER_IOCTL_GINFO _IOWR('T', 0x03, struct sndrv_timer_ginfo)
-#define SNDRV_TIMER_IOCTL_GPARAMS _IOW('T', 0x04, struct sndrv_timer_gparams)
-#define SNDRV_TIMER_IOCTL_GSTATUS _IOWR('T', 0x05, struct sndrv_timer_gstatus)
-#define SNDRV_TIMER_IOCTL_SELECT _IOW('T', 0x10, struct sndrv_timer_select)
-#define SNDRV_TIMER_IOCTL_INFO _IOR('T', 0x11, struct sndrv_timer_info)
-#define SNDRV_TIMER_IOCTL_PARAMS _IOW('T', 0x12, struct sndrv_timer_params)
-#define SNDRV_TIMER_IOCTL_STATUS _IOR('T', 0x14, struct sndrv_timer_status)
-#define SNDRV_TIMER_IOCTL_START _IO('T', 0xa0)
-#define SNDRV_TIMER_IOCTL_STOP _IO('T', 0xa1)
-#define SNDRV_TIMER_IOCTL_CONTINUE _IO('T', 0xa2)
-#define SNDRV_TIMER_IOCTL_PAUSE _IO('T', 0xa3)
-#define SNDRV_CTL_IOCTL_PVERSION _IOR('U', 0x00, int)
-#define SNDRV_CTL_IOCTL_CARD_INFO _IOR('U', 0x01, struct sndrv_ctl_card_info)
-#define SNDRV_CTL_IOCTL_ELEM_LIST _IOWR('U', 0x10, struct sndrv_ctl_elem_list)
-#define SNDRV_CTL_IOCTL_ELEM_INFO _IOWR('U', 0x11, struct sndrv_ctl_elem_info)
-#define SNDRV_CTL_IOCTL_ELEM_READ _IOWR('U', 0x12, struct sndrv_ctl_elem_value)
-#define SNDRV_CTL_IOCTL_ELEM_WRITE _IOWR('U', 0x13, struct sndrv_ctl_elem_value)
-#define SNDRV_CTL_IOCTL_ELEM_LOCK _IOW('U', 0x14, struct sndrv_ctl_elem_id)
-#define SNDRV_CTL_IOCTL_ELEM_UNLOCK _IOW('U', 0x15, struct sndrv_ctl_elem_id)
-#define SNDRV_CTL_IOCTL_SUBSCRIBE_EVENTS _IOWR('U', 0x16, int)
-#define SNDRV_CTL_IOCTL_ELEM_ADD _IOWR('U', 0x17, struct sndrv_ctl_elem_info)
-#define SNDRV_CTL_IOCTL_ELEM_REPLACE _IOWR('U', 0x18, struct sndrv_ctl_elem_info)
-#define SNDRV_CTL_IOCTL_ELEM_REMOVE _IOWR('U', 0x19, struct sndrv_ctl_elem_id)
-#define SNDRV_CTL_IOCTL_TLV_READ _IOWR('U', 0x1a, struct sndrv_ctl_tlv)
-#define SNDRV_CTL_IOCTL_TLV_WRITE _IOWR('U', 0x1b, struct sndrv_ctl_tlv)
-#define SNDRV_CTL_IOCTL_TLV_COMMAND _IOWR('U', 0x1c, struct sndrv_ctl_tlv)
-#define SNDRV_CTL_IOCTL_HWDEP_NEXT_DEVICE _IOWR('U', 0x20, int)
-#define SNDRV_CTL_IOCTL_HWDEP_INFO _IOR('U', 0x21, struct sndrv_hwdep_info)
-#define SNDRV_CTL_IOCTL_PCM_NEXT_DEVICE _IOR('U', 0x30, int)
-#define SNDRV_CTL_IOCTL_PCM_INFO _IOWR('U', 0x31, struct sndrv_pcm_info)
-#define SNDRV_CTL_IOCTL_PCM_PREFER_SUBDEVICE _IOW('U', 0x32, int)
-#define SNDRV_CTL_IOCTL_RAWMIDI_NEXT_DEVICE _IOWR('U', 0x40, int)
-#define SNDRV_CTL_IOCTL_RAWMIDI_INFO _IOWR('U', 0x41, struct sndrv_rawmidi_info)
-#define SNDRV_CTL_IOCTL_RAWMIDI_PREFER_SUBDEVICE _IOW('U', 0x42, int)
-#define SNDRV_CTL_IOCTL_POWER _IOWR('U', 0xd0, int)
-#define SNDRV_CTL_IOCTL_POWER_STATE _IOR('U', 0xd1, int)
-#define SNDRV_IOCTL_READV _IOW('K', 0x00, struct sndrv_xferv)
-#define SNDRV_IOCTL_WRITEV _IOW('K', 0x01, struct sndrv_xferv)
-#define SNDRV_EMU10K1_IOCTL_INFO	_IOR ('H', 0x10, emu10k1_fx8010_info_t)
-#define SNDRV_EMU10K1_IOCTL_CODE_POKE	_IOW ('H', 0x11, emu10k1_fx8010_code_t)
-#define SNDRV_EMU10K1_IOCTL_CODE_PEEK	_IOWR('H', 0x12, emu10k1_fx8010_code_t)
-#define SNDRV_EMU10K1_IOCTL_TRAM_SETUP	_IOW ('H', 0x20, int)
-#define SNDRV_EMU10K1_IOCTL_TRAM_POKE	_IOW ('H', 0x21, emu10k1_fx8010_tram_t)
-#define SNDRV_EMU10K1_IOCTL_TRAM_PEEK	_IOWR('H', 0x22, emu10k1_fx8010_tram_t)
-#define SNDRV_EMU10K1_IOCTL_PCM_POKE	_IOW ('H', 0x30, emu10k1_fx8010_pcm_t)
-#define SNDRV_EMU10K1_IOCTL_PCM_PEEK	_IOWR('H', 0x31, emu10k1_fx8010_pcm_t)
-#define SNDRV_EMU10K1_IOCTL_PVERSION	_IOR ('H', 0x40, int)
-#define SNDRV_EMU10K1_IOCTL_STOP	_IO  ('H', 0x80)
-#define SNDRV_EMU10K1_IOCTL_CONTINUE	_IO  ('H', 0x81)
-#define SNDRV_EMU10K1_IOCTL_ZERO_TRAM_COUNTER _IO ('H', 0x82)
-#define SNDRV_EMU10K1_IOCTL_SINGLE_STEP	_IOW ('H', 0x83, int)
-#define SNDRV_EMU10K1_IOCTL_DBG_READ	_IOR ('H', 0x84, int)
-#define SNDRV_HDSP_IOCTL_GET_PEAK_RMS _IOR('H', 0x40, hdsp_peak_rms_t)
-#define SNDRV_HDSP_IOCTL_GET_CONFIG_INFO _IOR('H', 0x41, hdsp_config_info_t)
-#define SNDRV_HDSP_IOCTL_UPLOAD_FIRMWARE _IOW('H', 0x42, hdsp_firmware_t)
-#define SNDRV_HDSP_IOCTL_GET_VERSION _IOR('H', 0x43, hdsp_version_t)
-#define SNDRV_HDSP_IOCTL_GET_MIXER _IOR('H', 0x44, hdsp_mixer_t)
-#define SNDRV_HDSP_IOCTL_GET_9632_AEB _IOR('H', 0x45, hdsp_9632_aeb_t)
-#define SNDRV_SB_CSP_IOCTL_INFO		_IOR('H', 0x10, snd_sb_csp_info_t)
-#define SNDRV_SB_CSP_IOCTL_LOAD_CODE	_IOW('H', 0x11, snd_sb_csp_microcode_t)
-#define SNDRV_SB_CSP_IOCTL_UNLOAD_CODE	_IO('H', 0x12)
-#define SNDRV_SB_CSP_IOCTL_START	_IOW('H', 0x13, snd_sb_csp_start_t)
-#define SNDRV_SB_CSP_IOCTL_STOP		_IO('H', 0x14)
-#define SNDRV_SB_CSP_IOCTL_PAUSE	_IO('H', 0x15)
-#define SNDRV_SB_CSP_IOCTL_RESTART	_IO('H', 0x16)
-#define SND_SSCAPE_LOAD_BOOTB  _IOWR('P', 100, struct sscape_bootblock)
-#define SND_SSCAPE_LOAD_MCODE  _IOW ('P', 101, struct sscape_microcode)
-
-
-#define TARGET_SNDRV_SEQ_IOCTL_PVERSION	TARGET_IOR ('S', 0x00, int)
-#define TARGET_SNDRV_SEQ_IOCTL_CLIENT_ID	TARGET_IOR ('S', 0x01, int)
-#define TARGET_SNDRV_SEQ_IOCTL_SYSTEM_INFO	TARGET_IOWRU('S', 0x02)
-#define TARGET_SNDRV_SEQ_IOCTL_RUNNING_MODE	TARGET_IOWRU('S', 0x03)
-#define TARGET_SNDRV_SEQ_IOCTL_GET_CLIENT_INFO	TARGET_IOWRU('S', 0x10)
-#define TARGET_SNDRV_SEQ_IOCTL_SET_CLIENT_INFO	TARGET_IOWU ('S', 0x11)
-#define TARGET_SNDRV_SEQ_IOCTL_CREATE_PORT	TARGET_IOWRU('S', 0x20)
-#define TARGET_SNDRV_SEQ_IOCTL_DELETE_PORT	TARGET_IOWU ('S', 0x21)
-#define TARGET_SNDRV_SEQ_IOCTL_GET_PORT_INFO	TARGET_IOWRU('S', 0x22)
-#define TARGET_SNDRV_SEQ_IOCTL_SET_PORT_INFO	TARGET_IOWU ('S', 0x23)
-#define TARGET_SNDRV_SEQ_IOCTL_SUBSCRIBE_PORT	TARGET_IOWU ('S', 0x30)
-#define TARGET_SNDRV_SEQ_IOCTL_UNSUBSCRIBE_PORT TARGET_IOWU ('S', 0x31)
-#define TARGET_SNDRV_SEQ_IOCTL_CREATE_QUEUE	TARGET_IOWRU('S', 0x32)
-#define TARGET_SNDRV_SEQ_IOCTL_DELETE_QUEUE	TARGET_IOWU ('S', 0x33)
-#define TARGET_SNDRV_SEQ_IOCTL_GET_QUEUE_INFO	TARGET_IOWRU('S', 0x34)
-#define TARGET_SNDRV_SEQ_IOCTL_SET_QUEUE_INFO	TARGET_IOWRU('S', 0x35)
-#define TARGET_SNDRV_SEQ_IOCTL_GET_NAMED_QUEUE	TARGET_IOWRU('S', 0x36)
-#define TARGET_SNDRV_SEQ_IOCTL_GET_QUEUE_STATUS TARGET_IOWRU('S', 0x40)
-#define TARGET_SNDRV_SEQ_IOCTL_GET_QUEUE_TEMPO	TARGET_IOWRU('S', 0x41)
-#define TARGET_SNDRV_SEQ_IOCTL_SET_QUEUE_TEMPO	TARGET_IOWU ('S', 0x42)
-#define TARGET_SNDRV_SEQ_IOCTL_GET_QUEUE_OWNER	TARGET_IOWRU('S', 0x43)
-#define TARGET_SNDRV_SEQ_IOCTL_SET_QUEUE_OWNER	TARGET_IOWU ('S', 0x44)
-#define TARGET_SNDRV_SEQ_IOCTL_GET_QUEUE_TIMER	TARGET_IOWRU('S', 0x45)
-#define TARGET_SNDRV_SEQ_IOCTL_SET_QUEUE_TIMER	TARGET_IOWU ('S', 0x46)
-#define TARGET_SNDRV_SEQ_IOCTL_GET_QUEUE_SYNC	TARGET_IOWRU('S', 0x53)
-#define TARGET_SNDRV_SEQ_IOCTL_SET_QUEUE_SYNC	TARGET_IOWU ('S', 0x54)
-#define TARGET_SNDRV_SEQ_IOCTL_GET_QUEUE_CLIENT	TARGET_IOWRU('S', 0x49)
-#define TARGET_SNDRV_SEQ_IOCTL_SET_QUEUE_CLIENT	TARGET_IOWU ('S', 0x4a)
-#define TARGET_SNDRV_SEQ_IOCTL_GET_CLIENT_POOL	TARGET_IOWRU('S', 0x4b)
-#define TARGET_SNDRV_SEQ_IOCTL_SET_CLIENT_POOL	TARGET_IOWU ('S', 0x4c)
-#define TARGET_SNDRV_SEQ_IOCTL_REMOVE_EVENTS	TARGET_IOWU ('S', 0x4e)
-#define TARGET_SNDRV_SEQ_IOCTL_QUERY_SUBS	TARGET_IOWRU('S', 0x4f)
-#define TARGET_SNDRV_SEQ_IOCTL_GET_SUBSCRIPTION	TARGET_IOWRU('S', 0x50)
-#define TARGET_SNDRV_SEQ_IOCTL_QUERY_NEXT_CLIENT	TARGET_IOWRU('S', 0x51)
-#define TARGET_SNDRV_SEQ_IOCTL_QUERY_NEXT_PORT	TARGET_IOWRU('S', 0x52)
-#define TARGET_SNDRV_DM_FM_IOCTL_INFO		TARGET_IORU('H', 0x20)
-#define TARGET_SNDRV_DM_FM_IOCTL_RESET		TARGET_IO ('H', 0x21)
-#define TARGET_SNDRV_DM_FM_IOCTL_PLAY_NOTE	TARGET_IOWU('H', 0x22)
-#define TARGET_SNDRV_DM_FM_IOCTL_SET_VOICE	TARGET_IOWU('H', 0x23)
-#define TARGET_SNDRV_DM_FM_IOCTL_SET_PARAMS	TARGET_IOWU('H', 0x24)
-#define TARGET_SNDRV_DM_FM_IOCTL_SET_MODE	TARGET_IOW('H', 0x25, int)
-#define TARGET_SNDRV_DM_FM_IOCTL_SET_CONNECTION	TARGET_IOW('H', 0x26, int)
-#define TARGET_SNDRV_DM_FM_OSS_IOCTL_RESET		0x20
-#define TARGET_SNDRV_DM_FM_OSS_IOCTL_PLAY_NOTE		0x21
-#define TARGET_SNDRV_DM_FM_OSS_IOCTL_SET_VOICE		0x22
-#define TARGET_SNDRV_DM_FM_OSS_IOCTL_SET_PARAMS	0x23
-#define TARGET_SNDRV_DM_FM_OSS_IOCTL_SET_MODE		0x24
-#define TARGET_SNDRV_DM_FM_OSS_IOCTL_SET_OPL		0x25
-#define TARGET_SNDRV_HWDEP_IOCTL_PVERSION TARGET_IOR ('H', 0x00, int)
-#define TARGET_SNDRV_HWDEP_IOCTL_INFO TARGET_IORU ('H', 0x01)
-#define TARGET_SNDRV_HWDEP_IOCTL_DSP_STATUS TARGET_IORU('H', 0x02)
-#define TARGET_SNDRV_HWDEP_IOCTL_DSP_LOAD   TARGET_IOWU('H', 0x03)
-#define TARGET_SNDRV_PCM_IOCTL_PVERSION TARGET_IOR('A', 0x00, int)
-#define TARGET_SNDRV_PCM_IOCTL_INFO TARGET_IORU('A', 0x01)
-#define TARGET_SNDRV_PCM_IOCTL_TSTAMP TARGET_IOW('A', 0x02, int)
-#define TARGET_SNDRV_PCM_IOCTL_HW_REFINE TARGET_IOWRU('A', 0x10)
-#define TARGET_SNDRV_PCM_IOCTL_HW_PARAMS TARGET_IOWRU('A', 0x11)
-#define TARGET_SNDRV_PCM_IOCTL_HW_FREE TARGET_IO('A', 0x12)
-#define TARGET_SNDRV_PCM_IOCTL_SW_PARAMS TARGET_IOWRU('A', 0x13)
-#define TARGET_SNDRV_PCM_IOCTL_STATUS TARGET_IORU('A', 0x20)
-#define TARGET_SNDRV_PCM_IOCTL_DELAY TARGET_IORU('A', 0x21)
-#define TARGET_SNDRV_PCM_IOCTL_HWSYNC TARGET_IO('A', 0x22)
-#define TARGET_SNDRV_PCM_IOCTL_SYNC_PTR TARGET_IOWRU('A', 0x23)
-#define TARGET_SNDRV_PCM_IOCTL_CHANNEL_INFO TARGET_IORU('A', 0x32)
-#define TARGET_SNDRV_PCM_IOCTL_PREPARE TARGET_IO('A', 0x40)
-#define TARGET_SNDRV_PCM_IOCTL_RESET TARGET_IO('A', 0x41)
-#define TARGET_SNDRV_PCM_IOCTL_START TARGET_IO('A', 0x42)
-#define TARGET_SNDRV_PCM_IOCTL_DROP TARGET_IO('A', 0x43)
-#define TARGET_SNDRV_PCM_IOCTL_DRAIN TARGET_IO('A', 0x44)
-#define TARGET_SNDRV_PCM_IOCTL_PAUSE TARGET_IOW('A', 0x45, int)
-#define TARGET_SNDRV_PCM_IOCTL_REWIND TARGET_IOWU('A', 0x46)
-#define TARGET_SNDRV_PCM_IOCTL_RESUME TARGET_IO('A', 0x47)
-#define TARGET_SNDRV_PCM_IOCTL_XRUN TARGET_IO('A', 0x48)
-#define TARGET_SNDRV_PCM_IOCTL_FORWARD TARGET_IOWU('A', 0x49)
-#define TARGET_SNDRV_PCM_IOCTL_WRITEI_FRAMES TARGET_IOWU('A', 0x50)
-#define TARGET_SNDRV_PCM_IOCTL_READI_FRAMES TARGET_IORU('A', 0x51)
-#define TARGET_SNDRV_PCM_IOCTL_WRITEN_FRAMES TARGET_IOWU('A', 0x52)
-#define TARGET_SNDRV_PCM_IOCTL_READN_FRAMES TARGET_IORU('A', 0x53)
-#define TARGET_SNDRV_PCM_IOCTL_LINK TARGET_IOW('A', 0x60, int)
-#define TARGET_SNDRV_PCM_IOCTL_UNLINK TARGET_IO('A', 0x61)
-#define TARGET_SNDRV_RAWMIDI_IOCTL_PVERSION TARGET_IOR('W', 0x00, int)
-#define TARGET_SNDRV_RAWMIDI_IOCTL_INFO TARGET_IORU('W', 0x01)
-#define TARGET_SNDRV_RAWMIDI_IOCTL_PARAMS TARGET_IOWRU('W', 0x10)
-#define TARGET_SNDRV_RAWMIDI_IOCTL_STATUS TARGET_IOWRU('W', 0x20)
-#define TARGET_SNDRV_RAWMIDI_IOCTL_DROP TARGET_IOW('W', 0x30, int)
-#define TARGET_SNDRV_RAWMIDI_IOCTL_DRAIN TARGET_IOW('W', 0x31, int)
-#define TARGET_SNDRV_TIMER_IOCTL_PVERSION TARGET_IOR('T', 0x00, int)
-#define TARGET_SNDRV_TIMER_IOCTL_NEXT_DEVICE TARGET_IOWRU('T', 0x01)
-#define TARGET_SNDRV_TIMER_IOCTL_TREAD TARGET_IOW('T', 0x02, int)
-#define TARGET_SNDRV_TIMER_IOCTL_GINFO TARGET_IOWRU('T', 0x03)
-#define TARGET_SNDRV_TIMER_IOCTL_GPARAMS TARGET_IOWU('T', 0x04)
-#define TARGET_SNDRV_TIMER_IOCTL_GSTATUS TARGET_IOWRU('T', 0x05)
-#define TARGET_SNDRV_TIMER_IOCTL_SELECT TARGET_IOWU('T', 0x10)
-#define TARGET_SNDRV_TIMER_IOCTL_INFO TARGET_IORU('T', 0x11)
-#define TARGET_SNDRV_TIMER_IOCTL_PARAMS TARGET_IOWU('T', 0x12)
-#define TARGET_SNDRV_TIMER_IOCTL_STATUS TARGET_IORU('T', 0x14)
-#define TARGET_SNDRV_TIMER_IOCTL_START TARGET_IO('T', 0xa0)
-#define TARGET_SNDRV_TIMER_IOCTL_STOP TARGET_IO('T', 0xa1)
-#define TARGET_SNDRV_TIMER_IOCTL_CONTINUE TARGET_IO('T', 0xa2)
-#define TARGET_SNDRV_TIMER_IOCTL_PAUSE TARGET_IO('T', 0xa3)
-#define TARGET_SNDRV_CTL_IOCTL_PVERSION TARGET_IOR('U', 0x00, int)
-#define TARGET_SNDRV_CTL_IOCTL_CARD_INFO TARGET_IORU('U', 0x01)
-#define TARGET_SNDRV_CTL_IOCTL_ELEM_LIST TARGET_IOWRU('U', 0x10)
-#define TARGET_SNDRV_CTL_IOCTL_ELEM_INFO TARGET_IOWRU('U', 0x11)
-#define TARGET_SNDRV_CTL_IOCTL_ELEM_READ TARGET_IOWRU('U', 0x12)
-#define TARGET_SNDRV_CTL_IOCTL_ELEM_WRITE TARGET_IOWRU('U', 0x13)
-#define TARGET_SNDRV_CTL_IOCTL_ELEM_LOCK TARGET_IOWU('U', 0x14)
-#define TARGET_SNDRV_CTL_IOCTL_ELEM_UNLOCK TARGET_IOWU('U', 0x15)
-#define TARGET_SNDRV_CTL_IOCTL_SUBSCRIBE_EVENTS TARGET_IOWR('U', 0x16, int)
-#define TARGET_SNDRV_CTL_IOCTL_ELEM_ADD TARGET_IOWRU('U', 0x17)
-#define TARGET_SNDRV_CTL_IOCTL_ELEM_REPLACE TARGET_IOWRU('U', 0x18)
-#define TARGET_SNDRV_CTL_IOCTL_ELEM_REMOVE TARGET_IOWRU('U', 0x19)
-#define TARGET_SNDRV_CTL_IOCTL_TLV_READ TARGET_IOWRU('U', 0x1a)
-#define TARGET_SNDRV_CTL_IOCTL_TLV_WRITE TARGET_IOWRU('U', 0x1b)
-#define TARGET_SNDRV_CTL_IOCTL_TLV_COMMAND TARGET_IOWRU('U', 0x1c)
-#define TARGET_SNDRV_CTL_IOCTL_HWDEP_NEXT_DEVICE TARGET_IOWR('U', 0x20, int)
-#define TARGET_SNDRV_CTL_IOCTL_HWDEP_INFO TARGET_IORU('U', 0x21)
-#define TARGET_SNDRV_CTL_IOCTL_PCM_NEXT_DEVICE TARGET_IOR('U', 0x30, int)
-#define TARGET_SNDRV_CTL_IOCTL_PCM_INFO TARGET_IOWRU('U', 0x31)
-#define TARGET_SNDRV_CTL_IOCTL_PCM_PREFER_SUBDEVICE TARGET_IOW('U', 0x32, int)
-#define TARGET_SNDRV_CTL_IOCTL_RAWMIDI_NEXT_DEVICE TARGET_IOWR('U', 0x40, int)
-#define TARGET_SNDRV_CTL_IOCTL_RAWMIDI_INFO TARGET_IOWRU('U', 0x41)
-#define TARGET_SNDRV_CTL_IOCTL_RAWMIDI_PREFER_SUBDEVICE TARGET_IOW('U', 0x42, int)
-#define TARGET_SNDRV_CTL_IOCTL_POWER TARGET_IOWR('U', 0xd0, int)
-#define TARGET_SNDRV_CTL_IOCTL_POWER_STATE TARGET_IOR('U', 0xd1, int)
-#define TARGET_SNDRV_IOCTL_READV TARGET_IOWU('K', 0x00)
-#define TARGET_SNDRV_IOCTL_WRITEV TARGET_IOWU('K', 0x01)
-#define TARGET_SNDRV_EMU10K1_IOCTL_INFO	TARGET_IORU ('H', 0x10)
-#define TARGET_SNDRV_EMU10K1_IOCTL_CODE_POKE	TARGET_IOWU ('H', 0x11)
-#define TARGET_SNDRV_EMU10K1_IOCTL_CODE_PEEK	TARGET_IOWRU('H', 0x12)
-#define TARGET_SNDRV_EMU10K1_IOCTL_TRAM_SETUP	TARGET_IOW ('H', 0x20, int)
-#define TARGET_SNDRV_EMU10K1_IOCTL_TRAM_POKE	TARGET_IOWU ('H', 0x21)
-#define TARGET_SNDRV_EMU10K1_IOCTL_TRAM_PEEK	TARGET_IOWRU('H', 0x22)
-#define TARGET_SNDRV_EMU10K1_IOCTL_PCM_POKE	TARGET_IOWU ('H', 0x30)
-#define TARGET_SNDRV_EMU10K1_IOCTL_PCM_PEEK	TARGET_IOWRU('H', 0x31)
-#define TARGET_SNDRV_EMU10K1_IOCTL_PVERSION	TARGET_IOR ('H', 0x40, int)
-#define TARGET_SNDRV_EMU10K1_IOCTL_STOP	TARGET_IO  ('H', 0x80)
-#define TARGET_SNDRV_EMU10K1_IOCTL_CONTINUE	TARGET_IO  ('H', 0x81)
-#define TARGET_SNDRV_EMU10K1_IOCTL_ZERO_TRAM_COUNTER TARGET_IO ('H', 0x82)
-#define TARGET_SNDRV_EMU10K1_IOCTL_SINGLE_STEP	TARGET_IOW ('H', 0x83, int)
-#define TARGET_SNDRV_EMU10K1_IOCTL_DBG_READ	TARGET_IOR ('H', 0x84, int)
-#define TARGET_SNDRV_HDSP_IOCTL_GET_PEAK_RMS TARGET_IORU('H', 0x40)
-#define TARGET_SNDRV_HDSP_IOCTL_GET_CONFIG_INFO TARGET_IORU('H', 0x41)
-#define TARGET_SNDRV_HDSP_IOCTL_UPLOAD_FIRMWARE TARGET_IOWU('H', 0x42)
-#define TARGET_SNDRV_HDSP_IOCTL_GET_VERSION TARGET_IORU('H', 0x43)
-#define TARGET_SNDRV_HDSP_IOCTL_GET_MIXER TARGET_IORU('H', 0x44)
-#define TARGET_SNDRV_HDSP_IOCTL_GET_9632_AEB TARGET_IORU('H', 0x45)
-#define TARGET_SNDRV_SB_CSP_IOCTL_INFO		TARGET_IORU('H', 0x10)
-#define TARGET_SNDRV_SB_CSP_IOCTL_LOAD_CODE	TARGET_IOWU('H', 0x11)
-#define TARGET_SNDRV_SB_CSP_IOCTL_UNLOAD_CODE	TARGET_IO('H', 0x12)
-#define TARGET_SNDRV_SB_CSP_IOCTL_START	TARGET_IOWU('H', 0x13)
-#define TARGET_SNDRV_SB_CSP_IOCTL_STOP		TARGET_IO('H', 0x14)
-#define TARGET_SNDRV_SB_CSP_IOCTL_PAUSE	TARGET_IO('H', 0x15)
-#define TARGET_SNDRV_SB_CSP_IOCTL_RESTART	TARGET_IO('H', 0x16)
-#define TARGET_SND_SSCAPE_LOAD_BOOTB  TARGET_IOWRU('P', 100)
-#define TARGET_SND_SSCAPE_LOAD_MCODE  TARGET_IOWU ('P', 101)
-
-IOCTL( SNDRV_SEQ_IOCTL_PVERSION	, IOC_R, MK_PTR(TYPE_INT) )
-IOCTL( SNDRV_SEQ_IOCTL_CLIENT_ID	, IOC_R, MK_PTR(TYPE_INT) )
-IOCTL( SNDRV_SEQ_IOCTL_SYSTEM_INFO	, IOC_RW, MK_PTR(MK_STRUCT(STRUCT_sndrv_seq_system_info)) )
-IOCTL( SNDRV_SEQ_IOCTL_RUNNING_MODE	, IOC_RW, MK_PTR(MK_STRUCT(STRUCT_sndrv_seq_running_info)) )
-IOCTL( SNDRV_SEQ_IOCTL_GET_CLIENT_INFO	, IOC_RW, MK_PTR(MK_STRUCT(STRUCT_sndrv_seq_client_info)) )
-IOCTL( SNDRV_SEQ_IOCTL_SET_CLIENT_INFO	, IOC_W, MK_PTR(MK_STRUCT(STRUCT_sndrv_seq_client_info)) )
-IOCTL( SNDRV_SEQ_IOCTL_CREATE_PORT	, IOC_RW, MK_PTR(MK_STRUCT(STRUCT_sndrv_seq_port_info)) )
-IOCTL( SNDRV_SEQ_IOCTL_DELETE_PORT	, IOC_W, MK_PTR(MK_STRUCT(STRUCT_sndrv_seq_port_info)) )
-IOCTL( SNDRV_SEQ_IOCTL_GET_PORT_INFO	, IOC_RW, MK_PTR(MK_STRUCT(STRUCT_sndrv_seq_port_info)) )
-IOCTL( SNDRV_SEQ_IOCTL_SET_PORT_INFO	, IOC_W, MK_PTR(MK_STRUCT(STRUCT_sndrv_seq_port_info)) )
-IOCTL( SNDRV_SEQ_IOCTL_SUBSCRIBE_PORT	, IOC_W, MK_PTR(MK_STRUCT(STRUCT_sndrv_seq_port_subscribe)) )
-IOCTL( SNDRV_SEQ_IOCTL_UNSUBSCRIBE_PORT , IOC_W, MK_PTR(MK_STRUCT(STRUCT_sndrv_seq_port_subscribe)) )
-IOCTL( SNDRV_SEQ_IOCTL_CREATE_QUEUE	, IOC_RW, MK_PTR(MK_STRUCT(STRUCT_sndrv_seq_queue_info)) )
-IOCTL( SNDRV_SEQ_IOCTL_DELETE_QUEUE	, IOC_W, MK_PTR(MK_STRUCT(STRUCT_sndrv_seq_queue_info)) )
-IOCTL( SNDRV_SEQ_IOCTL_GET_QUEUE_INFO	, IOC_RW, MK_PTR(MK_STRUCT(STRUCT_sndrv_seq_queue_info)) )
-IOCTL( SNDRV_SEQ_IOCTL_SET_QUEUE_INFO	, IOC_RW, MK_PTR(MK_STRUCT(STRUCT_sndrv_seq_queue_info)) )
-IOCTL( SNDRV_SEQ_IOCTL_GET_NAMED_QUEUE	, IOC_RW, MK_PTR(MK_STRUCT(STRUCT_sndrv_seq_queue_info)) )
-IOCTL( SNDRV_SEQ_IOCTL_GET_QUEUE_STATUS , IOC_RW, MK_PTR(MK_STRUCT(STRUCT_sndrv_seq_queue_status)) )
-IOCTL( SNDRV_SEQ_IOCTL_GET_QUEUE_TEMPO	, IOC_RW, MK_PTR(MK_STRUCT(STRUCT_sndrv_seq_queue_tempo)) )
-IOCTL( SNDRV_SEQ_IOCTL_SET_QUEUE_TEMPO	, IOC_W, MK_PTR(MK_STRUCT(STRUCT_sndrv_seq_queue_tempo)) )
-//IOCTL( SNDRV_SEQ_IOCTL_GET_QUEUE_OWNER	, IOC_RW, MK_PTR(MK_STRUCT(STRUCT_sndrv_seq_queue_owner)) )
-//IOCTL( SNDRV_SEQ_IOCTL_SET_QUEUE_OWNER	, IOC_W, MK_PTR(MK_STRUCT(STRUCT_sndrv_seq_queue_owner)) )
-IOCTL( SNDRV_SEQ_IOCTL_GET_QUEUE_TIMER	, IOC_RW, MK_PTR(MK_STRUCT(STRUCT_sndrv_seq_queue_timer)) )
-IOCTL( SNDRV_SEQ_IOCTL_SET_QUEUE_TIMER	, IOC_W, MK_PTR(MK_STRUCT(STRUCT_sndrv_seq_queue_timer)) )
-//IOCTL( SNDRV_SEQ_IOCTL_GET_QUEUE_SYNC	, IOC_RW, MK_PTR(MK_STRUCT(STRUCT_sndrv_seq_queue_sync)) )
-//IOCTL( SNDRV_SEQ_IOCTL_SET_QUEUE_SYNC	, IOC_W, MK_PTR(MK_STRUCT(STRUCT_sndrv_seq_queue_sync)) )
-IOCTL( SNDRV_SEQ_IOCTL_GET_QUEUE_CLIENT	, IOC_RW, MK_PTR(MK_STRUCT(STRUCT_sndrv_seq_queue_client)) )
-IOCTL( SNDRV_SEQ_IOCTL_SET_QUEUE_CLIENT	, IOC_W, MK_PTR(MK_STRUCT(STRUCT_sndrv_seq_queue_client)) )
-IOCTL( SNDRV_SEQ_IOCTL_GET_CLIENT_POOL	, IOC_RW, MK_PTR(MK_STRUCT(STRUCT_sndrv_seq_client_pool)) )
-IOCTL( SNDRV_SEQ_IOCTL_SET_CLIENT_POOL	, IOC_W, MK_PTR(MK_STRUCT(STRUCT_sndrv_seq_client_pool)) )
-IOCTL( SNDRV_SEQ_IOCTL_REMOVE_EVENTS	, IOC_W, MK_PTR(MK_STRUCT(STRUCT_sndrv_seq_remove_events)) )
-IOCTL( SNDRV_SEQ_IOCTL_QUERY_SUBS	, IOC_RW, MK_PTR(MK_STRUCT(STRUCT_sndrv_seq_query_subs)) )
-IOCTL( SNDRV_SEQ_IOCTL_GET_SUBSCRIPTION	, IOC_RW, MK_PTR(MK_STRUCT(STRUCT_sndrv_seq_port_subscribe)) )
-IOCTL( SNDRV_SEQ_IOCTL_QUERY_NEXT_CLIENT	, IOC_RW, MK_PTR(MK_STRUCT(STRUCT_sndrv_seq_client_info)) )
-IOCTL( SNDRV_SEQ_IOCTL_QUERY_NEXT_PORT	, IOC_RW, MK_PTR(MK_STRUCT(STRUCT_sndrv_seq_port_info)) )
-IOCTL( SNDRV_DM_FM_IOCTL_INFO		, IOC_R, MK_PTR(MK_STRUCT(STRUCT_snd_dm_fm_info)) )
-IOCTL( SNDRV_DM_FM_IOCTL_RESET		, 0, TYPE_NULL )
-IOCTL( SNDRV_DM_FM_IOCTL_PLAY_NOTE	, IOC_W, MK_PTR(MK_STRUCT(STRUCT_snd_dm_fm_note)) )
-IOCTL( SNDRV_DM_FM_IOCTL_SET_VOICE	, IOC_W, MK_PTR(MK_STRUCT(STRUCT_snd_dm_fm_voice)) )
-IOCTL( SNDRV_DM_FM_IOCTL_SET_PARAMS	, IOC_W, MK_PTR(MK_STRUCT(STRUCT_snd_dm_fm_params)) )
-IOCTL( SNDRV_DM_FM_IOCTL_SET_MODE	, IOC_W, MK_PTR(TYPE_INT) )
-IOCTL( SNDRV_DM_FM_IOCTL_SET_CONNECTION	, IOC_W, MK_PTR(TYPE_INT) )
-IOCTL( SNDRV_HWDEP_IOCTL_PVERSION , IOC_R, MK_PTR(TYPE_INT) )
-IOCTL( SNDRV_HWDEP_IOCTL_INFO , IOC_R, MK_PTR(MK_STRUCT(STRUCT_sndrv_hwdep_info)) )
-IOCTL( SNDRV_HWDEP_IOCTL_DSP_STATUS , IOC_R, MK_PTR(MK_STRUCT(STRUCT_sndrv_hwdep_dsp_status)) )
-IOCTL( SNDRV_HWDEP_IOCTL_DSP_LOAD   , IOC_W, MK_PTR(MK_STRUCT(STRUCT_sndrv_hwdep_dsp_image)) )
-IOCTL( SNDRV_PCM_IOCTL_PVERSION , IOC_R, MK_PTR(TYPE_INT) )
-IOCTL( SNDRV_PCM_IOCTL_INFO , IOC_R, MK_PTR(MK_STRUCT(STRUCT_sndrv_pcm_info)) )
-IOCTL( SNDRV_PCM_IOCTL_TSTAMP , IOC_W, MK_PTR(TYPE_INT) )
-IOCTL( SNDRV_PCM_IOCTL_HW_REFINE , IOC_RW, MK_PTR(MK_STRUCT(STRUCT_sndrv_pcm_hw_params)) )
-IOCTL( SNDRV_PCM_IOCTL_HW_PARAMS , IOC_RW, MK_PTR(MK_STRUCT(STRUCT_sndrv_pcm_hw_params)) )
-IOCTL( SNDRV_PCM_IOCTL_HW_FREE , 0, TYPE_NULL )
-IOCTL( SNDRV_PCM_IOCTL_SW_PARAMS , IOC_RW, MK_PTR(MK_STRUCT(STRUCT_sndrv_pcm_sw_params)) )
-IOCTL( SNDRV_PCM_IOCTL_STATUS , IOC_R, MK_PTR(MK_STRUCT(STRUCT_sndrv_pcm_status)) )
-IOCTL( SNDRV_PCM_IOCTL_DELAY , IOC_R, MK_PTR(MK_STRUCT(STRUCT_sndrv_pcm_sframes)) )
-IOCTL( SNDRV_PCM_IOCTL_HWSYNC , 0, TYPE_NULL )
-IOCTL( SNDRV_PCM_IOCTL_SYNC_PTR , IOC_RW, MK_PTR(MK_STRUCT(STRUCT_sndrv_pcm_sync_ptr)) )
-IOCTL( SNDRV_PCM_IOCTL_CHANNEL_INFO , IOC_R, MK_PTR(MK_STRUCT(STRUCT_sndrv_pcm_channel_info)) )
-IOCTL( SNDRV_PCM_IOCTL_PREPARE , 0, TYPE_NULL )
-IOCTL( SNDRV_PCM_IOCTL_RESET , 0, TYPE_NULL )
-IOCTL( SNDRV_PCM_IOCTL_START , 0, TYPE_NULL )
-IOCTL( SNDRV_PCM_IOCTL_DROP , 0, TYPE_NULL )
-IOCTL( SNDRV_PCM_IOCTL_DRAIN , 0, TYPE_NULL )
-IOCTL( SNDRV_PCM_IOCTL_PAUSE , IOC_W, MK_PTR(TYPE_INT) )
-IOCTL( SNDRV_PCM_IOCTL_REWIND , IOC_W, MK_PTR(MK_STRUCT(STRUCT_sndrv_pcm_uframes)) )
-IOCTL( SNDRV_PCM_IOCTL_RESUME , 0, TYPE_NULL )
-IOCTL( SNDRV_PCM_IOCTL_XRUN , 0, TYPE_NULL )
-IOCTL( SNDRV_PCM_IOCTL_FORWARD , IOC_W, MK_PTR(MK_STRUCT(STRUCT_sndrv_pcm_uframes)) )
-IOCTL( SNDRV_PCM_IOCTL_WRITEI_FRAMES , IOC_W, MK_PTR(MK_STRUCT(STRUCT_sndrv_xferi)) )
-IOCTL( SNDRV_PCM_IOCTL_READI_FRAMES , IOC_R, MK_PTR(MK_STRUCT(STRUCT_sndrv_xferi)) )
-IOCTL( SNDRV_PCM_IOCTL_WRITEN_FRAMES , IOC_W, MK_PTR(MK_STRUCT(STRUCT_sndrv_xfern)) )
-IOCTL( SNDRV_PCM_IOCTL_READN_FRAMES , IOC_R, MK_PTR(MK_STRUCT(STRUCT_sndrv_xfern)) )
-IOCTL( SNDRV_PCM_IOCTL_LINK , IOC_W, MK_PTR(TYPE_INT) )
-IOCTL( SNDRV_PCM_IOCTL_UNLINK , 0, TYPE_NULL )
-IOCTL( SNDRV_RAWMIDI_IOCTL_PVERSION , IOC_R, MK_PTR(TYPE_INT) )
-IOCTL( SNDRV_RAWMIDI_IOCTL_INFO , IOC_R, MK_PTR(MK_STRUCT(STRUCT_sndrv_rawmidi_info)) )
-IOCTL( SNDRV_RAWMIDI_IOCTL_PARAMS , IOC_RW, MK_PTR(MK_STRUCT(STRUCT_sndrv_rawmidi_params)) )
-IOCTL( SNDRV_RAWMIDI_IOCTL_STATUS , IOC_RW, MK_PTR(MK_STRUCT(STRUCT_sndrv_rawmidi_status)) )
-IOCTL( SNDRV_RAWMIDI_IOCTL_DROP , IOC_W, MK_PTR(TYPE_INT) )
-IOCTL( SNDRV_RAWMIDI_IOCTL_DRAIN , IOC_W, MK_PTR(TYPE_INT) )
-IOCTL( SNDRV_TIMER_IOCTL_PVERSION , IOC_R, MK_PTR(TYPE_INT) )
-IOCTL( SNDRV_TIMER_IOCTL_NEXT_DEVICE , IOC_RW, MK_PTR(MK_STRUCT(STRUCT_sndrv_timer_id)) )
-IOCTL( SNDRV_TIMER_IOCTL_TREAD , IOC_W, MK_PTR(TYPE_INT) )
-IOCTL( SNDRV_TIMER_IOCTL_GINFO , IOC_RW, MK_PTR(MK_STRUCT(STRUCT_sndrv_timer_ginfo)) )
-IOCTL( SNDRV_TIMER_IOCTL_GPARAMS , IOC_W, MK_PTR(MK_STRUCT(STRUCT_sndrv_timer_gparams)) )
-IOCTL( SNDRV_TIMER_IOCTL_GSTATUS , IOC_RW, MK_PTR(MK_STRUCT(STRUCT_sndrv_timer_gstatus)) )
-IOCTL( SNDRV_TIMER_IOCTL_SELECT , IOC_W, MK_PTR(MK_STRUCT(STRUCT_sndrv_timer_select)) )
-IOCTL( SNDRV_TIMER_IOCTL_INFO , IOC_R, MK_PTR(MK_STRUCT(STRUCT_sndrv_timer_info)) )
-IOCTL( SNDRV_TIMER_IOCTL_PARAMS , IOC_W, MK_PTR(MK_STRUCT(STRUCT_sndrv_timer_params)) )
-IOCTL( SNDRV_TIMER_IOCTL_STATUS , IOC_R, MK_PTR(MK_STRUCT(STRUCT_sndrv_timer_status)) )
-IOCTL( SNDRV_TIMER_IOCTL_START , 0, TYPE_NULL )
-IOCTL( SNDRV_TIMER_IOCTL_STOP , 0, TYPE_NULL )
-IOCTL( SNDRV_TIMER_IOCTL_CONTINUE , 0, TYPE_NULL )
-IOCTL( SNDRV_TIMER_IOCTL_PAUSE , 0, TYPE_NULL )
-IOCTL( SNDRV_CTL_IOCTL_PVERSION , IOC_R, MK_PTR(TYPE_INT) )
-IOCTL( SNDRV_CTL_IOCTL_CARD_INFO , IOC_R, MK_PTR(MK_STRUCT(STRUCT_sndrv_ctl_card_info)) )
-IOCTL( SNDRV_CTL_IOCTL_ELEM_LIST , IOC_RW, MK_PTR(MK_STRUCT(STRUCT_sndrv_ctl_elem_list)) )
-IOCTL( SNDRV_CTL_IOCTL_ELEM_INFO , IOC_RW, MK_PTR(MK_STRUCT(STRUCT_sndrv_ctl_elem_info)) )
-IOCTL( SNDRV_CTL_IOCTL_ELEM_READ , IOC_RW, MK_PTR(MK_STRUCT(STRUCT_sndrv_ctl_elem_value)) )
-IOCTL( SNDRV_CTL_IOCTL_ELEM_WRITE , IOC_RW, MK_PTR(MK_STRUCT(STRUCT_sndrv_ctl_elem_value)) )
-IOCTL( SNDRV_CTL_IOCTL_ELEM_LOCK , IOC_W, MK_PTR(MK_STRUCT(STRUCT_sndrv_ctl_elem_id)) )
-IOCTL( SNDRV_CTL_IOCTL_ELEM_UNLOCK , IOC_W, MK_PTR(MK_STRUCT(STRUCT_sndrv_ctl_elem_id)) )
-IOCTL( SNDRV_CTL_IOCTL_SUBSCRIBE_EVENTS , IOC_RW, MK_PTR(TYPE_INT) )
-IOCTL( SNDRV_CTL_IOCTL_ELEM_ADD , IOC_RW, MK_PTR(MK_STRUCT(STRUCT_sndrv_ctl_elem_info)) )
-IOCTL( SNDRV_CTL_IOCTL_ELEM_REPLACE , IOC_RW, MK_PTR(MK_STRUCT(STRUCT_sndrv_ctl_elem_info)) )
-IOCTL( SNDRV_CTL_IOCTL_ELEM_REMOVE , IOC_RW, MK_PTR(MK_STRUCT(STRUCT_sndrv_ctl_elem_id)) )
-IOCTL( SNDRV_CTL_IOCTL_TLV_READ , IOC_RW, MK_PTR(MK_STRUCT(STRUCT_sndrv_ctl_tlv)) )
-IOCTL( SNDRV_CTL_IOCTL_TLV_WRITE , IOC_RW, MK_PTR(MK_STRUCT(STRUCT_sndrv_ctl_tlv)) )
-IOCTL( SNDRV_CTL_IOCTL_TLV_COMMAND , IOC_RW, MK_PTR(MK_STRUCT(STRUCT_sndrv_ctl_tlv)) )
-IOCTL( SNDRV_CTL_IOCTL_HWDEP_NEXT_DEVICE , IOC_RW, MK_PTR(TYPE_INT) )
-IOCTL( SNDRV_CTL_IOCTL_HWDEP_INFO , IOC_R, MK_PTR(MK_STRUCT(STRUCT_sndrv_hwdep_info)) )
-IOCTL( SNDRV_CTL_IOCTL_PCM_NEXT_DEVICE , IOC_R, MK_PTR(TYPE_INT) )
-IOCTL( SNDRV_CTL_IOCTL_PCM_INFO , IOC_RW, MK_PTR(MK_STRUCT(STRUCT_sndrv_pcm_info)) )
-IOCTL( SNDRV_CTL_IOCTL_PCM_PREFER_SUBDEVICE , IOC_W, MK_PTR(TYPE_INT) )
-IOCTL( SNDRV_CTL_IOCTL_RAWMIDI_NEXT_DEVICE , IOC_RW, MK_PTR(TYPE_INT) )
-IOCTL( SNDRV_CTL_IOCTL_RAWMIDI_INFO , IOC_RW, MK_PTR(MK_STRUCT(STRUCT_sndrv_rawmidi_info)) )
-IOCTL( SNDRV_CTL_IOCTL_RAWMIDI_PREFER_SUBDEVICE , IOC_W, MK_PTR(TYPE_INT) )
-IOCTL( SNDRV_CTL_IOCTL_POWER , IOC_RW, MK_PTR(TYPE_INT) )
-IOCTL( SNDRV_CTL_IOCTL_POWER_STATE , IOC_R, MK_PTR(TYPE_INT) )
-IOCTL( SNDRV_IOCTL_READV , IOC_W, MK_PTR(MK_STRUCT(STRUCT_sndrv_xferv)) )
-IOCTL( SNDRV_IOCTL_WRITEV , IOC_W, MK_PTR(MK_STRUCT(STRUCT_sndrv_xferv)) )
-IOCTL( SNDRV_EMU10K1_IOCTL_INFO	, IOC_R, MK_PTR(MK_STRUCT(STRUCT_emu10k1_fx8010_info)) )
-IOCTL( SNDRV_EMU10K1_IOCTL_CODE_POKE	, IOC_W, MK_PTR(MK_STRUCT(STRUCT_emu10k1_fx8010_code)) )
-IOCTL( SNDRV_EMU10K1_IOCTL_CODE_PEEK	, IOC_RW, MK_PTR(MK_STRUCT(STRUCT_emu10k1_fx8010_code)) )
-IOCTL( SNDRV_EMU10K1_IOCTL_TRAM_SETUP	, IOC_W, MK_PTR(TYPE_INT) )
-IOCTL( SNDRV_EMU10K1_IOCTL_TRAM_POKE	, IOC_W, MK_PTR(MK_STRUCT(STRUCT_emu10k1_fx8010_tram)) )
-IOCTL( SNDRV_EMU10K1_IOCTL_TRAM_PEEK	, IOC_RW, MK_PTR(MK_STRUCT(STRUCT_emu10k1_fx8010_tram)) )
-IOCTL( SNDRV_EMU10K1_IOCTL_PCM_POKE	, IOC_W, MK_PTR(MK_STRUCT(STRUCT_emu10k1_fx8010_pcm)) )
-IOCTL( SNDRV_EMU10K1_IOCTL_PCM_PEEK	, IOC_RW, MK_PTR(MK_STRUCT(STRUCT_emu10k1_fx8010_pcm)) )
-IOCTL( SNDRV_EMU10K1_IOCTL_PVERSION	, IOC_R, MK_PTR(TYPE_INT) )
-IOCTL( SNDRV_EMU10K1_IOCTL_STOP	, 0, TYPE_NULL )
-IOCTL( SNDRV_EMU10K1_IOCTL_CONTINUE	, 0, TYPE_NULL )
-IOCTL( SNDRV_EMU10K1_IOCTL_ZERO_TRAM_COUNTER , 0, TYPE_NULL )
-IOCTL( SNDRV_EMU10K1_IOCTL_SINGLE_STEP	, IOC_W, MK_PTR(TYPE_INT) )
-IOCTL( SNDRV_EMU10K1_IOCTL_DBG_READ	, IOC_R, MK_PTR(TYPE_INT) )
-IOCTL( SNDRV_HDSP_IOCTL_GET_PEAK_RMS , IOC_R, MK_PTR(MK_STRUCT(STRUCT_hdsp_peak_rms)) )
-IOCTL( SNDRV_HDSP_IOCTL_GET_CONFIG_INFO , IOC_R, MK_PTR(MK_STRUCT(STRUCT_hdsp_config_info)) )
-IOCTL( SNDRV_HDSP_IOCTL_UPLOAD_FIRMWARE , IOC_W, MK_PTR(MK_STRUCT(STRUCT_hdsp_firmware)) )
-IOCTL( SNDRV_HDSP_IOCTL_GET_VERSION , IOC_R, MK_PTR(MK_STRUCT(STRUCT_hdsp_version)) )
-IOCTL( SNDRV_HDSP_IOCTL_GET_MIXER , IOC_R, MK_PTR(MK_STRUCT(STRUCT_hdsp_mixer)) )
-IOCTL( SNDRV_HDSP_IOCTL_GET_9632_AEB , IOC_R, MK_PTR(MK_STRUCT(STRUCT_hdsp_9632_aeb)) )
-IOCTL( SNDRV_SB_CSP_IOCTL_INFO		, IOC_R, MK_PTR(MK_STRUCT(STRUCT_snd_sb_csp_info)) )
-#if _IOC_SIZEBITS > 13
-IOCTL( SNDRV_SB_CSP_IOCTL_LOAD_CODE	, IOC_W, MK_PTR(MK_STRUCT(STRUCT_snd_sb_csp_microcode)) )
-#endif
-IOCTL( SNDRV_SB_CSP_IOCTL_UNLOAD_CODE	, 0, TYPE_NULL )
-IOCTL( SNDRV_SB_CSP_IOCTL_START	, IOC_W, MK_PTR(MK_STRUCT(STRUCT_snd_sb_csp_start)) )
-IOCTL( SNDRV_SB_CSP_IOCTL_STOP		, 0, TYPE_NULL )
-IOCTL( SNDRV_SB_CSP_IOCTL_PAUSE	, 0, TYPE_NULL )
-IOCTL( SNDRV_SB_CSP_IOCTL_RESTART	, 0, TYPE_NULL )
-IOCTL( SND_SSCAPE_LOAD_BOOTB  , IOC_RW, MK_PTR(MK_STRUCT(STRUCT_sscape_bootblock)) )
-IOCTL( SND_SSCAPE_LOAD_MCODE  , IOC_W, MK_PTR(MK_STRUCT(STRUCT_sscape_microcode)) )
--- a/linux-user/ioctls_alsa_structs.h
+++ b/linux-user/ioctls_alsa_structs.h
--- a/linux-user/linux_loop.h
+++ b/linux-user/linux_loop.h
@@ -91,6 +91,5 @@ struct loop_info64 {
 #define LOOP_SET_STATUS64	0x4C04
 #define LOOP_GET_STATUS64	0x4C05
 #define LOOP_CHANGE_FD		0x4C06
-#define LOOP_BOGUS_CMD		0x4C82

 #endif
--- a/linux-user/m68k/syscall_nr.h
+++ b/linux-user/m68k/syscall_nr.h
@@ -344,8 +344,3 @@
 #define TARGET_NR_open_by_handle_at     341
 #define TARGET_NR_clock_adjtime         342
 #define TARGET_NR_syncfs                343
-#define TARGET_NR_setns                 344
-#define TARGET_NR_process_vm_readv      345
-#define TARGET_NR_process_vm_writev     346
-#define TARGET_NR_kcmp                  347
-#define TARGET_NR_finit_module          348
--- a/linux-user/main.c
+++ b/linux-user/main.c
@@ -810,22 +810,15 @@ void cpu_loop(CPUARMState *env)
                            break;
                        }
                    } else {
-                        TaskState *ts = ((CPUArchState*)env)->opaque;
-                        target_ulong r;
-                        r = do_syscall(env, n, env->regs[0], env->regs[1],
-                                       env->regs[2], env->regs[3], env->regs[4],
-                                       env->regs[5], 0, 0);
-                        if ((r == -EINTR) && ts->signal_restart &&
-                            syscall_restartable(n)) {
-                            if (env->thumb) {
-                                env->regs[15] -= 2;
-                            } else {
-                                env->regs[15] -= 4;
-                            }
-                        } else {
-                            env->regs[0] = r;
-                        }
-                        ts->signal_restart = 0;
+                        env->regs[0] = do_syscall(env,
+                                                  n,
+                                                  env->regs[0],
+                                                  env->regs[1],
+                                                  env->regs[2],
+                                                  env->regs[3],
+                                                  env->regs[4],
+                                                  env->regs[5],
+                                                  0, 0);
                    }
                } else {
                    goto error;
--- a/linux-user/microblaze/syscall_nr.h
+++ b/linux-user/microblaze/syscall_nr.h
@@ -376,9 +376,4 @@
 #define TARGET_NR_open_by_handle_at     372
 #define TARGET_NR_clock_adjtime         373
 #define TARGET_NR_syncfs                374
-#define TARGET_NR_setns                 375
-#define TARGET_NR_sendmmsg              376
-#define TARGET_NR_process_vm_readv      377
-#define TARGET_NR_process_vm_writev     378
-#define TARGET_NR_kcmp                  379
-#define TARGET_NR_finit_module          380
+
--- a/linux-user/mips/syscall_nr.h
+++ b/linux-user/mips/syscall_nr.h
@@ -345,9 +345,3 @@
 #define TARGET_NR_open_by_handle_at     (TARGET_NR_Linux + 340)
 #define TARGET_NR_clock_adjtime         (TARGET_NR_Linux + 341)
 #define TARGET_NR_syncfs                (TARGET_NR_Linux + 342)
-#define TARGET_NR_sendmmsg              (TARGET_NR_Linux + 343)
-#define TARGET_NR_setns                 (TARGET_NR_Linux + 344)
-#define TARGET_NR_process_vm_readv      (TARGET_NR_Linux + 345)
-#define TARGET_NR_process_vm_writev     (TARGET_NR_Linux + 346)
-#define TARGET_NR_kcmp                  (TARGET_NR_Linux + 347)
-#define TARGET_NR_finit_module          (TARGET_NR_Linux + 348)
--- a/linux-user/mips64/syscall_nr.h
+++ b/linux-user/mips64/syscall_nr.h
@@ -310,12 +310,6 @@
 #define TARGET_NR_open_by_handle_at     (TARGET_NR_Linux + 304)
 #define TARGET_NR_clock_adjtime         (TARGET_NR_Linux + 305)
 #define TARGET_NR_syncfs                (TARGET_NR_Linux + 306)
-#define TARGET_NR_sendmmsg              (TARGET_NR_Linux + 307)
-#define TARGET_NR_setns                 (TARGET_NR_Linux + 308)
-#define TARGET_NR_process_vm_readv      (TARGET_NR_Linux + 309)
-#define TARGET_NR_process_vm_writev     (TARGET_NR_Linux + 310)
-#define TARGET_NR_kcmp                  (TARGET_NR_Linux + 311)
-#define TARGET_NR_finit_module          (TARGET_NR_Linux + 312)
 #else
 /*
 * Linux 64-bit syscalls are in the range from 5000 to 5999.
@@ -623,11 +617,4 @@
 #define TARGET_NR_open_by_handle_at     (TARGET_NR_Linux + 299)
 #define TARGET_NR_clock_adjtime         (TARGET_NR_Linux + 300)
 #define TARGET_NR_syncfs                (TARGET_NR_Linux + 301)
-#define TARGET_NR_sendmmsg              (TARGET_NR_Linux + 302)
-#define TARGET_NR_setns                 (TARGET_NR_Linux + 303)
-#define TARGET_NR_process_vm_readv      (TARGET_NR_Linux + 304)
-#define TARGET_NR_process_vm_writev     (TARGET_NR_Linux + 305)
-#define TARGET_NR_kcmp                  (TARGET_NR_Linux + 306)
-#define TARGET_NR_finit_module          (TARGET_NR_Linux + 307)
-#define TARGET_NR_getdents64            (TARGET_NR_Linux + 308)
 #endif
--- a/linux-user/mmap.c
+++ b/linux-user/mmap.c
@@ -30,7 +30,6 @@

 #include "qemu.h"
 #include "qemu-common.h"
-#include "tcg.h"

 //#define DEBUG_MMAP

@@ -41,7 +40,6 @@ void mmap_lock(void)
 {
    if (mmap_lock_count++ == 0) {
        pthread_mutex_lock(&mmap_mutex);
-        tcg_lock();
    }
 }

@@ -49,7 +47,6 @@ void mmap_unlock(void)
 {
    if (--mmap_lock_count == 0) {
        pthread_mutex_unlock(&mmap_mutex);
-        tcg_unlock();
    }
 }

@@ -369,9 +366,6 @@ abi_ulong mmap_find_vma(abi_ulong start, abi_ulong size)
    }
 }

-#define SNDRV_PCM_MMAP_OFFSET_STATUS  0x80000000
-#define SNDRV_PCM_MMAP_OFFSET_CONTROL 0x81000000
-
 /* NOTE: all the constants are the HOST ones */
 abi_long target_mmap(abi_ulong start, abi_ulong len, int prot,
                     int flags, int fd, abi_ulong offset)
@@ -406,17 +400,6 @@ abi_long target_mmap(abi_ulong start, abi_ulong len, int prot,
    }
 #endif

-    /* Alsa tries to communcate with the kernel via mmap. This usually
-     * is a good idea when user- and kernelspace are running on the
-     * same architecture but does not work out when not. To make alsa
-     * not to use mmap, we can just have it fail on the mmap calls that
-     * would initiate this.
-     */
-    if(offset == SNDRV_PCM_MMAP_OFFSET_STATUS || offset == SNDRV_PCM_MMAP_OFFSET_CONTROL) {
-	errno = EINVAL;
-	return -1;
-    }
-
    if (offset & ~TARGET_PAGE_MASK) {
        errno = EINVAL;
        goto fail;
--- a/linux-user/openrisc/syscall_nr.h
+++ b/linux-user/openrisc/syscall_nr.h
@@ -378,13 +378,9 @@
 #define TARGET_NR_syncfs 267
 #define TARGET_NR_setns 268
 #define TARGET_NR_sendmmsg 269
-#define TARGET_NR_process_vm_readv 270
-#define TARGET_NR_process_vm_writev 271
-#define TARGET_NR_kcmp 272
-#define TARGET_NR_finit_module 273

 #undef TARGET_NR_syscalls
-#define TARGET_NR_syscalls 274
+#define TARGET_NR_syscalls 270

 /*
 * All syscalls below here should go away really,
--- a/linux-user/ppc/syscall_nr.h
+++ b/linux-user/ppc/syscall_nr.h
@@ -362,9 +362,3 @@
 #define TARGET_NR_open_by_handle_at     346
 #define TARGET_NR_clock_adjtime         347
 #define TARGET_NR_syncfs                348
-#define TARGET_NR_sendmmsg              349
-#define TARGET_NR_setns                 350
-#define TARGET_NR_process_vm_readv      351
-#define TARGET_NR_process_vm_writev     352
-#define TARGET_NR_finit_module          353
-#define TARGET_NR_kcmp                  354
--- a/linux-user/qemu.h
+++ b/linux-user/qemu.h
@@ -133,8 +133,6 @@ typedef struct TaskState {
    struct sigqueue sigqueue_table[MAX_SIGQUEUE_SIZE]; /* siginfo queue */
    struct sigqueue *first_free; /* first free siginfo queue entry */
    int signal_pending; /* non zero if a signal may be pending */
-    int signal_in_syscall; /* non zero if we are in do_syscall() */
-    int signal_restart; /* non zero if we need to restart a syscall */
 } __attribute__((aligned(16))) TaskState;

 extern char *exec_path;
@@ -190,10 +188,10 @@ abi_long memcpy_to_target(abi_ulong dest, const void *src,
 void target_set_brk(abi_ulong new_brk);
 abi_long do_brk(abi_ulong new_brk);
 void syscall_init(void);
-abi_long do_syscall(void *cpu_env, int num, abi_ulong arg1,
-                    abi_ulong arg2, abi_ulong arg3, abi_ulong arg4,
-                    abi_ulong arg5, abi_ulong arg6, abi_ulong arg7,
-                    abi_ulong arg8);
+abi_long do_syscall(void *cpu_env, int num, abi_long arg1,
+                    abi_long arg2, abi_long arg3, abi_long arg4,
+                    abi_long arg5, abi_long arg6, abi_long arg7,
+                    abi_long arg8);
 void gemu_log(const char *fmt, ...) GCC_FMT_ATTR(1, 2);
 extern THREAD CPUState *thread_cpu;
 void cpu_loop(CPUArchState *env);
@@ -202,7 +200,6 @@ int get_osversion(void);
 void init_qemu_uname_release(void);
 void fork_start(void);
 void fork_end(int child);
-int syscall_restartable(int syscall_nr);

 /* Creates the initial guest address space in the host memory space using
 * the given host start address hint and size.  The guest_start parameter
--- a/linux-user/s390x/syscall_nr.h
+++ b/linux-user/s390x/syscall_nr.h
@@ -265,12 +265,6 @@
 #define TARGET_NR_open_by_handle_at     336
 #define TARGET_NR_clock_adjtime         337
 #define TARGET_NR_syncfs                338
-#define TARGET_NR_setns                 339
-#define TARGET_NR_process_vm_readv      340
-#define TARGET_NR_process_vm_writev     341
-#define TARGET_NR_s390_runtime_instr    342
-#define TARGET_NR_kcmp                  343
-#define TARGET_NR_finit_module          344

 /*
 * There are some system calls that are not present on 64 bit, some
@@ -361,3 +355,4 @@
 #define TARGET_NR_newfstatat		293

 #endif
+
--- a/linux-user/sh4/syscall_nr.h
+++ b/linux-user/sh4/syscall_nr.h
@@ -366,9 +366,3 @@
 #define TARGET_NR_open_by_handle_at     360
 #define TARGET_NR_clock_adjtime         361
 #define TARGET_NR_syncfs                362
-#define TARGET_NR_sendmmsg              363
-#define TARGET_NR_setns                 364
-#define TARGET_NR_process_vm_readv      365
-#define TARGET_NR_process_vm_writev     366
-#define TARGET_NR_kcmp                  367
-#define TARGET_NR_finit_module          368
--- a/linux-user/signal.c
+++ b/linux-user/signal.c
@@ -25,7 +25,6 @@
 #include <assert.h>
 #include <sys/ucontext.h>
 #include <sys/resource.h>
-#include <sched.h>

 #include "qemu.h"
 #include "qemu-common.h"
@@ -396,10 +395,6 @@ static void QEMU_NORETURN force_sig(int target_sig)
    host_sig = target_to_host_signal(target_sig);
    gdb_signalled(env, target_sig);

-    if (target_sig == 6) {
-        goto no_core;
-    }
-
    /* dump core if supported by target binary format */
    if (core_dump_signal(target_sig) && (ts->bprm->core_dump != NULL)) {
        stop_all_tasks();
@@ -417,8 +412,6 @@ static void QEMU_NORETURN force_sig(int target_sig)
            target_sig, strsignal(host_sig), "core dumped" );
    }

-no_core:
-
    /* The proper exit code for dying from an uncaught signal is
     * -<signal>.  The kernel doesn't allow exit() or _exit() to pass
     * a negative value.  To get the proper exit code we need to
@@ -504,11 +497,6 @@ int queue_signal(CPUArchState *env, int sig, target_siginfo_t *info)
        k->pending = 1;
        /* signal that a new signal is pending */
        ts->signal_pending = 1;
-        /* check if we have to restart the current syscall */
-        if ((sigact_table[sig - 1].sa_flags & SA_RESTART) &&
-            ts->signal_in_syscall) {
-            ts->signal_restart = 1;
-        }
        return 1; /* indicates that the signal was queued */
    }
 }
@@ -644,24 +632,8 @@ int do_sigaction(int sig, const struct target_sigaction *act,
        if (host_sig != SIGSEGV && host_sig != SIGBUS) {
            sigfillset(&act1.sa_mask);
            act1.sa_flags = SA_SIGINFO;
-#ifdef TARGET_ARM
-            /* Breaks boehm-gc, we have to do this manually */
-            /*
-             * Unfortunately our hacks only work as long as we don't do parallel
-             * signal delivery and futexes, so let's do a dirty hack here to
-             * pin our guest process to a single host CPU if we're using the
-             * boehm-gc.
-             */
-            if ((k->sa_flags & TARGET_SA_RESTART) && host_sig == SIGPWR) {
-                cpu_set_t mask;
-                CPU_ZERO(&mask);
-                CPU_SET(0, &mask);
-                sched_setaffinity(0, sizeof(mask), &mask);
-            }
-#else
            if (k->sa_flags & TARGET_SA_RESTART)
                act1.sa_flags |= SA_RESTART;
-#endif
            /* NOTE: it is important to update the host kernel signal
               ignore state to avoid getting unexpected interrupted
               syscalls */
--- a/linux-user/sparc/syscall_nr.h
+++ b/linux-user/sparc/syscall_nr.h
@@ -302,10 +302,3 @@
 #define TARGET_NR_open_by_handle_at     333
 #define TARGET_NR_clock_adjtime         334
 #define TARGET_NR_syncfs                335
-#define TARGET_NR_sendmmsg              336
-#define TARGET_NR_setns                 337
-#define TARGET_NR_process_vm_readv      338
-#define TARGET_NR_process_vm_writev     339
-#define TARGET_NR_kern_features         340
-#define TARGET_NR_kcmp                  341
-#define TARGET_NR_finit_module          342
--- a/linux-user/sparc64/syscall_nr.h
+++ b/linux-user/sparc64/syscall_nr.h
@@ -334,10 +334,3 @@
 #define TARGET_NR_open_by_handle_at     333
 #define TARGET_NR_clock_adjtime         334
 #define TARGET_NR_syncfs                335
-#define TARGET_NR_sendmmsg              336
-#define TARGET_NR_setns                 337
-#define TARGET_NR_process_vm_readv      338
-#define TARGET_NR_process_vm_writev     339
-#define TARGET_NR_kern_features         340
-#define TARGET_NR_kcmp                  341
-#define TARGET_NR_finit_module          342
--- a/linux-user/syscall.c
+++ b/linux-user/syscall.c
@@ -107,7 +107,6 @@ int __clone2(int (*fn)(void *), void *child_stack_base,
 #include <linux/reboot.h>
 #include <linux/route.h>
 #include <linux/filter.h>
-#include <linux/blkpg.h>
 #include "linux_loop.h"
 #include "cpu-uname.h"

@@ -3290,11 +3289,6 @@ static abi_long do_ioctl_fs_ioc_fiemap(const IOCTLEntry *ie, uint8_t *buf_temp,
    uint32_t outbufsz;
    int free_fm = 0;

-    if (1) {
-        /* XXX agraf: fiemap breaks for me */
-        return -TARGET_EINVAL;
-    }
-
    assert(arg_type[0] == TYPE_PTR);
    assert(ie->access == IOC_RW);
    arg_type++;
@@ -3738,13 +3732,6 @@ static abi_long do_ioctl_rt(const IOCTLEntry *ie, uint8_t *buf_temp,
    return ret;
 }

-static abi_long do_ioctl_fail(const IOCTLEntry *ie, uint8_t *buf_temp, int fd,
-                              abi_long cmd, abi_long arg)
-{
-    /* Fail silently */
-    return -EINVAL;
-}
-
 static IOCTLEntry ioctl_entries[] = {
 #define IOCTL(cmd, access, ...) \
    { TARGET_ ## cmd, cmd, #cmd, access, 0, {  __VA_ARGS__ } },
@@ -3768,12 +3755,7 @@ static abi_long do_ioctl(int fd, abi_long cmd, abi_long arg)
    ie = ioctl_entries;
    for(;;) {
        if (ie->target_cmd == 0) {
-	    int i;
-            gemu_log("Unsupported ioctl: cmd=0x%04lx (%x)\n", (unsigned long)cmd, (unsigned int)(cmd & (TARGET_IOC_SIZEMASK << TARGET_IOC_SIZESHIFT)) >> TARGET_IOC_SIZESHIFT);
-            for (i = 0; ioctl_entries[i].target_cmd; i++) {
-		if ((ioctl_entries[i].target_cmd & ~(TARGET_IOC_SIZEMASK << TARGET_IOC_SIZESHIFT)) == (cmd & ~(TARGET_IOC_SIZEMASK << TARGET_IOC_SIZESHIFT)))
-		    gemu_log("%p\t->\t%s (%x)\n", (void *)(unsigned long)ioctl_entries[i].host_cmd, ioctl_entries[i].name, (ioctl_entries[i].target_cmd & (TARGET_IOC_SIZEMASK << TARGET_IOC_SIZESHIFT)) >> TARGET_IOC_SIZESHIFT);
-	    }
+            gemu_log("Unsupported ioctl: cmd=0x%04lx\n", (long)cmd);
            return -TARGET_ENOSYS;
        }
        if (ie->target_cmd == cmd)
@@ -3802,11 +3784,6 @@ static abi_long do_ioctl(int fd, abi_long cmd, abi_long arg)
        arg_type++;
        target_size = thunk_type_size(arg_type, 0);
        switch(ie->access) {
-	/* FIXME: actually the direction given in the ioctl should be
-	 * correct so we can assume the communication is uni-directional.
-	 * The alsa developers did not like this concept though and
-	 * declared ioctls IOC_R and IOC_W even though they were IOC_RW.*/
-/*
        case IOC_R:
            ret = get_errno(ioctl(fd, ie->host_cmd, buf_temp));
            if (!is_error(ret)) {
@@ -3825,7 +3802,6 @@ static abi_long do_ioctl(int fd, abi_long cmd, abi_long arg)
            unlock_user(argptr, arg, 0);
            ret = get_errno(ioctl(fd, ie->host_cmd, buf_temp));
            break;
-*/
        default:
        case IOC_RW:
            argptr = lock_user(VERIFY_READ, arg, target_size, 1);
@@ -4438,15 +4414,6 @@ static int do_fork(CPUArchState *env, unsigned int flags, abi_ulong newsp,
        if (nptl_flags & CLONE_SETTLS)
            cpu_set_tls (new_env, newtls);

-        /* agraf: Pin ourselves to a single CPU when running multi-threaded.
-           This turned out to improve stability for me. */
-        {
-            cpu_set_t mask;
-            CPU_ZERO(&mask);
-            CPU_SET(0, &mask);
-            sched_setaffinity(0, sizeof(mask), &mask);
-        }
-
        /* Grab a mutex so that thread setup appears atomic.  */
        pthread_mutex_lock(&clone_lock);

@@ -5157,25 +5124,6 @@ static int open_self_stat(void *cpu_env, int fd)
    return 0;
 }

-static int open_cpuinfo(void *cpu_env, int fd)
-{
-    dprintf(fd,
-"Processor       : ARMv7 Processor rev 5 (v7l)\n"
-"BogoMIPS        : 799.53\n"
-"Features        : swp half thumb fastmult vfp edsp thumbee neon vfpv3\n"
-"CPU implementer : 0x41\n"
-"CPU architecture: 7\n"
-"CPU variant     : 0x2\n"
-"CPU part        : 0xc08\n"
-"CPU revision    : 5\n"
-"\n"
-"Hardware        : Genesi Efika MX (Smarttop)\n"
-"Revision        : 51030\n"
-"Serial          : 0000000000000000\n");
-
-    return 0;
-}
-
 static int open_self_auxv(void *cpu_env, int fd)
 {
    TaskState *ts = ((CPUArchState *)cpu_env)->opaque;
@@ -5288,7 +5236,6 @@ static int do_open(void *cpu_env, const char *pathname, int flags, mode_t mode)
 #if defined(HOST_WORDS_BIGENDIAN) != defined(TARGET_WORDS_BIGENDIAN)
        { "/proc/net/route", open_net_route, is_proc },
 #endif
-        { "cpuinfo", open_cpuinfo, is_proc_myself },
        { NULL, NULL, NULL }
    };

@@ -5326,106 +5273,19 @@ static int do_open(void *cpu_env, const char *pathname, int flags, mode_t mode)
    return get_errno(open(path(pathname), flags, mode));
 }

-int syscall_restartable(int syscall_nr)
-{
-    switch (syscall_nr) {
-#ifdef TARGET_NR_sigsuspend
-    case TARGET_NR_sigsuspend:
-#endif
-#ifdef TARGET_NR_pause
-    case TARGET_NR_pause:
-#endif
-#ifdef TARGET_NR_setsockopt
-    case TARGET_NR_setsockopt:
-#endif
-#ifdef TARGET_NR_accept
-    case TARGET_NR_accept:
-#endif
-#ifdef TARGET_NR_recv
-    case TARGET_NR_recv:
-#endif
-#ifdef TARGET_NR_recvfrom
-    case TARGET_NR_recvfrom:
-#endif
-#ifdef TARGET_NR_recvmsg
-    case TARGET_NR_recvmsg:
-#endif
-#ifdef TARGET_NR_socketcall
-    case TARGET_NR_socketcall:
-#endif
-#ifdef TARGET_NR_connect
-    case TARGET_NR_connect:
-#endif
-#ifdef TARGET_NR_send
-    case TARGET_NR_send:
-#endif
-#ifdef TARGET_NR_sendmsg
-    case TARGET_NR_sendmsg:
-#endif
-#ifdef TARGET_NR_sendto
-    case TARGET_NR_sendto:
-#endif
-#ifdef TARGET_NR_poll
-    case TARGET_NR_poll:
-#endif
-#ifdef TARGET_NR_ppoll
-    case TARGET_NR_ppoll:
-#endif
-#if defined(TARGET_NR_select)
-    case TARGET_NR_select:
-#endif
-#ifdef TARGET_NR_pselect6
-    case TARGET_NR_pselect6:
-#endif
-#ifdef TARGET_NR__newselect
-    case TARGET_NR__newselect:
-#endif
-#ifdef TARGET_NR_msgrcv
-    case TARGET_NR_msgrcv:
-#endif
-#ifdef TARGET_NR_msgsnd
-    case TARGET_NR_msgsnd:
-#endif
-#ifdef TARGET_NR_semop
-    case TARGET_NR_semop:
-#endif
-#ifdef TARGET_NR_ipc
-    case TARGET_NR_ipc:
-#endif
-#ifdef TARGET_NR_clock_nanosleep
-    case TARGET_NR_clock_nanosleep:
-#endif
-    case TARGET_NR_rt_sigsuspend:
-    case TARGET_NR_rt_sigtimedwait:
-    case TARGET_NR_nanosleep:
-    case TARGET_NR_close:
-        /* can not be restarted */
-        return 0;
-    }
-
-    /* every other syscall can be restarted */
-    return 1;
-}
-
 /* do_syscall() should always have a single exit point at the end so
   that actions, such as logging of syscall results, can be performed.
   All errnos that do_syscall() returns must be -TARGET_<errcode>. */
-abi_long do_syscall(void *cpu_env, int num, abi_ulong arg1,
-                    abi_ulong arg2, abi_ulong arg3, abi_ulong arg4,
-                    abi_ulong arg5, abi_ulong arg6, abi_ulong arg7,
-                    abi_ulong arg8)
+abi_long do_syscall(void *cpu_env, int num, abi_long arg1,
+                    abi_long arg2, abi_long arg3, abi_long arg4,
+                    abi_long arg5, abi_long arg6, abi_long arg7,
+                    abi_long arg8)
 {
    CPUState *cpu = ENV_GET_CPU(cpu_env);
    abi_long ret;
    struct stat st;
    struct statfs stfs;
    void *p;
-    TaskState *ts = ((CPUArchState*)cpu_env)->opaque;
-
-    if (!ts->signal_restart) {
-        /* remember syscall info for restart */
-        ts->signal_in_syscall = 1;
-    }

 #ifdef DEBUG
    gemu_log("syscall %d", num);
@@ -5724,14 +5584,9 @@ abi_long do_syscall(void *cpu_env, int num, abi_ulong arg1,
    case TARGET_NR_oldstat:
        goto unimplemented;
 #endif
-    case TARGET_NR_lseek: {
-        off_t off = arg2;
-        if (arg3 != SEEK_SET) {
-            off = (abi_long)arg2;
-        }
-        ret = get_errno(lseek(arg1, off, arg3));
+    case TARGET_NR_lseek:
+        ret = get_errno(lseek(arg1, arg2, arg3));
        break;
-    }
 #if defined(TARGET_NR_getxpid) && defined(TARGET_ALPHA)
    /* Alpha specific */
    case TARGET_NR_getxpid:
@@ -6469,8 +6324,6 @@ abi_long do_syscall(void *cpu_env, int num, abi_ulong arg1,
    case TARGET_NR_gettimeofday:
        {
            struct timeval tv;
-            if(copy_from_user_timeval(&tv, arg1))
-		goto efault;
            ret = get_errno(gettimeofday(&tv, NULL));
            if (!is_error(ret)) {
                if (copy_to_user_timeval(arg1, &tv))
@@ -7832,7 +7685,7 @@ abi_long do_syscall(void *cpu_env, int num, abi_ulong arg1,
        unlock_user(p, arg1, ret);
        break;
    case TARGET_NR_capget:
-        goto unimplemented_nowarn;
+        goto unimplemented;
    case TARGET_NR_capset:
        goto unimplemented;
    case TARGET_NR_sigaltstack:
@@ -8538,7 +8391,7 @@ abi_long do_syscall(void *cpu_env, int num, abi_ulong arg1,
 	cmd = target_to_host_fcntl_cmd(arg2);
        if (cmd == -TARGET_EINVAL) {
            ret = cmd;
-            goto fail;
+            break;
        }

        switch(arg2) {
@@ -8913,11 +8766,6 @@ abi_long do_syscall(void *cpu_env, int num, abi_ulong arg1,
        break;
 #endif

-#if defined(TARGET_NR_timer_create)
-    case TARGET_NR_timer_create:
-	goto unimplemented_nowarn;
-#endif
-
 #if defined(TARGET_NR_tkill) && defined(__NR_tkill)
    case TARGET_NR_tkill:
        ret = get_errno(sys_tkill((int)arg1, target_to_host_signal(arg2)));
@@ -9362,7 +9210,6 @@ fail:
 #endif
    if(do_strace)
        print_syscall_ret(num, ret);
-    ts->signal_in_syscall = 0;
    return ret;
 efault:
    ret = -TARGET_EFAULT;
--- a/linux-user/syscall_defs.h
+++ b/linux-user/syscall_defs.h
@@ -895,19 +895,12 @@ struct target_pollfd {
 #define TARGET_BLKSECTSET TARGET_IO(0x12,102)/* set max sectors per request (ll_rw_blk.c) */
 #define TARGET_BLKSECTGET TARGET_IO(0x12,103)/* get max sectors per request (ll_rw_blk.c) */
 #define TARGET_BLKSSZGET  TARGET_IO(0x12,104)/* get block device sector size */
-#define TARGET_BLKPG      TARGET_IO(0x12,105)/* Partition table and disk geometry handling */
 /* A jump here: 108-111 have been used for various private purposes. */
 #define TARGET_BLKBSZGET  TARGET_IOR(0x12, 112, abi_ulong)
 #define TARGET_BLKBSZSET  TARGET_IOW(0x12, 113, abi_ulong)
 #define TARGET_BLKGETSIZE64 TARGET_IOR(0x12,114,abi_ulong)
                                             /* return device size in bytes
                                                (u64 *arg) */
-#define TARGET_BLKDISCARD TARGET_IO(0x12,119)
-#define TARGET_BLKIOMIN TARGET_IO(0x12,120)
-#define TARGET_BLKIOOPT TARGET_IO(0x12,121)
-#define TARGET_BLKALIGNOFF TARGET_IO(0x12,122)
-#define TARGET_BLKPBSZGET TARGET_IO(0x12,123)
-#define TARGET_BLKDISCARDZEROES TARGET_IO(0x12,124)
 #define TARGET_FIBMAP     TARGET_IO(0x00,1)  /* bmap access */
 #define TARGET_FIGETBSZ   TARGET_IO(0x00,2)  /* get the block size used for bmap */
 #define TARGET_FS_IOC_FIEMAP TARGET_IOWR('f',11,struct fiemap)
@@ -1039,7 +1032,6 @@ struct target_pollfd {
 #define TARGET_LOOP_SET_STATUS64      0x4C04
 #define TARGET_LOOP_GET_STATUS64      0x4C05
 #define TARGET_LOOP_CHANGE_FD         0x4C06
-#define TARGET_LOOP_BOGUS_CMD         0x4C82

 /* fb ioctls */
 #define TARGET_FBIOGET_VSCREENINFO    0x4600
@@ -2448,9 +2440,6 @@ struct target_eabi_flock64 {
 #define TARGET_MTIOCGET        TARGET_IOR('m', 2, struct mtget)
 #define TARGET_MTIOCPOS        TARGET_IOR('m', 3, struct mtpos)

-#define TARGET_FS_IOC_GETFLAGS TARGET_IORU('f', 1)
-#define TARGET_FS_IOC_SETFLAGS TARGET_IOWU('f', 2)
-
 struct target_sysinfo {
    abi_long uptime;                /* Seconds since boot */
    abi_ulong loads[3];             /* 1, 5, and 15 minute load averages */
@@ -2537,6 +2526,4 @@ struct target_ucred {
    uint32_t gid;
 };

-#include "ioctls_alsa_structs.h"
-
 #endif
--- a/linux-user/syscall_types.h
+++ b/linux-user/syscall_types.h
@@ -71,9 +71,6 @@ STRUCT(kbentry,
 STRUCT(kbsentry,
       TYPE_CHAR, MK_ARRAY(TYPE_CHAR, 512))

-STRUCT(blkdiscard,
-       MK_ARRAY(TYPE_LONGLONG, 2))
-
 STRUCT(audio_buf_info,
       TYPE_INT, TYPE_INT, TYPE_INT, TYPE_INT)

@@ -86,11 +83,6 @@ STRUCT(buffmem_desc,
 STRUCT(mixer_info,
       MK_ARRAY(TYPE_CHAR, 16), MK_ARRAY(TYPE_CHAR, 32), TYPE_INT, MK_ARRAY(TYPE_INT, 10))

-/* FIXME: including these on x86 / x86_64 breaks qemu-i386 */
-#ifdef __powerpc__
-#include "syscall_types_alsa.h"
-#endif
-
 /* loop device ioctls */
 STRUCT(loop_info,
       TYPE_INT,                 /* lo_number */
@@ -248,16 +240,3 @@ STRUCT(fiemap,
       TYPE_INT, /* fm_mapped_extents */
       TYPE_INT, /* fm_extent_count */
       TYPE_INT) /* fm_reserved */
-
-STRUCT(blkpg_partition,
-       TYPE_LONGLONG, /* start */
-       TYPE_LONGLONG, /* length */
-       TYPE_INT, /* pno */
-       MK_ARRAY(TYPE_CHAR, BLKPG_DEVNAMELTH), /* devname */
-       MK_ARRAY(TYPE_CHAR, BLKPG_VOLNAMELTH)) /* volname */
-
-STRUCT(blkpg_ioctl_arg,
-       TYPE_INT, /* op */
-       TYPE_INT, /* flags */
-       TYPE_INT, /* datalen */
-       MK_PTR(MK_STRUCT(STRUCT_blkpg_partition))) /* data */
--- a/linux-user/syscall_types_alsa.h
+++ b/linux-user/syscall_types_alsa.h
--- a/linux-user/x86_64/syscall_nr.h
+++ b/linux-user/x86_64/syscall_nr.h
@@ -305,10 +305,3 @@
 #define TARGET_NR_open_by_handle_at     304
 #define TARGET_NR_clock_adjtime         305
 #define TARGET_NR_syncfs                306
-#define TARGET_NR_sendmmsg              307
-#define TARGET_NR_setns                 308
-#define TARGET_NR_getcpu                309
-#define TARGET_NR_process_vm_readv      310
-#define TARGET_NR_process_vm_writev     311
-#define TARGET_NR_kcmp                  312
-#define TARGET_NR_finit_module          313
--- a/net/net.c
+++ b/net/net.c
@@ -141,27 +141,6 @@ void qemu_format_nic_info_str(NetClientState *nc, uint8_t macaddr[6])
             macaddr[3], macaddr[4], macaddr[5]);
 }

-static void default_mac_check(void)
-{
-    static const MACAddr def_mac = { .a = { 0x52,0x54,0x00,0x12,0x34,0x56 } };
-    static int warned = 0;
-    int i;
-
-    for (i = 0; i < MAX_NICS; i++)
-    {
-        if (!nd_table[i].used)
-            continue;
-        if (memcmp(nd_table[i].macaddr.a, def_mac.a, 5))
-            continue;
-        if (nd_table[i].macaddr.a[5] >= 0x56 &&
-            nd_table[i].macaddr.a[5] < 0x56  + MAX_NICS && !warned) {
-            warned = 1;
-            fprintf(stderr, "Warning: default mac address being used, creating "
-                    "potential for address conflict\n");
-        }
-    }
-}
-
 void qemu_macaddr_default_if_unset(MACAddr *macaddr)
 {
    static int index = 0;
@@ -1206,7 +1185,6 @@ int net_init_clients(void)
    if (qemu_opts_foreach(net, net_init_client, NULL, 1) == -1) {
        return -1;
    }
-    default_mac_check();

    return 0;
 }
--- a/qemu-char.c
+++ b/qemu-char.c
@@ -252,9 +252,6 @@ typedef struct {
    IOEventHandler *chr_event[MAX_MUX];
    void *ext_opaque[MAX_MUX];
    CharDriverState *drv;
-#if defined(TARGET_S390X)
-    QEMUTimer *accept_timer;
-#endif
    int focus;
    int mux_cnt;
    int term_got_escape;
@@ -411,15 +408,6 @@ static void mux_chr_accept_input(CharDriverState *chr)
        d->chr_read[m](d->ext_opaque[m],
                       &d->buffer[m][d->cons[m]++ & MUX_BUFFER_MASK], 1);
    }
-
-#if defined(TARGET_S390X)
-    /* We're still not able to sync producer and consumer, so let's wait a bit
-       and try again by then. */
-    if (d->prod[m] != d->cons[m]) {
-        qemu_mod_timer(d->accept_timer, qemu_get_clock_ns(vm_clock)
-                                        + (int64_t)100000);
-    }
-#endif
 }

 static int mux_chr_can_read(void *opaque)
@@ -542,10 +530,6 @@ static CharDriverState *qemu_chr_open_mux(CharDriverState *drv)
    chr->opaque = d;
    d->drv = drv;
    d->focus = -1;
-#if defined(TARGET_S390X)
-    d->accept_timer = qemu_new_timer_ns(vm_clock,
-                                     (QEMUTimerCB*)mux_chr_accept_input, chr);
-#endif
    chr->chr_write = mux_chr_write;
    chr->chr_update_read_handler = mux_chr_update_read_handler;
    chr->chr_accept_input = mux_chr_accept_input;
--- a/qemu-img.c
+++ b/qemu-img.c
@@ -1133,7 +1133,7 @@ static int img_convert(int argc, char **argv)
    const uint8_t *buf1;
    BlockDriverInfo bdi;
    QEMUOptionParameter *param = NULL, *create_options = NULL;
-    QEMUOptionParameter *out_baseimg_param, *scsi;
+    QEMUOptionParameter *out_baseimg_param;
    char *options = NULL;
    const char *snapshot_name = NULL;
    float local_progress = 0;
@@ -1340,12 +1340,6 @@ static int img_convert(int argc, char **argv)
        }
    }

-    if ((scsi = get_option_parameter(param, BLOCK_OPT_SCSI)) && scsi->value.n && strcmp(drv->format_name, "vmdk")) {
-        error_report("SCSI devices not supported for this file format");
-        ret = -1;
-        goto out;
-    }
-
    if (!skip_create) {
        /* Create the new image */
        ret = bdrv_create(drv, out_filename, param, &local_err);
--- a/qemu-options.hx
+++ b/qemu-options.hx
@@ -2578,16 +2578,6 @@ Store the QEMU process PID in @var{file}. It is useful if you launch QEMU
 from a script.
 ETEXI

-DEF("nooutgoing", HAS_ARG, QEMU_OPTION_nooutgoing, \
-    "-nooutgoing <IP>\n" \
-    "                incoming traffic only from IP, no outgoing\n", \
-    QEMU_ARCH_ALL)
-STEXI
-@item -nooutgoing
-Forbid userspace networking to make outgoing connections. Only accept incoming
-connections from ip address IP.
-ETEXI
-
 DEF("singlestep", 0, QEMU_OPTION_singlestep, \
    "-singlestep     always run in singlestep mode\n", QEMU_ARCH_ALL)
 STEXI
--- a/roms/Makefile
+++ b/roms/Makefile
@@ -80,8 +80,6 @@ build-seabios-config-%: config.%


 lgplvgabios: $(patsubst %,lgplvgabios-%,$(vgabios_variants))
-	make -C vgabios vgabios.bin
-	cp vgabios/VGABIOS-lgpl-latest.bin ../pc-bios/vgabios.bin

 lgplvgabios-isavga: build-lgplvgabios
 	cp vgabios/VGABIOS-lgpl-latest.bin ../pc-bios/vgabios.bin
--- a/scripts/qemu-binfmt-conf.sh
+++ b/scripts/qemu-binfmt-conf.sh
@@ -27,46 +27,43 @@ case "$cpu" in
  armv[4-9]*)
    cpu="arm"
  ;;
-  sparc*)
-    cpu="sparc"
-  ;;
 esac

 # register the interpreter for each cpu except for the native one
 if [ $cpu != "i386" ] ; then
-    echo ':i386:M::\x7fELF\x01\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x03\x00:\xff\xff\xff\xff\xff\xfe\xfe\xff\xff\xff\xff\xff\xff\xff\xff\xff\xfe\xff\xff\xff:/usr/bin/qemu-i386-binfmt:P' > /proc/sys/fs/binfmt_misc/register
-    echo ':i486:M::\x7fELF\x01\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x06\x00:\xff\xff\xff\xff\xff\xfe\xfe\xff\xff\xff\xff\xff\xff\xff\xff\xff\xfe\xff\xff\xff:/usr/bin/qemu-i386-binfmt:P' > /proc/sys/fs/binfmt_misc/register
+    echo ':i386:M::\x7fELF\x01\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x03\x00:\xff\xff\xff\xff\xff\xfe\xfe\xff\xff\xff\xff\xff\xff\xff\xff\xff\xfe\xff\xff\xff:/usr/local/bin/qemu-i386:' > /proc/sys/fs/binfmt_misc/register
+    echo ':i486:M::\x7fELF\x01\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x06\x00:\xff\xff\xff\xff\xff\xfe\xfe\xff\xff\xff\xff\xff\xff\xff\xff\xff\xfe\xff\xff\xff:/usr/local/bin/qemu-i386:' > /proc/sys/fs/binfmt_misc/register
 fi
 if [ $cpu != "alpha" ] ; then
-    echo ':alpha:M::\x7fELF\x02\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x26\x90:\xff\xff\xff\xff\xff\xfe\xfe\xff\xff\xff\xff\xff\xff\xff\xff\xff\xfe\xff\xff\xff:/usr/bin/qemu-alpha-binfmt:P' > /proc/sys/fs/binfmt_misc/register
+    echo ':alpha:M::\x7fELF\x02\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x26\x90:\xff\xff\xff\xff\xff\xfe\xfe\xff\xff\xff\xff\xff\xff\xff\xff\xff\xfe\xff\xff\xff:/usr/local/bin/qemu-alpha:' > /proc/sys/fs/binfmt_misc/register
 fi
 if [ $cpu != "arm" ] ; then
-    echo   ':arm:M::\x7fELF\x01\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x28\x00:\xff\xff\xff\xff\xff\xff\xff\x00\xff\xff\xff\xff\xff\xff\xff\xff\xfe\xff\xff\xff:/usr/bin/qemu-arm-binfmt:P' > /proc/sys/fs/binfmt_misc/register
-    echo   ':armeb:M::\x7fELF\x01\x02\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x28:\xff\xff\xff\xff\xff\xff\xff\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xfe\xff\xff:/usr/bin/qemu-armeb-binfmt:P' > /proc/sys/fs/binfmt_misc/register
+    echo   ':arm:M::\x7fELF\x01\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x28\x00:\xff\xff\xff\xff\xff\xff\xff\x00\xff\xff\xff\xff\xff\xff\xff\xff\xfe\xff\xff\xff:/usr/local/bin/qemu-arm:' > /proc/sys/fs/binfmt_misc/register
+    echo   ':armeb:M::\x7fELF\x01\x02\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x28:\xff\xff\xff\xff\xff\xff\xff\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xfe\xff\xff:/usr/local/bin/qemu-armeb:' > /proc/sys/fs/binfmt_misc/register
 fi
 if [ $cpu != "sparc" ] ; then
-    echo   ':sparc:M::\x7fELF\x01\x02\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x02:\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xfe\xff\xff:/usr/bin/qemu-sparc-binfmt:P' > /proc/sys/fs/binfmt_misc/register
+    echo   ':sparc:M::\x7fELF\x01\x02\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x02:\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xfe\xff\xff:/usr/local/bin/qemu-sparc:' > /proc/sys/fs/binfmt_misc/register
 fi
 if [ $cpu != "ppc" ] ; then
-    echo   ':ppc:M::\x7fELF\x01\x02\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x14:\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xfe\xff\xff:/usr/bin/qemu-ppc-binfmt:P' > /proc/sys/fs/binfmt_misc/register
+    echo   ':ppc:M::\x7fELF\x01\x02\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x14:\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xfe\xff\xff:/usr/local/bin/qemu-ppc:' > /proc/sys/fs/binfmt_misc/register
 fi
 if [ $cpu != "m68k" ] ; then
    echo   'Please check cpu value and header information for m68k!'
-    echo   ':m68k:M::\x7fELF\x01\x02\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x04:\xff\xff\xff\xff\xff\xff\xff\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xfe\xff\xff:/usr/bin/qemu-m68k-binfmt:P' > /proc/sys/fs/binfmt_misc/register
+    echo   ':m68k:M::\x7fELF\x01\x02\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x04:\xff\xff\xff\xff\xff\xff\xff\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xfe\xff\xff:/usr/local/bin/qemu-m68k:' > /proc/sys/fs/binfmt_misc/register
 fi
 if [ $cpu != "mips" ] ; then
    # FIXME: We could use the other endianness on a MIPS host.
-    echo   ':mips:M::\x7fELF\x01\x02\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x08:\xff\xff\xff\xff\xff\xff\xff\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xfe\xff\xff:/usr/bin/qemu-mips-binfmt:P' > /proc/sys/fs/binfmt_misc/register
-    echo   ':mipsel:M::\x7fELF\x01\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x08\x00:\xff\xff\xff\xff\xff\xff\xff\x00\xff\xff\xff\xff\xff\xff\xff\xff\xfe\xff\xff\xff:/usr/bin/qemu-mipsel-binfmt:P' > /proc/sys/fs/binfmt_misc/register
-    echo   ':mipsn32:M::\x7fELF\x01\x02\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x08:\xff\xff\xff\xff\xff\xff\xff\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xfe\xff\xff:/usr/bin/qemu-mipsn32-binfmt:P' > /proc/sys/fs/binfmt_misc/register
-    echo   ':mipsn32el:M::\x7fELF\x01\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x08\x00:\xff\xff\xff\xff\xff\xff\xff\x00\xff\xff\xff\xff\xff\xff\xff\xff\xfe\xff\xff\xff:/usr/bin/qemu-mipsn32el-binfmt:P' > /proc/sys/fs/binfmt_misc/register
-    echo   ':mips64:M::\x7fELF\x02\x02\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x08:\xff\xff\xff\xff\xff\xff\xff\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xfe\xff\xff:/usr/bin/qemu-mips64-binfmt:P' > /proc/sys/fs/binfmt_misc/register
-    echo   ':mips64el:M::\x7fELF\x02\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x08\x00:\xff\xff\xff\xff\xff\xff\xff\x00\xff\xff\xff\xff\xff\xff\xff\xff\xfe\xff\xff\xff:/usr/bin/qemu-mips64el-binfmt:P' > /proc/sys/fs/binfmt_misc/register
+    echo   ':mips:M::\x7fELF\x01\x02\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x08:\xff\xff\xff\xff\xff\xff\xff\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xfe\xff\xff:/usr/local/bin/qemu-mips:' > /proc/sys/fs/binfmt_misc/register
+    echo   ':mipsel:M::\x7fELF\x01\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x08\x00:\xff\xff\xff\xff\xff\xff\xff\x00\xff\xff\xff\xff\xff\xff\xff\xff\xfe\xff\xff\xff:/usr/local/bin/qemu-mipsel:' > /proc/sys/fs/binfmt_misc/register
+    echo   ':mipsn32:M::\x7fELF\x01\x02\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x08:\xff\xff\xff\xff\xff\xff\xff\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xfe\xff\xff:/usr/local/bin/qemu-mipsn32:' > /proc/sys/fs/binfmt_misc/register
+    echo   ':mipsn32el:M::\x7fELF\x01\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x08\x00:\xff\xff\xff\xff\xff\xff\xff\x00\xff\xff\xff\xff\xff\xff\xff\xff\xfe\xff\xff\xff:/usr/local/bin/qemu-mipsn32el:' > /proc/sys/fs/binfmt_misc/register
+    echo   ':mips64:M::\x7fELF\x02\x02\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x08:\xff\xff\xff\xff\xff\xff\xff\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xfe\xff\xff:/usr/local/bin/qemu-mips64:' > /proc/sys/fs/binfmt_misc/register
+    echo   ':mips64el:M::\x7fELF\x02\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x08\x00:\xff\xff\xff\xff\xff\xff\xff\x00\xff\xff\xff\xff\xff\xff\xff\xff\xfe\xff\xff\xff:/usr/local/bin/qemu-mips64el:' > /proc/sys/fs/binfmt_misc/register
 fi
 if [ $cpu != "sh" ] ; then
-    echo    ':sh4:M::\x7fELF\x01\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x2a\x00:\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xfe\xff\xff\xff:/usr/bin/qemu-sh4-binfmt:P' > /proc/sys/fs/binfmt_misc/register
-    echo    ':sh4eb:M::\x7fELF\x01\x02\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x2a:\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xfe\xff\xff:/usr/bin/qemu-sh4eb-binfmt:P' > /proc/sys/fs/binfmt_misc/register
+    echo    ':sh4:M::\x7fELF\x01\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x2a\x00:\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xfe\xff\xff\xff:/usr/local/bin/qemu-sh4:' > /proc/sys/fs/binfmt_misc/register
+    echo    ':sh4eb:M::\x7fELF\x01\x02\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x2a:\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xfe\xff\xff:/usr/local/bin/qemu-sh4eb:' > /proc/sys/fs/binfmt_misc/register
 fi
 if [ $cpu != "s390x" ] ; then
-    echo   ':s390x:M::\x7fELF\x02\x02\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x16:\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xfe\xff\xff:/usr/bin/qemu-s390x-binfmt:P' > /proc/sys/fs/binfmt_misc/register
+    echo   ':s390x:M::\x7fELF\x02\x02\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x16:\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xfe\xff\xff:/usr/local/bin/qemu-s390x:' > /proc/sys/fs/binfmt_misc/register
 fi
--- a/slirp/socket.c
+++ b/slirp/socket.c
@@ -532,8 +532,6 @@ sorecvfrom(struct socket *so)
 	} /* if ping packet */
 }

-extern int slirp_nooutgoing;
-
 /*
 * sendto() a socket
 */
@@ -564,12 +562,6 @@ sosendto(struct socket *so, struct mbuf *m)

 	DEBUG_MISC((dfd, " sendto()ing, addr.sin_port=%d, addr.sin_addr.s_addr=%.16s\n", ntohs(addr.sin_port), inet_ntoa(addr.sin_addr)));

-	/* Only allow DNS requests */
-	if (slirp_nooutgoing && ntohs(addr.sin_port) != 53) {
-		errno = EHOSTUNREACH;
-		return -1;
-	}
-
 	/* Don't care what port we get */
 	ret = sendto(so->s, m->m_data, m->m_len, 0,
 		     (struct sockaddr *)&addr, sizeof (struct sockaddr));
--- a/slirp/tcp_subr.c
+++ b/slirp/tcp_subr.c
@@ -324,9 +324,6 @@ tcp_sockclosed(struct tcpcb *tp)
 * nonblocking.  Connect returns after the SYN is sent, and does
 * not wait for ACK+SYN.
 */
-
-extern int slirp_nooutgoing;
-
 int tcp_fconnect(struct socket *so)
 {
  Slirp *slirp = so->slirp;
@@ -335,11 +332,6 @@ int tcp_fconnect(struct socket *so)
  DEBUG_CALL("tcp_fconnect");
  DEBUG_ARG("so = %lx", (long )so);

-  if (slirp_nooutgoing) {
-    errno = EHOSTUNREACH;
-    return -1;
-  }
-
  if( (ret = so->s = qemu_socket(AF_INET,SOCK_STREAM,0)) >= 0) {
    int opt, s=so->s;
    struct sockaddr_in addr;
@@ -432,11 +424,6 @@ void tcp_connect(struct socket *inso)
        tcp_close(sototcpcb(so)); /* This will sofree() as well */
        return;
    }
-    if (slirp_nooutgoing && addr.sin_addr.s_addr != slirp_nooutgoing) {
-        tcp_close(sototcpcb(so)); /* This will sofree() as well */
-        close(s);
-        return;
-    }
    qemu_set_nonblock(s);
    socket_set_fast_reuse(s);
    opt = 1;
--- a/target-arm/cpu.c
+++ b/target-arm/cpu.c
@@ -133,11 +133,7 @@ static void arm_cpu_reset(CPUState *s)
     * bake assumptions about into translated code, so we need to
     * tb_flush().
     */
-#if !defined(CONFIG_USER_ONLY)
-    /* XXX hack alert! automoc4 segaults after spawning a new thread with this
-           flush enabled */
    tb_flush(env);
-#endif
 }

 #ifndef CONFIG_USER_ONLY
--- a/tcg/tcg.c
+++ b/tcg/tcg.c
@@ -40,8 +40,6 @@
 #include "qemu/cache-utils.h"
 #include "qemu/host-utils.h"
 #include "qemu/timer.h"
-#include "config-host.h"
-#include "qemu/thread.h"

 /* Note: the long term plan is to reduce the dependancies on the QEMU
   CPU definitions. Currently they are used for qemu_ld/st
@@ -119,29 +117,6 @@ const size_t tcg_op_defs_max = ARRAY_SIZE(tcg_op_defs);
 static TCGRegSet tcg_target_available_regs[2];
 static TCGRegSet tcg_target_call_clobber_regs;

-#ifdef CONFIG_USER_ONLY
-static __thread int tcg_lock_count;
-#endif
-void tcg_lock(void)
-{
-#ifdef CONFIG_USER_ONLY
-    TCGContext *s = &tcg_ctx;
-    if (tcg_lock_count++ == 0) {
-        qemu_mutex_lock(&s->lock);
-    }
-#endif
-}
-
-void tcg_unlock(void)
-{
-#ifdef CONFIG_USER_ONLY
-    TCGContext *s = &tcg_ctx;
-    if (--tcg_lock_count == 0) {
-        qemu_mutex_unlock(&s->lock);
-    }
-#endif
-}
-
 static inline void tcg_out8(TCGContext *s, uint8_t v)
 {
    *s->code_ptr++ = v;
@@ -320,8 +295,7 @@ void tcg_context_init(TCGContext *s)

    memset(s, 0, sizeof(*s));
    s->nb_globals = 0;
-    qemu_mutex_init(&s->lock);
-
+    
    /* Count total number of arguments and allocate the corresponding
       space */
    total_args = 0;
@@ -2625,12 +2599,10 @@ int tcg_gen_code(TCGContext *s, uint8_t *gen_code_buf)
    }
 #endif

-    tcg_lock();
    tcg_gen_code_common(s, gen_code_buf, -1);

    /* flush instruction cache */
    flush_icache_range((uintptr_t)gen_code_buf, (uintptr_t)s->code_ptr);
-    tcg_unlock();

    return s->code_ptr -  gen_code_buf;
 }
@@ -2641,11 +2613,7 @@ int tcg_gen_code(TCGContext *s, uint8_t *gen_code_buf)
   Return -1 if not found. */
 int tcg_gen_code_search_pc(TCGContext *s, uint8_t *gen_code_buf, long offset)
 {
-    int r;
-    tcg_lock();
-    r = tcg_gen_code_common(s, gen_code_buf, offset);
-    tcg_unlock();
-    return r;
+    return tcg_gen_code_common(s, gen_code_buf, offset);
 }

 #ifdef CONFIG_PROFILER
--- a/tcg/tcg.h
+++ b/tcg/tcg.h
@@ -54,8 +54,6 @@ typedef uint64_t tcg_target_ulong;
 #error unsupported
 #endif

-#include "config-host.h"
-#include "qemu/thread.h"
 #include "tcg-runtime.h"

 #if TCG_TARGET_NB_REGS <= 32
@@ -528,7 +526,6 @@ struct TCGContext {

    /* The TCGBackendData structure is private to tcg-target.c.  */
    struct TCGBackendData *be;
-    QemuMutex lock;
 };

 extern TCGContext tcg_ctx;
@@ -706,9 +703,6 @@ void tcg_gen_shifti_i64(TCGv_i64 ret, TCGv_i64 arg1,
 TCGArg *tcg_optimize(TCGContext *s, uint16_t *tcg_opc_ptr, TCGArg *args,
                     TCGOpDef *tcg_op_def);

-extern void tcg_lock(void);
-extern void tcg_unlock(void);
-
 /* only used for debugging purposes */
 void tcg_dump_ops(TCGContext *s);

--- a/tests/qemu-iotests/041
+++ b/tests/qemu-iotests/041
@@ -691,32 +691,16 @@ class TestUnbackedSource(ImageMirroringTestCase):
        os.remove(test_img)
        os.remove(target_img)

-    def test_absolute_paths_full(self):
-        self.assert_no_active_block_jobs()
-        result = self.vm.qmp('drive-mirror', device='drive0',
-                             sync='full', target=target_img,
-                             mode='absolute-paths')
-        self.assert_qmp(result, 'return', {})
-        self.complete_and_wait()
+    def test_absolute_paths(self):
        self.assert_no_active_block_jobs()

-    def test_absolute_paths_top(self):
-        self.assert_no_active_block_jobs()
-        result = self.vm.qmp('drive-mirror', device='drive0',
-                             sync='top', target=target_img,
-                             mode='absolute-paths')
-        self.assert_qmp(result, 'return', {})
-        self.complete_and_wait()
-        self.assert_no_active_block_jobs()
-
-    def test_absolute_paths_none(self):
-        self.assert_no_active_block_jobs()
-        result = self.vm.qmp('drive-mirror', device='drive0',
-                             sync='none', target=target_img,
-                             mode='absolute-paths')
-        self.assert_qmp(result, 'return', {})
-        self.complete_and_wait()
-        self.assert_no_active_block_jobs()
+        for sync_mode in ['full', 'top', 'none']:
+            result = self.vm.qmp('drive-mirror', device='drive0',
+                                 sync=sync_mode, target=target_img,
+                                 mode='absolute-paths')
+            self.assert_qmp(result, 'return', {})
+            self.complete_and_wait()
+            self.assert_no_active_block_jobs()

 if __name__ == '__main__':
    iotests.main(supported_fmts=['qcow2', 'qed'])
--- a/tests/qemu-iotests/041.out
+++ b/tests/qemu-iotests/041.out
@@ -1,5 +1,5 @@
-...........................
+.........................
 ----------------------------------------------------------------------
-Ran 27 tests
+Ran 25 tests

 OK
--- a/thunk.c
+++ b/thunk.c
@@ -41,7 +41,6 @@ static inline const argtype *thunk_type_next(const argtype *type_ptr)
    case TYPE_CHAR:
    case TYPE_SHORT:
    case TYPE_INT:
-    case TYPE_INTBITFIELD:
    case TYPE_LONGLONG:
    case TYPE_ULONGLONG:
    case TYPE_LONG:
@@ -141,26 +140,6 @@ const argtype *thunk_convert(void *dst, const void *src,
    case TYPE_INT:
        *(uint32_t *)dst = tswap32(*(uint32_t *)src);
        break;
-    case TYPE_INTBITFIELD:
-#if defined(TARGET_I386) && defined(__powerpc__)
-        /* powerpc uses the MSB, whereas i386 uses the LSB
-         * to store the first bit in a field */
-        {
-	    unsigned char byte = *(uint8_t *)src;
-            *(uint8_t *)dst  = ((byte >> 7) & 1)
-		             | ((byte >> 5) & 2)
-			     | ((byte >> 3) & 4)
-			     | ((byte >> 1) & 8)
-			     | ((byte << 1) & 16)
-			     | ((byte << 3) & 32)
-			     | ((byte << 5) & 64)
-			     | ((byte << 7) & 128);
-	    /* FIXME: implement for bitfields > 1 byte and other archs */
-        }
-#else
-        *(uint32_t *)dst = tswap32(*(uint32_t *)src);
-#endif
-	break;
    case TYPE_LONGLONG:
    case TYPE_ULONGLONG:
        *(uint64_t *)dst = tswap64(*(uint64_t *)src);
--- a/16
+++ b/16
@@ -309,6 +309,9 @@ usb_ehci_sitd(uint32_t addr, uint32_t nxt, uint32_t active) "ITD @ %08x: next %0
 usb_ehci_port_attach(uint32_t port, const char *owner, const char *device) "attach port #%d, owner %s, device %s"
 usb_ehci_port_detach(uint32_t port, const char *owner) "detach port #%d, owner %s"
 usb_ehci_port_reset(uint32_t port, int enable) "reset port #%d - %d"
+usb_ehci_port_suspend(uint32_t port) "port #%d"
+usb_ehci_port_wakeup(uint32_t port) "port #%d"
+usb_ehci_port_resume(uint32_t port) "port #%d"
 usb_ehci_queue_action(void *q, const char *action) "q %p: %s"
 usb_ehci_packet_action(void *q, void *p, const char *action) "q %p p %p: %s"
 usb_ehci_irq(uint32_t level, uint32_t frindex, uint32_t sts, uint32_t mask) "level %d, frindex 0x%04x, sts 0x%x, mask 0x%x"
@@ -427,45 +430,32 @@ usb_uas_tmf_abort_task(int addr, uint16_t tag, uint16_t task_tag) "dev %d, tag 0
 usb_uas_tmf_logical_unit_reset(int addr, uint16_t tag, int lun) "dev %d, tag 0x%x, lun %d"
 usb_uas_tmf_unsupported(int addr, uint16_t tag, uint32_t function) "dev %d, tag 0x%x, function 0x%x"

-# hw/usb/host-linux.c
 # hw/usb/host-libusb.c
 usb_host_open_started(int bus, int addr) "dev %d:%d"
 usb_host_open_success(int bus, int addr) "dev %d:%d"
 usb_host_open_failure(int bus, int addr) "dev %d:%d"
-usb_host_disconnect(int bus, int addr) "dev %d:%d"
 usb_host_close(int bus, int addr) "dev %d:%d"
 usb_host_attach_kernel(int bus, int addr, int interface) "dev %d:%d, if %d"
 usb_host_detach_kernel(int bus, int addr, int interface) "dev %d:%d, if %d"
 usb_host_set_address(int bus, int addr, int config) "dev %d:%d, address %d"
 usb_host_set_config(int bus, int addr, int config) "dev %d:%d, config %d"
 usb_host_set_interface(int bus, int addr, int interface, int alt) "dev %d:%d, interface %d, alt %d"
-usb_host_claim_interfaces(int bus, int addr, int config, int nif) "dev %d:%d, config %d, nif %d"
 usb_host_claim_interface(int bus, int addr, int config, int interface) "dev %d:%d, config %d, if %d"
-usb_host_release_interfaces(int bus, int addr) "dev %d:%d"
 usb_host_release_interface(int bus, int addr, int interface) "dev %d:%d, if %d"
 usb_host_req_control(int bus, int addr, void *p, int req, int value, int index) "dev %d:%d, packet %p, req 0x%x, value %d, index %d"
 usb_host_req_data(int bus, int addr, void *p, int in, int ep, int size) "dev %d:%d, packet %p, in %d, ep %d, size %d"
 usb_host_req_complete(int bus, int addr, void *p, int status, int length) "dev %d:%d, packet %p, status %d, length %d"
 usb_host_req_emulated(int bus, int addr, void *p, int status) "dev %d:%d, packet %p, status %d"
 usb_host_req_canceled(int bus, int addr, void *p) "dev %d:%d, packet %p"
-usb_host_urb_submit(int bus, int addr, void *aurb, int length, int more) "dev %d:%d, aurb %p, length %d, more %d"
-usb_host_urb_complete(int bus, int addr, void *aurb, int status, int length, int more) "dev %d:%d, aurb %p, status %d, length %d, more %d"
-usb_host_urb_canceled(int bus, int addr, void *aurb) "dev %d:%d, aurb %p"
-usb_host_ep_set_halt(int bus, int addr, int ep) "dev %d:%d, ep %d"
-usb_host_ep_clear_halt(int bus, int addr, int ep) "dev %d:%d, ep %d"
 usb_host_iso_start(int bus, int addr, int ep) "dev %d:%d, ep %d"
 usb_host_iso_stop(int bus, int addr, int ep) "dev %d:%d, ep %d"
 usb_host_iso_out_of_bufs(int bus, int addr, int ep) "dev %d:%d, ep %d"
-usb_host_iso_many_urbs(int bus, int addr, int count) "dev %d:%d, count %d"
 usb_host_reset(int bus, int addr) "dev %d:%d"
 usb_host_auto_scan_enabled(void)
 usb_host_auto_scan_disabled(void)
-usb_host_claim_port(int bus, int hub, int port) "bus %d, hub addr %d, port %d"
-usb_host_parse_device(int bus, int addr, int vendor, int product) "dev %d:%d, id %04x:%04x"
 usb_host_parse_config(int bus, int addr, int value, int active) "dev %d:%d, value %d, active %d"
 usb_host_parse_interface(int bus, int addr, int num, int alt, int active) "dev %d:%d, num %d, alt %d, active %d"
 usb_host_parse_endpoint(int bus, int addr, int ep, const char *dir, const char *type, int active) "dev %d:%d, ep %d, %s, %s, active %d"
-usb_host_parse_unknown(int bus, int addr, int len, int type) "dev %d:%d, len %d, type %d"
 usb_host_parse_error(int bus, int addr, const char *errmsg) "dev %d:%d, msg %s"

 # hw/scsi/scsi-bus.c
--- a/translate-all.c
+++ b/translate-all.c
@@ -612,23 +612,19 @@ static TranslationBlock *tb_alloc(target_ulong pc)
 {
    TranslationBlock *tb;

-    tcg_lock();
    if (tcg_ctx.tb_ctx.nb_tbs >= tcg_ctx.code_gen_max_blocks ||
        (tcg_ctx.code_gen_ptr - tcg_ctx.code_gen_buffer) >=
         tcg_ctx.code_gen_buffer_max_size) {
-        tcg_unlock();
        return NULL;
    }
    tb = &tcg_ctx.tb_ctx.tbs[tcg_ctx.tb_ctx.nb_tbs++];
    tb->pc = pc;
    tb->cflags = 0;
-    tcg_unlock();
    return tb;
 }

 void tb_free(TranslationBlock *tb)
 {
-    tcg_lock();
    /* In practice this is mostly used for single use temporary TB
       Ignore the hard cases and just back up if this TB happens to
       be the last one generated.  */
@@ -637,7 +633,6 @@ void tb_free(TranslationBlock *tb)
        tcg_ctx.code_gen_ptr = tb->tc_ptr;
        tcg_ctx.tb_ctx.nb_tbs--;
    }
-    tcg_unlock();
 }

 static inline void invalidate_page_bitmap(PageDesc *p)
@@ -695,7 +690,6 @@ void tb_flush(CPUArchState *env1)
           ((unsigned long)(tcg_ctx.code_gen_ptr - tcg_ctx.code_gen_buffer)) /
           tcg_ctx.tb_ctx.nb_tbs : 0);
 #endif
-    tcg_lock();
    if ((unsigned long)(tcg_ctx.code_gen_ptr - tcg_ctx.code_gen_buffer)
        > tcg_ctx.code_gen_buffer_size) {
        cpu_abort(env1, "Internal error: code buffer overflow\n");
@@ -716,7 +710,6 @@ void tb_flush(CPUArchState *env1)
    /* XXX: flush processor icache at this point if cache flush is
       expensive */
    tcg_ctx.tb_ctx.tb_flush_count++;
-    tcg_unlock();
 }

 #ifdef DEBUG_TB_CHECK
@@ -1026,10 +1019,8 @@ void tb_invalidate_phys_page_range(tb_page_addr_t start, tb_page_addr_t end,
    int current_flags = 0;
 #endif /* TARGET_HAS_PRECISE_SMC */

-    tcg_lock();
    p = page_find(start >> TARGET_PAGE_BITS);
    if (!p) {
-        tcg_unlock();
        return;
    }
    if (!p->code_bitmap &&
@@ -1122,7 +1113,6 @@ void tb_invalidate_phys_page_range(tb_page_addr_t start, tb_page_addr_t end,
        cpu_resume_from_signal(env, NULL);
    }
 #endif
-    tcg_unlock();
 }

 /* len must be <= 8 and start must be a multiple of len */
@@ -1334,16 +1324,13 @@ static TranslationBlock *tb_find_pc(uintptr_t tc_ptr)
 {
    int m_min, m_max, m;
    uintptr_t v;
-    TranslationBlock *tb, *r;
+    TranslationBlock *tb;

-    tcg_lock();
    if (tcg_ctx.tb_ctx.nb_tbs <= 0) {
-        tcg_unlock();
        return NULL;
    }
    if (tc_ptr < (uintptr_t)tcg_ctx.code_gen_buffer ||
        tc_ptr >= (uintptr_t)tcg_ctx.code_gen_ptr) {
-        tcg_unlock();
        return NULL;
    }
    /* binary search (cf Knuth) */
@@ -1354,7 +1341,6 @@ static TranslationBlock *tb_find_pc(uintptr_t tc_ptr)
        tb = &tcg_ctx.tb_ctx.tbs[m];
        v = (uintptr_t)tb->tc_ptr;
        if (v == tc_ptr) {
-            tcg_unlock();
            return tb;
        } else if (tc_ptr < v) {
            m_max = m - 1;
@@ -1362,9 +1348,7 @@ static TranslationBlock *tb_find_pc(uintptr_t tc_ptr)
            m_min = m + 1;
        }
    }
-    r = &tcg_ctx.tb_ctx.tbs[m_max];
-    tcg_unlock();
-    return r;
+    return &tcg_ctx.tb_ctx.tbs[m_max];
 }

 #if defined(TARGET_HAS_ICE) && !defined(CONFIG_USER_ONLY)
--- a/ui/console.c
+++ b/ui/console.c
@@ -864,7 +864,7 @@ static void console_putchar(QemuConsole *s, int ch)
        } else {
            if (s->nb_esc_params < MAX_ESC_PARAMS)
                s->nb_esc_params++;
-            if (ch == ';' || ch == '?')
+            if (ch == ';')
                break;
 #ifdef DEBUG_CONSOLE
            fprintf(stderr, "escape sequence CSI%d;%d%c, %d parameters\n",
--- a/ui/vnc.c
+++ b/ui/vnc.c
@@ -44,7 +44,6 @@ static const struct timeval VNC_REFRESH_LOSSY = { 2, 0 };
 #include "d3des.h"

 static VncDisplay *vnc_display; /* needed for info vnc */
-static int allowed_connections = 0;

 static int vnc_cursor_define(VncState *vs);
 static void vnc_release_modifiers(VncState *vs);
@@ -1030,7 +1029,6 @@ static void vnc_disconnect_start(VncState *vs)
 void vnc_disconnect_finish(VncState *vs)
 {
    int i;
-    static int num_disconnects = 0;

    vnc_jobs_join(vs); /* Wait encoding jobs */

@@ -1079,13 +1077,6 @@ void vnc_disconnect_finish(VncState *vs)
    }
    g_free(vs->lossy_rect);
    g_free(vs);
-
-    num_disconnects++;
-    if (allowed_connections > 0 && allowed_connections <= num_disconnects) {
-        VNC_DEBUG("Maximum number of disconnects (%d) reached:"
-                  " Session terminating\n", allowed_connections);
-        exit(0);
-    }
 }

 int vnc_client_io_error(VncState *vs, int ret, int last_errno)
@@ -3045,39 +3036,6 @@ char *vnc_display_local_addr(DisplayState *ds)
    return vnc_socket_local_addr("%s:%s", vs->lsock);
 }

-static void read_file_password(DisplayState *ds, char *filename)
-{
-    FILE *pfile = NULL;
-    char *passwd = NULL;
-    int start = 0, length = 0, rc = 0;
-
-    if(strlen(filename) == 0) {
-	printf("No file supplied\n");
-	return;
-    }
-
-    pfile = fopen(filename, "r");
-    if(pfile == NULL) {
-	printf("Could not read from %s\n", filename);
-	return;
-    }
-
-    start  = ftell(pfile);
-    fseek(pfile, 0L, SEEK_END);
-    length = ftell(pfile);
-    fseek(pfile, 0L, start);
-
-    passwd = malloc(length+1);
-    rc = fread(passwd, 1, length, pfile);
-    fclose(pfile);
-
-    if(rc == length && rc > 0) {
-	vnc_display_password(ds, passwd);
-    }
-
-    free(passwd);
-}
-
 void vnc_display_open(DisplayState *ds, const char *display, Error **errp)
 {
    VncDisplay *vs = vnc_display;
@@ -3111,9 +3069,6 @@ void vnc_display_open(DisplayState *ds, const char *display, Error **errp)
    while ((options = strchr(options, ','))) {
        options++;
        if (strncmp(options, "password", 8) == 0) {
-            char *start, *end;
-            start = strchr(options, '=');
-            end = strchr(options, ',');
            if (fips_get_state()) {
                error_setg(errp,
                           "VNC password auth disabled due to FIPS mode, "
@@ -3122,32 +3077,6 @@ void vnc_display_open(DisplayState *ds, const char *display, Error **errp)
                goto fail;
            }
            password = 1; /* Require password auth */
-            if (start && (!end || (start < end))) {
-                int len = end ? end-(start+1) : strlen(start+1);
-                char *text = g_malloc(len+1);
-                strncpy(text, start+1, len);
-                text[len] = '\0';
-                
-                if (strncmp(options, "password-file=", 14) == 0) {
-                    read_file_password(ds, text);
-                } else {
-                    vnc_display_password(ds, text);
-                } 
-            
-                free(text);
-            }
-        } else if (strncmp(options, "allowed-connections=", 20) == 0) {
-            char *start, *end;
-            start = strchr(options, '=');
-            end = strchr(options, ',');
-            if (start && (!end || (start < end))) {
-                int len = end ? end-(start+1) : strlen(start+1);
-                char *text = g_malloc(len+1);
-                strncpy(text, start+1, len);
-                text[len] = '\0';
-                VNC_DEBUG("Maximum number of disconnects: %s\n", text);
-                allowed_connections = atoi(text);
-            }
        } else if (strncmp(options, "reverse", 7) == 0) {
            reverse = 1;
        } else if (strncmp(options, "no-lock-key-sync", 16) == 0) {
--- a/user-exec.c
+++ b/user-exec.c
@@ -89,10 +89,6 @@ static inline int handle_cpu_signal(uintptr_t pc, unsigned long address,
    qemu_printf("qemu: SIGSEGV pc=0x%08lx address=%08lx w=%d oldset=0x%08lx\n",
                pc, address, is_write, *(unsigned long *)old_set);
 #endif
-
-    /* Maybe we're still holding the TB fiddling lock? */
-    spin_unlock_safe(&tcg_ctx.tb_ctx.tb_lock);
-
    /* XXX: locking issue */
    if (is_write && h2g_valid(address)
        && page_unprotect(h2g(address), pc, puc)) {
--- a/vl.c
+++ b/vl.c
@@ -217,7 +217,6 @@ const char *vnc_display;
 int acpi_enabled = 1;
 int no_hpet = 0;
 int fd_bootchk = 1;
-int slirp_nooutgoing = 0;
 static int no_reboot;
 int no_shutdown = 0;
 int cursor_hide = 1;
@@ -3235,14 +3234,6 @@ int main(int argc, char **argv, char **envp)
            case QEMU_OPTION_singlestep:
                singlestep = 1;
                break;
-            case QEMU_OPTION_nooutgoing:
-                slirp_nooutgoing = inet_addr(optarg);
-                if (slirp_nooutgoing == INADDR_NONE) {
-                    printf("Invalid address: %s.\nOnly addresses of the format "
-                           "xxx.xxx.xxx.xxx are supported.\n", optarg);
-                    exit(1);
-                }
-                break;
            case QEMU_OPTION_S:
                autostart = 0;
                break;
Author	SHA1	Message	Date
Gerd Hoffmann	0b1fa34e1d	usb: move usb_{hi,lo} helpers to header file. Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>	2013-11-28 15:39:27 +01:00
Gerd Hoffmann	2b81ba5388	usb: add vendor request defines Add defines for vendor specific usb control requests. Group defines by Device / Interface / Endpoint while being at it. Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>	2013-11-28 15:39:27 +01:00
Markus Armbruster	904c063039	trace-events: Clean up after removal of old usb-host code Commit `b5613fd` neglected to drop the trace events along with the code. Signed-off-by: Markus Armbruster <armbru@redhat.com> Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>	2013-11-28 15:39:27 +01:00
Gerd Hoffmann	690af06aeb	Revert "usb-tablet: Don't claim wakeup capability for USB-2 version" This reverts commit `aa1c9e971e`. Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>	2013-11-28 15:39:27 +01:00
Gerd Hoffmann	e489df40ca	ehci: implement port wakeup Update portsc register and raise irq in case a suspended port is woken up, so remote wakeup works on our ehci ports. Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>	2013-11-28 15:39:27 +01:00
Hans de Goede	72391da506	xhci: Call usb_device_alloc/free_streams Note this code is not as KISS as I would like, the reason for this is that the Linux kernel interface wants streams on eps belonging to one interface to be allocated in one call. Things will also work if we do this one ep at a time (as long as all eps support the same amount of streams), but lets stick to the kernel API. Signed-off-by: Hans de Goede <hdegoede@redhat.com> Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>	2013-11-26 09:21:17 +01:00
Hans de Goede	3b444eadf7	usb: Add usb_device_alloc/free_streams Signed-off-by: Hans de Goede <hdegoede@redhat.com> Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>	2013-11-26 09:21:17 +01:00
Hans de Goede	04b300f85f	usb: Add max_streams attribute to endpoint info Signed-off-by: Hans de Goede <hdegoede@redhat.com> Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>	2013-11-26 09:21:17 +01:00
Hans de Goede	5007c940a9	uas: s/ui/iu/ The various uas data structures are called IU-s, which is short for Information Unit, rather then UI-s. Signed-off-by: Hans de Goede <hdegoede@redhat.com> Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>	2013-11-26 09:21:17 +01:00
Hans de Goede	49cfa2fdc9	uas: Fix response iu struct definition This patch mirrors a patch to the Linux uas kernel driver which I've just submitted. It looks like the qemu uas struct definitions were taken from the Linux kernel driver, and have inherited the same mistake. Besides fixing the response iu struct, the patch also drops the add_info parameter from the usb_uas_queue_response() function, it is always 0 anyways, and expressing 3 zero-bytes as a function argument is a bit hard. Below is the long explanation for this change taken from the kernel commit: The response iu struct before this patch has a size of 7 bytes, which is weird since all other iu-s are explictly padded to a multiple of 4 bytes. Submitting a 7 byte bulk transfer to the status endpoint of a real uasp device when expecting a response iu results in an USB babble error, as the device actually sends 8 bytes. Up on closer reading of the UAS spec: http://www.t10.org/cgi-bin/ac.pl?t=f&f=uas2r00.pdf The reason for this becomes clear, the 2 entries in "Table 17 — RESPONSE IU" are numbered 4 and 6, looking at other iu definitions in the spec, esp. multi-byte fields, this indicates that the ADDITIONAL RESPONSE INFORMATION field is not a 2 byte field as one might assume at a first look, but is a multi-byte field containing 3 bytes. This also aligns with the SCSI Architecture Model 4 spec, which UAS is based on which states in paragraph "7.1 Task management function procedure calls" that the "Additional Response Information" output argument for a Task management function procedure call is 3 bytes. Last but not least I've verified this by sending a logical unit reset task management call with an invalid lun to an actual uasp device, and received back a response-iu with byte 6 being 0, and byte 7 being 9, which is the responce code for an invalid iu, which confirms that the response code is being reported in byte 7 of the response iu rather then in byte 6. Signed-off-by: Hans de Goede <hdegoede@redhat.com> Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>	2013-11-26 09:21:17 +01:00
Hans de Goede	3453f9a0df	uas: Bounds check tags when using streams Disallow the guest to cause us to address the data3 and status3 arrays out of bounds. Signed-off-by: Hans de Goede <hdegoede@redhat.com> Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>	2013-11-26 09:21:17 +01:00
Hans de Goede	0478661ec5	uas: Streams are numbered 1-y, rather then 0-x It is easier to simply make the arrays one larger, rather then substracting one everywhere. Signed-off-by: Hans de Goede <hdegoede@redhat.com> Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>	2013-11-26 09:21:17 +01:00
Hans de Goede	5eb6d9e3ef	uas: Fix / cleanup usb_uas_task error handling -The correct error if we cannot find the dev is INCORRECT_LUN rather then INVALID_INFO_UNIT -Move the device not found check to the top so we only need to do it once -Remove the dev->lun != lun checks, dev is returned by scsi_device_find which searches by lun, so this will never trigger Signed-off-by: Hans de Goede <hdegoede@redhat.com> Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>	2013-11-26 09:21:17 +01:00
Hans de Goede	d4bfc7b9f3	uas: Only use report iu-s for task_mgmt status reporting Regular scsi cmds should always report their status using a sense-iu, using the sense code to report any errors. Signed-off-by: Hans de Goede <hdegoede@redhat.com> Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>	2013-11-26 09:21:17 +01:00
Hans de Goede	9ec557bd53	scsi: Add 2 new sense codes needed by uas Signed-off-by: Hans de Goede <hdegoede@redhat.com> Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>	2013-11-26 09:21:17 +01:00
Gerd Hoffmann	f1f8bc218a	xhci: add support for suspend/resume The OS can ask the xhci controller to save and restore its internal state, which is used by the OS when the system is suspended and resumed. This patch handles writes to the save + restore bits in the command register. Only thing it does is updating the restore error bit in the status register to signal an error on restore. The guest OS should do a full reinitialization after resume then. This is the minimal patch which gets S3 going with xhci. Implementing full save/restore support is TBD. https://bugzilla.redhat.com/show_bug.cgi?id=1012365 Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>	2013-11-26 09:21:17 +01:00
Hans de Goede	de9de157fb	xhci: Add a few missing checks for disconnected devices One of the reworks of qemu's usb core made changes to usb-port's disconnect handling. Now ports with a device will always have a non 0 dev member, but if the device is not attached (which is possible with usb redirection), dev->attached will be 0. So supplement all checks for dev to also check dev->attached, and add an extra check in a path where a device check was completely missing. This fixes various crashes (asserts triggering) I've been seeing when xhci attached usb devices get disconnected at the wrong time. Signed-off-by: Hans de Goede <hdegoede@redhat.com> Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>	2013-11-26 09:21:17 +01:00
@@ -1 +1 @@
 .7.0
 .6.92