9 files changed, 181 insertions, 153 deletions

diff --git a/sound/usb/usbaudio.c b/sound/usb/usbaudio.c
index 2ead878bcb8f..99dae024b640 100644
--- a/sound/usb/usbaudio.c
+++ b/sound/usb/usbaudio.c
@@ -41,7 +41,6 @@
 #include <sound/driver.h>
 #include <linux/bitops.h>
 #include <linux/init.h>
-#include <linux/interrupt.h>
 #include <linux/list.h>
 #include <linux/slab.h>
 #include <linux/string.h>
@@ -185,7 +184,6 @@ struct snd_usb_substream {
         unsigned int num_formats;               /* number of supported audio formats (list) */
         struct list_head fmt_list;      /* format list */
         spinlock_t lock;
-        struct tasklet_struct start_period_elapsed;     /* for start trigger */
 
         struct snd_urb_ops ops;         /* callbacks (must be filled at init) */
 };
@@ -480,6 +478,28 @@ static int retire_playback_sync_urb_hs(snd_usb_substream_t *subs,
 }
 
 /*
+ * Prepare urb for streaming before playback starts.
+ *
+ * We don't care about (or have) any data, so we just send a transfer delimiter.
+ */
+static int prepare_startup_playback_urb(snd_usb_substream_t *subs,
+                                        snd_pcm_runtime_t *runtime,
+                                        struct urb *urb)
+{
+        unsigned int i;
+        snd_urb_ctx_t *ctx = urb->context;
+
+        urb->dev = ctx->subs->dev;
+        urb->number_of_packets = subs->packs_per_ms;
+        for (i = 0; i < subs->packs_per_ms; ++i) {
+                urb->iso_frame_desc[i].offset = 0;
+                urb->iso_frame_desc[i].length = 0;
+        }
+        urb->transfer_buffer_length = 0;
+        return 0;
+}
+
+/*
  * prepare urb for playback data pipe
  *
  * Since a URB can handle only a single linear buffer, we must use double
@@ -568,12 +588,8 @@ static int prepare_playback_urb(snd_usb_substream_t *subs,
                 subs->hwptr_done -= runtime->buffer_size;
         spin_unlock_irqrestore(&subs->lock, flags);
         urb->transfer_buffer_length = offs * stride;
-        if (period_elapsed) {
-                if (likely(subs->running))
-                        snd_pcm_period_elapsed(subs->pcm_substream);
-                else
-                        tasklet_hi_schedule(&subs->start_period_elapsed);
-        }
+        if (period_elapsed)
+                snd_pcm_period_elapsed(subs->pcm_substream);
         return 0;
 }
 
@@ -588,22 +604,12 @@ static int retire_playback_urb(snd_usb_substream_t *subs,
         return 0;
 }
 
-/*
- * Delay the snd_pcm_period_elapsed() call until after the start trigger
- * callback so that we're not longer in the substream's lock.
- */
-static void start_period_elapsed(unsigned long data)
-{
-        snd_usb_substream_t *subs = (snd_usb_substream_t *)data;
-        snd_pcm_period_elapsed(subs->pcm_substream);
-}
-
 
 /*
  */
 static struct snd_urb_ops audio_urb_ops[2] = {
         {
-                .prepare =      prepare_playback_urb,
+                .prepare =      prepare_startup_playback_urb,
                 .retire =       retire_playback_urb,
                 .prepare_sync = prepare_playback_sync_urb,
                 .retire_sync =  retire_playback_sync_urb,
@@ -618,7 +624,7 @@ static struct snd_urb_ops audio_urb_ops[2] = {
 
 static struct snd_urb_ops audio_urb_ops_high_speed[2] = {
         {
-                .prepare =      prepare_playback_urb,
+                .prepare =      prepare_startup_playback_urb,
                 .retire =       retire_playback_urb,
                 .prepare_sync = prepare_playback_sync_urb_hs,
                 .retire_sync =  retire_playback_sync_urb_hs,
@@ -692,9 +698,9 @@ static int snd_pcm_alloc_vmalloc_buffer(snd_pcm_substream_t *subs, size_t size)
         if (runtime->dma_area) {
                 if (runtime->dma_bytes >= size)
                         return 0; /* already large enough */
-                vfree_nocheck(runtime->dma_area);
+                vfree(runtime->dma_area);
         }
-        runtime->dma_area = vmalloc_nocheck(size);
+        runtime->dma_area = vmalloc(size);
         if (! runtime->dma_area)
                 return -ENOMEM;
         runtime->dma_bytes = size;
@@ -706,7 +712,7 @@ static int snd_pcm_free_vmalloc_buffer(snd_pcm_substream_t *subs)
 {
         snd_pcm_runtime_t *runtime = subs->runtime;
         if (runtime->dma_area) {
-                vfree_nocheck(runtime->dma_area);
+                vfree(runtime->dma_area);
                 runtime->dma_area = NULL;
         }
         return 0;
@@ -838,8 +844,7 @@ static int wait_clear_urbs(snd_usb_substream_t *subs)
                 }
                 if (! alive)
                         break;
-                set_current_state(TASK_UNINTERRUPTIBLE);
-                schedule_timeout(1);
+                schedule_timeout_uninterruptible(1);
         } while (time_before(jiffies, end_time));
         if (alive)
                 snd_printk(KERN_ERR "timeout: still %d active urbs..\n", alive);
@@ -864,25 +869,40 @@ static snd_pcm_uframes_t snd_usb_pcm_pointer(snd_pcm_substream_t *substream)
 
 
 /*
- * start/stop substream
+ * start/stop playback substream
  */
-static int snd_usb_pcm_trigger(snd_pcm_substream_t *substream, int cmd)
+static int snd_usb_pcm_playback_trigger(snd_pcm_substream_t *substream,
+                                        int cmd)
 {
-        snd_usb_substream_t *subs = (snd_usb_substream_t *)substream->runtime->private_data;
-        int err;
+        snd_usb_substream_t *subs = substream->runtime->private_data;
 
         switch (cmd) {
         case SNDRV_PCM_TRIGGER_START:
-                err = start_urbs(subs, substream->runtime);
-                break;
+                subs->ops.prepare = prepare_playback_urb;
+                return 0;
         case SNDRV_PCM_TRIGGER_STOP:
-                err = deactivate_urbs(subs, 0, 0);
-                break;
+                return deactivate_urbs(subs, 0, 0);
         default:
-                err = -EINVAL;
-                break;
+                return -EINVAL;
+        }
+}
+
+/*
+ * start/stop capture substream
+ */
+static int snd_usb_pcm_capture_trigger(snd_pcm_substream_t *substream,
+                                       int cmd)
+{
+        snd_usb_substream_t *subs = substream->runtime->private_data;
+
+        switch (cmd) {
+        case SNDRV_PCM_TRIGGER_START:
+                return start_urbs(subs, substream->runtime);
+        case SNDRV_PCM_TRIGGER_STOP:
+                return deactivate_urbs(subs, 0, 0);
+        default:
+                return -EINVAL;
         }
-        return err < 0 ? err : 0;
 }
 
 
@@ -1044,7 +1064,7 @@ static int init_substream_urbs(snd_usb_substream_t *subs, unsigned int period_by
                 u->urb->transfer_flags = URB_ISO_ASAP | URB_NO_TRANSFER_DMA_MAP;
                 u->urb->interval = 1 << subs->datainterval;
                 u->urb->context = u;
-                u->urb->complete = snd_usb_complete_callback(snd_complete_urb);
+                u->urb->complete = snd_complete_urb;
         }
 
         if (subs->syncpipe) {
@@ -1070,7 +1090,7 @@ static int init_substream_urbs(snd_usb_substream_t *subs, unsigned int period_by
                         u->urb->number_of_packets = 1;
                         u->urb->interval = 1 << subs->syncinterval;
                         u->urb->context = u;
-                        u->urb->complete = snd_usb_complete_callback(snd_complete_sync_urb);
+                        u->urb->complete = snd_complete_sync_urb;
                 }
         }
         return 0;
@@ -1414,7 +1434,7 @@ static int snd_usb_hw_free(snd_pcm_substream_t *substream)
 static int snd_usb_pcm_prepare(snd_pcm_substream_t *substream)
 {
         snd_pcm_runtime_t *runtime = substream->runtime;
-        snd_usb_substream_t *subs = (snd_usb_substream_t *)runtime->private_data;
+        snd_usb_substream_t *subs = runtime->private_data;
 
         if (! subs->cur_audiofmt) {
                 snd_printk(KERN_ERR "usbaudio: no format is specified!\n");
@@ -1434,7 +1454,13 @@ static int snd_usb_pcm_prepare(snd_pcm_substream_t *substream)
         deactivate_urbs(subs, 0, 1);
         wait_clear_urbs(subs);
 
-        return 0;
+        /* for playback, submit the URBs now; otherwise, the first hwptr_done
+         * updates for all URBs would happen at the same time when starting */
+        if (subs->direction == SNDRV_PCM_STREAM_PLAYBACK) {
+                subs->ops.prepare = prepare_startup_playback_urb;
+                return start_urbs(subs, runtime);
+        } else
+                return 0;
 }
 
 static snd_pcm_hardware_t snd_usb_playback =
@@ -1848,7 +1874,7 @@ static snd_pcm_ops_t snd_usb_playback_ops = {
         .hw_params =    snd_usb_hw_params,
         .hw_free =      snd_usb_hw_free,
         .prepare =      snd_usb_pcm_prepare,
-        .trigger =      snd_usb_pcm_trigger,
+        .trigger =      snd_usb_pcm_playback_trigger,
         .pointer =      snd_usb_pcm_pointer,
         .page =         snd_pcm_get_vmalloc_page,
 };
@@ -1860,7 +1886,7 @@ static snd_pcm_ops_t snd_usb_capture_ops = {
         .hw_params =    snd_usb_hw_params,
         .hw_free =      snd_usb_hw_free,
         .prepare =      snd_usb_pcm_prepare,
-        .trigger =      snd_usb_pcm_trigger,
+        .trigger =      snd_usb_pcm_capture_trigger,
         .pointer =      snd_usb_pcm_pointer,
         .page =         snd_pcm_get_vmalloc_page,
 };
@@ -2079,9 +2105,6 @@ static void init_substream(snd_usb_stream_t *as, int stream, struct audioformat
 
         INIT_LIST_HEAD(&subs->fmt_list);
         spin_lock_init(&subs->lock);
-        if (stream == SNDRV_PCM_STREAM_PLAYBACK)
-                tasklet_init(&subs->start_period_elapsed, start_period_elapsed,
-                             (unsigned long)subs);
 
         subs->stream = as;
         subs->direction = stream;
@@ -2755,9 +2778,9 @@ static int create_fixed_stream_quirk(snd_usb_audio_t *chip,
 /*
  * create a stream for an interface with proper descriptors
  */
-static int create_standard_interface_quirk(snd_usb_audio_t *chip,
-                                           struct usb_interface *iface,
-                                           const snd_usb_audio_quirk_t *quirk)
+static int create_standard_audio_quirk(snd_usb_audio_t *chip,
+                                       struct usb_interface *iface,
+                                       const snd_usb_audio_quirk_t *quirk)
 {
         struct usb_host_interface *alts;
         struct usb_interface_descriptor *altsd;
@@ -2765,24 +2788,14 @@ static int create_standard_interface_quirk(snd_usb_audio_t *chip,
 
         alts = &iface->altsetting[0];
         altsd = get_iface_desc(alts);
-        switch (quirk->type) {
-        case QUIRK_AUDIO_STANDARD_INTERFACE:
-                err = parse_audio_endpoints(chip, altsd->bInterfaceNumber);
-                if (!err)
-                        usb_set_interface(chip->dev, altsd->bInterfaceNumber, 0); /* reset the current interface */
-                break;
-        case QUIRK_MIDI_STANDARD_INTERFACE:
-                err = snd_usb_create_midi_interface(chip, iface, NULL);
-                break;
-        default:
-                snd_printd(KERN_ERR "invalid quirk type %d\n", quirk->type);
-                return -ENXIO;
-        }
+        err = parse_audio_endpoints(chip, altsd->bInterfaceNumber);
         if (err < 0) {
                 snd_printk(KERN_ERR "cannot setup if %d: error %d\n",
                            altsd->bInterfaceNumber, err);
                 return err;
         }
+        /* reset the current interface */
+        usb_set_interface(chip->dev, altsd->bInterfaceNumber, 0);
         return 0;
 }
 
@@ -3044,7 +3057,7 @@ static int snd_usb_create_quirk(snd_usb_audio_t *chip,
                 [QUIRK_MIDI_RAW] = snd_usb_create_midi_interface,
                 [QUIRK_MIDI_EMAGIC] = snd_usb_create_midi_interface,
                 [QUIRK_MIDI_MIDITECH] = snd_usb_create_midi_interface,
-                [QUIRK_AUDIO_STANDARD_INTERFACE] = create_standard_interface_quirk,
+                [QUIRK_AUDIO_STANDARD_INTERFACE] = create_standard_audio_quirk,
                 [QUIRK_AUDIO_FIXED_ENDPOINT] = create_fixed_stream_quirk,
                 [QUIRK_AUDIO_EDIROL_UA700_UA25] = create_ua700_ua25_quirk,
                 [QUIRK_AUDIO_EDIROL_UA1000] = create_ua1000_quirk,
@@ -3222,7 +3235,6 @@ static void *snd_usb_audio_probe(struct usb_device *dev,
                                  struct usb_interface *intf,
                                  const struct usb_device_id *usb_id)
 {
-        struct usb_host_config *config = dev->actconfig;
         const snd_usb_audio_quirk_t *quirk = (const snd_usb_audio_quirk_t *)usb_id->driver_info;
         int i, err;
         snd_usb_audio_t *chip;
@@ -3243,7 +3255,6 @@ static void *snd_usb_audio_probe(struct usb_device *dev,
         if (id == USB_ID(0x041e, 0x3000)) {
                 if (snd_usb_extigy_boot_quirk(dev, intf) < 0)
                         goto __err_val;
-                config = dev->actconfig;
         }
         /* SB Audigy 2 NX needs its own boot-up magic, too */
         if (id == USB_ID(0x041e, 0x3020)) {
@@ -3272,11 +3283,6 @@ static void *snd_usb_audio_probe(struct usb_device *dev,
                 /* it's a fresh one.
                  * now look for an empty slot and create a new card instance
                  */
-                /* first, set the current configuration for this device */
-                if (usb_reset_configuration(dev) < 0) {
-                        snd_printk(KERN_ERR "cannot reset configuration (value 0x%x)\n", get_cfg_desc(config)->bConfigurationValue);
-                        goto __error;
-                }
                 for (i = 0; i < SNDRV_CARDS; i++)
                         if (enable[i] && ! usb_chip[i] &&
                             (vid[i] == -1 || vid[i] == USB_ID_VENDOR(id)) &&
diff --git a/sound/usb/usbaudio.h b/sound/usb/usbaudio.h
index ad9eab211d8f..b5802022bb19 100644
--- a/sound/usb/usbaudio.h
+++ b/sound/usb/usbaudio.h
@@ -249,14 +249,6 @@ void snd_usbmidi_disconnect(struct list_head *p);
 #define get_cfg_desc(cfg)       (&(cfg)->desc)
 #endif
 
-#ifndef usb_pipe_needs_resubmit
-#define usb_pipe_needs_resubmit(pipe) 1
-#endif
-
-#ifndef snd_usb_complete_callback
-#define snd_usb_complete_callback(x) (x)
-#endif
-
 #ifndef snd_usb_get_speed
 #define snd_usb_get_speed(dev) ((dev)->speed)
 #endif
diff --git a/sound/usb/usbmidi.c b/sound/usb/usbmidi.c
index f1a2e2c2e02f..f8aa662562a0 100644
--- a/sound/usb/usbmidi.c
+++ b/sound/usb/usbmidi.c
@@ -47,7 +47,6 @@
 #include <linux/timer.h>
 #include <linux/usb.h>
 #include <sound/core.h>
-#include <sound/minors.h>
 #include <sound/rawmidi.h>
 #include "usbaudio.h"
 
@@ -246,10 +245,8 @@ static void snd_usbmidi_in_urb_complete(struct urb* urb, struct pt_regs *regs)
                 }
         }
 
-        if (usb_pipe_needs_resubmit(urb->pipe)) {
-                urb->dev = ep->umidi->chip->dev;
-                snd_usbmidi_submit_urb(urb, GFP_ATOMIC);
-        }
+        urb->dev = ep->umidi->chip->dev;
+        snd_usbmidi_submit_urb(urb, GFP_ATOMIC);
 }
 
 static void snd_usbmidi_out_urb_complete(struct urb* urb, struct pt_regs *regs)
@@ -863,13 +860,12 @@ static int snd_usbmidi_in_endpoint_create(snd_usb_midi_t* umidi,
                 return -ENOMEM;
         }
         if (ep_info->in_interval)
-                usb_fill_int_urb(ep->urb, umidi->chip->dev, pipe, buffer, length,
-                                 snd_usb_complete_callback(snd_usbmidi_in_urb_complete),
-                                 ep, ep_info->in_interval);
+                usb_fill_int_urb(ep->urb, umidi->chip->dev, pipe, buffer,
+                                 length, snd_usbmidi_in_urb_complete, ep,
+                                 ep_info->in_interval);
         else
-                usb_fill_bulk_urb(ep->urb, umidi->chip->dev, pipe, buffer, length,
-                                  snd_usb_complete_callback(snd_usbmidi_in_urb_complete),
-                                  ep);
+                usb_fill_bulk_urb(ep->urb, umidi->chip->dev, pipe, buffer,
+                                  length, snd_usbmidi_in_urb_complete, ep);
         ep->urb->transfer_flags = URB_NO_TRANSFER_DMA_MAP;
 
         rep->in = ep;
@@ -933,8 +929,7 @@ static int snd_usbmidi_out_endpoint_create(snd_usb_midi_t* umidi,
                 return -ENOMEM;
         }
         usb_fill_bulk_urb(ep->urb, umidi->chip->dev, pipe, buffer,
-                          ep->max_transfer,
-                          snd_usb_complete_callback(snd_usbmidi_out_urb_complete), ep);
+                          ep->max_transfer, snd_usbmidi_out_urb_complete, ep);
         ep->urb->transfer_flags = URB_NO_TRANSFER_DMA_MAP;
 
         spin_lock_init(&ep->buffer_lock);
@@ -1550,46 +1545,45 @@ int snd_usb_create_midi_interface(snd_usb_audio_t* chip,
 
         /* detect the endpoint(s) to use */
         memset(endpoints, 0, sizeof(endpoints));
-        if (!quirk) {
+        switch (quirk ? quirk->type : QUIRK_MIDI_STANDARD_INTERFACE) {
+        case QUIRK_MIDI_STANDARD_INTERFACE:
                 err = snd_usbmidi_get_ms_info(umidi, endpoints);
-        } else {
-                switch (quirk->type) {
-                case QUIRK_MIDI_FIXED_ENDPOINT:
-                        memcpy(&endpoints[0], quirk->data,
-                               sizeof(snd_usb_midi_endpoint_info_t));
-                        err = snd_usbmidi_detect_endpoints(umidi, &endpoints[0], 1);
-                        break;
-                case QUIRK_MIDI_YAMAHA:
-                        err = snd_usbmidi_detect_yamaha(umidi, &endpoints[0]);
-                        break;
-                case QUIRK_MIDI_MIDIMAN:
-                        umidi->usb_protocol_ops = &snd_usbmidi_midiman_ops;
-                        memcpy(&endpoints[0], quirk->data,
-                               sizeof(snd_usb_midi_endpoint_info_t));
-                        err = 0;
-                        break;
-                case QUIRK_MIDI_NOVATION:
-                        umidi->usb_protocol_ops = &snd_usbmidi_novation_ops;
-                        err = snd_usbmidi_detect_per_port_endpoints(umidi, endpoints);
-                        break;
-                case QUIRK_MIDI_RAW:
-                        umidi->usb_protocol_ops = &snd_usbmidi_raw_ops;
-                        err = snd_usbmidi_detect_per_port_endpoints(umidi, endpoints);
-                        break;
-                case QUIRK_MIDI_EMAGIC:
-                        umidi->usb_protocol_ops = &snd_usbmidi_emagic_ops;
-                        memcpy(&endpoints[0], quirk->data,
-                               sizeof(snd_usb_midi_endpoint_info_t));
-                        err = snd_usbmidi_detect_endpoints(umidi, &endpoints[0], 1);
-                        break;
-                case QUIRK_MIDI_MIDITECH:
-                        err = snd_usbmidi_detect_per_port_endpoints(umidi, endpoints);
-                        break;
-                default:
-                        snd_printd(KERN_ERR "invalid quirk type %d\n", quirk->type);
-                        err = -ENXIO;
-                        break;
-                }
+                break;
+        case QUIRK_MIDI_FIXED_ENDPOINT:
+                memcpy(&endpoints[0], quirk->data,
+                       sizeof(snd_usb_midi_endpoint_info_t));
+                err = snd_usbmidi_detect_endpoints(umidi, &endpoints[0], 1);
+                break;
+        case QUIRK_MIDI_YAMAHA:
+                err = snd_usbmidi_detect_yamaha(umidi, &endpoints[0]);
+                break;
+        case QUIRK_MIDI_MIDIMAN:
+                umidi->usb_protocol_ops = &snd_usbmidi_midiman_ops;
+                memcpy(&endpoints[0], quirk->data,
+                       sizeof(snd_usb_midi_endpoint_info_t));
+                err = 0;
+                break;
+        case QUIRK_MIDI_NOVATION:
+                umidi->usb_protocol_ops = &snd_usbmidi_novation_ops;
+                err = snd_usbmidi_detect_per_port_endpoints(umidi, endpoints);
+                break;
+        case QUIRK_MIDI_RAW:
+                umidi->usb_protocol_ops = &snd_usbmidi_raw_ops;
+                err = snd_usbmidi_detect_per_port_endpoints(umidi, endpoints);
+                break;
+        case QUIRK_MIDI_EMAGIC:
+                umidi->usb_protocol_ops = &snd_usbmidi_emagic_ops;
+                memcpy(&endpoints[0], quirk->data,
+                       sizeof(snd_usb_midi_endpoint_info_t));
+                err = snd_usbmidi_detect_endpoints(umidi, &endpoints[0], 1);
+                break;
+        case QUIRK_MIDI_MIDITECH:
+                err = snd_usbmidi_detect_per_port_endpoints(umidi, endpoints);
+                break;
+        default:
+                snd_printd(KERN_ERR "invalid quirk type %d\n", quirk->type);
+                err = -ENXIO;
+                break;
         }
         if (err < 0) {
                 kfree(umidi);
diff --git a/sound/usb/usbmixer.c b/sound/usb/usbmixer.c
index c3c08c9cb46e..e570d140258d 100644
--- a/sound/usb/usbmixer.c
+++ b/sound/usb/usbmixer.c
@@ -911,7 +911,7 @@ static void build_feature_ctl(mixer_build_t *state, unsigned char *desc,
         case USB_ID(0x0672, 0x1041):
                 if (!strcmp(kctl->id.name, "PCM Playback Volume") &&
                     cval->min == -15616) {
-                        snd_printk("using volume control quirk for the UDA1321/N101 chip\n");
+                        snd_printk(KERN_INFO "using volume control quirk for the UDA1321/N101 chip\n");
                         cval->max = -256;
                 }
         }
diff --git a/sound/usb/usbquirks.h b/sound/usb/usbquirks.h
index 948759da6563..ba506c3871f4 100644
--- a/sound/usb/usbquirks.h
+++ b/sound/usb/usbquirks.h
@@ -294,6 +294,7 @@ YAMAHA_DEVICE(0x7010, "UB99"),
         }
 },
 {
+        /* a later revision uses ID 0x0099 */
         USB_DEVICE(0x0582, 0x0005),
         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
                 .vendor_name = "EDIROL",
@@ -384,6 +385,7 @@ YAMAHA_DEVICE(0x7010, "UB99"),
         }
 },
 {
+        /* a later revision uses ID 0x009d */
         USB_DEVICE(0x0582, 0x0009),
         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
                 .vendor_name = "EDIROL",
@@ -532,6 +534,7 @@ YAMAHA_DEVICE(0x7010, "UB99"),
         }
 },
 {
+        /* has ID 0x0013 when not in "Advanced Driver" mode */
         USB_DEVICE(0x0582, 0x0012),
         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
                 .vendor_name = "Roland",
@@ -545,6 +548,7 @@ YAMAHA_DEVICE(0x7010, "UB99"),
         }
 },
 {
+        /* has ID 0x0015 when not in "Advanced Driver" mode */
         USB_DEVICE(0x0582, 0x0014),
         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
                 .vendor_name = "EDIROL",
@@ -558,6 +562,7 @@ YAMAHA_DEVICE(0x7010, "UB99"),
         }
 },
 {
+        /* has ID 0x0017 when not in "Advanced Driver" mode */
         USB_DEVICE(0x0582, 0x0016),
         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
                 .vendor_name = "EDIROL",
@@ -588,6 +593,7 @@ YAMAHA_DEVICE(0x7010, "UB99"),
         }
 },
 {
+        /* has ID 0x001c when not in "Advanced Driver" mode */
         USB_DEVICE(0x0582, 0x001b),
         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
                 .vendor_name = "Roland",
@@ -618,6 +624,7 @@ YAMAHA_DEVICE(0x7010, "UB99"),
         }
 },
 {
+        /* has ID 0x001e when not in "Advanced Driver" mode */
         USB_DEVICE(0x0582, 0x001d),
         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
                 .vendor_name = "Roland",
@@ -631,6 +638,7 @@ YAMAHA_DEVICE(0x7010, "UB99"),
         }
 },
 {
+        /* has ID 0x0024 when not in "Advanced Driver" mode */
         USB_DEVICE(0x0582, 0x0023),
         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
                 .vendor_name = "EDIROL",
@@ -675,6 +683,7 @@ YAMAHA_DEVICE(0x7010, "UB99"),
         }
 },
 {
+        /* has ID 0x0028 when not in "Advanced Driver" mode */
         USB_DEVICE(0x0582, 0x0027),
         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
                 .vendor_name = "EDIROL",
@@ -688,6 +697,7 @@ YAMAHA_DEVICE(0x7010, "UB99"),
         }
 },
 {
+        /* has ID 0x002a when not in "Advanced Driver" mode */
         USB_DEVICE(0x0582, 0x0029),
         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
                 .vendor_name = "EDIROL",
@@ -732,6 +742,7 @@ YAMAHA_DEVICE(0x7010, "UB99"),
         }
 },
 {
+        /* has ID 0x002e when not in "Advanced Driver" mode */
         USB_DEVICE(0x0582, 0x002d),
         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
                 .vendor_name = "Roland",
@@ -745,6 +756,7 @@ YAMAHA_DEVICE(0x7010, "UB99"),
         }
 },
 {
+        /* has ID 0x0030 when not in "Advanced Driver" mode */
         USB_DEVICE(0x0582, 0x002f),
         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
                 .vendor_name = "Roland",
@@ -758,6 +770,7 @@ YAMAHA_DEVICE(0x7010, "UB99"),
         }
 },
 {
+        /* has ID 0x0034 when not in "Advanced Driver" mode */
         USB_DEVICE(0x0582, 0x0033),
         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
                 .vendor_name = "EDIROL",
@@ -770,7 +783,12 @@ YAMAHA_DEVICE(0x7010, "UB99"),
                 }
         }
 },
+        /* TODO: add Roland M-1000 support */
 {
+        /*
+         * Has ID 0x0038 when not in "Advanced Driver" mode;
+         * later revisions use IDs 0x0054 and 0x00a2.
+         */
         USB_DEVICE(0x0582, 0x0037),
         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
                 .vendor_name = "Roland",
@@ -815,6 +833,7 @@ YAMAHA_DEVICE(0x7010, "UB99"),
         }
 },
 {
+        /* has ID 0x0041 when not in "Advanced Driver" mode */
         USB_DEVICE(0x0582, 0x0040),
         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
                 .vendor_name = "Roland",
@@ -828,6 +847,7 @@ YAMAHA_DEVICE(0x7010, "UB99"),
         }
 },
 {
+        /* has ID 0x0043 when not in "Advanced Driver" mode */
         USB_DEVICE(0x0582, 0x0042),
         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
                 .vendor_name = "Roland",
@@ -871,6 +891,7 @@ YAMAHA_DEVICE(0x7010, "UB99"),
         }
 },
 {
+        /* has ID 0x004a when not in "Advanced Driver" mode */
         USB_DEVICE(0x0582, 0x0048),
         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
                 .vendor_name = "EDIROL",
@@ -883,7 +904,9 @@ YAMAHA_DEVICE(0x7010, "UB99"),
                 }
         }
 },
+        /* TODO: add Edirol M-100FX support */
 {
+        /* has ID 0x004f when not in "Advanced Driver" mode */
         USB_DEVICE(0x0582, 0x004d),
         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
                 .vendor_name = "EDIROL",
@@ -931,7 +954,9 @@ YAMAHA_DEVICE(0x7010, "UB99"),
                 .type = QUIRK_MIDI_STANDARD_INTERFACE
         }
 },
+        /* TODO: add Roland EXR support */
 {
+        /* has ID 0x0067 when not in "Advanced Driver" mode */
         USB_DEVICE(0x0582, 0x0065),
         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
                 .vendor_name = "EDIROL",
@@ -945,6 +970,7 @@ YAMAHA_DEVICE(0x7010, "UB99"),
         }
 },
 {
+        /* has ID 0x006b when not in "Advanced Driver" mode */
         USB_DEVICE_VENDOR_SPEC(0x0582, 0x006a),
         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
                 .vendor_name = "Roland",
@@ -958,6 +984,7 @@ YAMAHA_DEVICE(0x7010, "UB99"),
         }
 },
 {
+        /* has ID 0x006e when not in "Advanced Driver" mode */
         USB_DEVICE(0x0582, 0x006d),
         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
                 .vendor_name = "Roland",
@@ -1002,6 +1029,7 @@ YAMAHA_DEVICE(0x7010, "UB99"),
         }
 },
 {
+        /* has ID 0x0076 when not in "Advanced Driver" mode */
         USB_DEVICE(0x0582, 0x0075),
         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
                 .vendor_name = "BOSS",
@@ -1015,10 +1043,11 @@ YAMAHA_DEVICE(0x7010, "UB99"),
         }
 },
 {
+        /* has ID 0x007b when not in "Advanced Driver" mode */
         USB_DEVICE_VENDOR_SPEC(0x0582, 0x007a),
         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
                 .vendor_name = "Roland",
-                /* RD-700SX, RD-300SX */
+                /* "RD" or "RD-700SX"? */
                 .ifnum = 0,
                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
                 .data = & (const snd_usb_midi_endpoint_info_t) {
@@ -1048,6 +1077,15 @@ YAMAHA_DEVICE(0x7010, "UB99"),
                 }
         }
 },
+        /* TODO: add Edirol UA-101 support */
+        /* TODO: add Roland G-70 support */
+        /* TODO: add Roland V-SYNTH XT support */
+        /* TODO: add BOSS GT-PRO support */
+        /* TODO: add Edirol PC-50 support */
+        /* TODO: add Edirol PC-80 support */
+        /* TODO: add Edirol UA-1EX support */
+        /* TODO: add Edirol UM-3 support */
+        /* TODO: add Edirol MD-P1 support */
 
 /* Midiman/M-Audio devices */
 {
diff --git a/sound/usb/usx2y/usX2Yhwdep.c b/sound/usb/usx2y/usX2Yhwdep.c
index 0281a362857a..8abe08611df6 100644
--- a/sound/usb/usx2y/usX2Yhwdep.c
+++ b/sound/usb/usx2y/usX2Yhwdep.c
@@ -193,7 +193,7 @@ static int usX2Y_create_alsa_devices(snd_card_t* card)
 
         do {
                 if ((err = usX2Y_create_usbmidi(card)) < 0) {
-                        snd_printk("usX2Y_create_alsa_devices: usX2Y_create_usbmidi error %i \n", err);
+                        snd_printk(KERN_ERR "usX2Y_create_alsa_devices: usX2Y_create_usbmidi error %i \n", err);
                         break;
                 }
                 if ((err = usX2Y_audio_create(card)) < 0) 
@@ -224,7 +224,7 @@ static int snd_usX2Y_hwdep_dsp_load(snd_hwdep_t *hw, snd_hwdep_dsp_image_t *dsp)
                 }
                 err = usb_set_interface(dev, 0, 1);
                 if (err)
-                        snd_printk("usb_set_interface error \n");
+                        snd_printk(KERN_ERR "usb_set_interface error \n");
                 else
                         err = usb_bulk_msg(dev, usb_sndbulkpipe(dev, 2), buf, dsp->length, &lret, 6000);
                 kfree(buf);
@@ -235,17 +235,17 @@ static int snd_usX2Y_hwdep_dsp_load(snd_hwdep_t *hw, snd_hwdep_dsp_image_t *dsp)
                 msleep(250);                            // give the device some time
                 err = usX2Y_AsyncSeq04_init(priv);
                 if (err) {
-                        snd_printk("usX2Y_AsyncSeq04_init error \n");
+                        snd_printk(KERN_ERR "usX2Y_AsyncSeq04_init error \n");
                         return err;
                 }
                 err = usX2Y_In04_init(priv);
                 if (err) {
-                        snd_printk("usX2Y_In04_init error \n");
+                        snd_printk(KERN_ERR "usX2Y_In04_init error \n");
                         return err;
                 }
                 err = usX2Y_create_alsa_devices(hw->card);
                 if (err) {
-                        snd_printk("usX2Y_create_alsa_devices error %i \n", err);
+                        snd_printk(KERN_ERR "usX2Y_create_alsa_devices error %i \n", err);
                         snd_card_free(hw->card);
                         return err;
                 }
diff --git a/sound/usb/usx2y/usbusx2y.c b/sound/usb/usx2y/usbusx2y.c
index e6e6da159671..cf77313c609d 100644
--- a/sound/usb/usx2y/usbusx2y.c
+++ b/sound/usb/usx2y/usbusx2y.c
@@ -251,9 +251,8 @@ static void i_usX2Y_In04Int(struct urb* urb, struct pt_regs *regs)
                         }
                 }
 
-        if (err) {
-                snd_printk("In04Int() usb_submit_urb err=%i\n", err);
-        }
+        if (err)
+                snd_printk(KERN_ERR "In04Int() usb_submit_urb err=%i\n", err);
 
         urb->dev = usX2Y->chip.dev;
         usb_submit_urb(urb, GFP_ATOMIC);
diff --git a/sound/usb/usx2y/usbusx2yaudio.c b/sound/usb/usx2y/usbusx2yaudio.c
index 0f09e0de52dd..affda973cece 100644
--- a/sound/usb/usx2y/usbusx2yaudio.c
+++ b/sound/usb/usx2y/usbusx2yaudio.c
@@ -78,7 +78,7 @@ static int usX2Y_urb_capt_retire(snd_usX2Y_substream_t *subs)
         for (i = 0; i < nr_of_packs(); i++) {
                 cp = (unsigned char*)urb->transfer_buffer + urb->iso_frame_desc[i].offset;
                 if (urb->iso_frame_desc[i].status) { /* active? hmm, skip this */
-                        snd_printk("activ frame status %i. Most propably some hardware problem.\n", urb->iso_frame_desc[i].status);
+                        snd_printk(KERN_ERR "activ frame status %i. Most propably some hardware problem.\n", urb->iso_frame_desc[i].status);
                         return urb->iso_frame_desc[i].status;
                 }
                 len = urb->iso_frame_desc[i].actual_length / usX2Y->stride;
@@ -134,7 +134,7 @@ static int usX2Y_urb_play_prepare(snd_usX2Y_substream_t *subs,
                 counts = cap_urb->iso_frame_desc[pack].actual_length / usX2Y->stride;
                 count += counts;
                 if (counts < 43 || counts > 50) {
-                        snd_printk("should not be here with counts=%i\n", counts);
+                        snd_printk(KERN_ERR "should not be here with counts=%i\n", counts);
                         return -EPIPE;
                 }
                 /* set up descriptor */
@@ -196,7 +196,7 @@ static int usX2Y_urb_submit(snd_usX2Y_substream_t *subs, struct urb *urb, int fr
         urb->hcpriv = NULL;
         urb->dev = subs->usX2Y->chip.dev; /* we need to set this at each time */
         if ((err = usb_submit_urb(urb, GFP_ATOMIC)) < 0) {
-                snd_printk("usb_submit_urb() returned %i\n", err);
+                snd_printk(KERN_ERR "usb_submit_urb() returned %i\n", err);
                 return err;
         }
         return 0;
@@ -283,16 +283,16 @@ static void usX2Y_clients_stop(usX2Ydev_t *usX2Y)
 
 static void usX2Y_error_urb_status(usX2Ydev_t *usX2Y, snd_usX2Y_substream_t *subs, struct urb *urb)
 {
-        snd_printk("ep=%i stalled with status=%i\n", subs->endpoint, urb->status);
+        snd_printk(KERN_ERR "ep=%i stalled with status=%i\n", subs->endpoint, urb->status);
         urb->status = 0;
         usX2Y_clients_stop(usX2Y);
 }
 
 static void usX2Y_error_sequence(usX2Ydev_t *usX2Y, snd_usX2Y_substream_t *subs, struct urb *urb)
 {
-        snd_printk("Sequence Error!(hcd_frame=%i ep=%i%s;wait=%i,frame=%i).\n"
-                   "Most propably some urb of usb-frame %i is still missing.\n"
-                   "Cause could be too long delays in usb-hcd interrupt handling.\n",
+        snd_printk(KERN_ERR "Sequence Error!(hcd_frame=%i ep=%i%s;wait=%i,frame=%i).\n"
+                   KERN_ERR "Most propably some urb of usb-frame %i is still missing.\n"
+                   KERN_ERR "Cause could be too long delays in usb-hcd interrupt handling.\n",
                    usb_get_current_frame_number(usX2Y->chip.dev),
                    subs->endpoint, usb_pipein(urb->pipe) ? "in" : "out", usX2Y->wait_iso_frame, urb->start_frame, usX2Y->wait_iso_frame);
         usX2Y_clients_stop(usX2Y);
@@ -653,9 +653,8 @@ static void i_usX2Y_04Int(struct urb* urb, struct pt_regs *regs)
 {
         usX2Ydev_t*     usX2Y = urb->context;
         
-        if (urb->status) {
-                snd_printk("snd_usX2Y_04Int() urb->status=%i\n", urb->status);
-        }
+        if (urb->status)
+                snd_printk(KERN_ERR "snd_usX2Y_04Int() urb->status=%i\n", urb->status);
         if (0 == --usX2Y->US04->len)
                 wake_up(&usX2Y->In04WaitQueue);
 }
@@ -740,7 +739,7 @@ static int usX2Y_format_set(usX2Ydev_t *usX2Y, snd_pcm_format_t format)
         }
         usb_kill_urb(usX2Y->In04urb);
         if ((err = usb_set_interface(usX2Y->chip.dev, 0, alternate))) {
-                snd_printk("usb_set_interface error \n");
+                snd_printk(KERN_ERR "usb_set_interface error \n");
                 return err;
         }
         usX2Y->In04urb->dev = usX2Y->chip.dev;
@@ -787,7 +786,7 @@ static int snd_usX2Y_pcm_hw_params(snd_pcm_substream_t *substream,
                 }
         }
         if (0 > (err = snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params)))) {
-                snd_printk("snd_pcm_lib_malloc_pages(%p, %i) returned %i\n", substream, params_buffer_bytes(hw_params), err);
+                snd_printk(KERN_ERR "snd_pcm_lib_malloc_pages(%p, %i) returned %i\n", substream, params_buffer_bytes(hw_params), err);
                 return err;
         }
         return 0;
diff --git a/sound/usb/usx2y/usx2yhwdeppcm.c b/sound/usb/usx2y/usx2yhwdeppcm.c
index d0199c4e5551..0dc828ff9e94 100644
--- a/sound/usb/usx2y/usx2yhwdeppcm.c
+++ b/sound/usb/usx2y/usx2yhwdeppcm.c
@@ -73,7 +73,7 @@ static int usX2Y_usbpcm_urb_capt_retire(snd_usX2Y_substream_t *subs)
         }
         for (i = 0; i < nr_of_packs(); i++) {
                 if (urb->iso_frame_desc[i].status) { /* active? hmm, skip this */
-                        snd_printk("activ frame status %i. Most propably some hardware problem.\n", urb->iso_frame_desc[i].status);
+                        snd_printk(KERN_ERR "activ frame status %i. Most propably some hardware problem.\n", urb->iso_frame_desc[i].status);
                         return urb->iso_frame_desc[i].status;
                 }
                 lens += urb->iso_frame_desc[i].actual_length / usX2Y->stride;
@@ -126,7 +126,7 @@ static int usX2Y_hwdep_urb_play_prepare(snd_usX2Y_substream_t *subs,
                 /* calculate the size of a packet */
                 counts = shm->captured_iso[shm->playback_iso_head].length / usX2Y->stride;
                 if (counts < 43 || counts > 50) {
-                        snd_printk("should not be here with counts=%i\n", counts);
+                        snd_printk(KERN_ERR "should not be here with counts=%i\n", counts);
                         return -EPIPE;
                 }
                 /* set up descriptor */