diff --git a/include/linux/usb/ch9.h b/include/linux/usb/ch9.h
index 0fd3fbd..0f138de 100644
--- a/include/linux/usb/ch9.h
+++ b/include/linux/usb/ch9.h
@@ -377,6 +377,11 @@ struct usb_endpoint_descriptor {
 #define USB_ENDPOINT_NUMBER_MASK	0x0f	/* in bEndpointAddress */
 #define USB_ENDPOINT_DIR_MASK		0x80
 
+#define USB_ENDPOINT_USAGE_MASK		0x30
+#define USB_ENDPOINT_USAGE_DATA		0x00
+#define USB_ENDPOINT_USAGE_FEEDBACK	0x10
+#define USB_ENDPOINT_USAGE_IMPLICIT_FB	0x20	/* Implicit feedback Data endpoint */
+
 #define USB_ENDPOINT_SYNCTYPE		0x0c
 #define USB_ENDPOINT_SYNC_NONE		(0 << 2)
 #define USB_ENDPOINT_SYNC_ASYNC		(1 << 2)
diff --git a/sound/usb/card.h b/sound/usb/card.h
index ae4251d..b9ba132 100644
--- a/sound/usb/card.h
+++ b/sound/usb/card.h
@@ -3,7 +3,7 @@
 
 #define MAX_PACKS	20
 #define MAX_PACKS_HS	(MAX_PACKS * 8)	/* in high speed mode */
-#define MAX_URBS	8
+#define MAX_URBS	16
 #define SYNC_URBS	4	/* always four urbs for sync */
 #define MAX_QUEUE	24	/* try not to exceed this queue length, in ms */
 
@@ -36,9 +36,11 @@ struct snd_urb_ctx {
 	struct snd_usb_substream *subs;
 	int index;	/* index for urb array */
 	int packets;	/* number of packets per urb */
+	int packet_size[MAX_PACKS_HS]; /* size of packets for next submission */
 };
 
 struct snd_urb_ops {
+	int (*prepare_size)(struct snd_usb_substream *subs, struct snd_pcm_runtime *runtime, struct urb *u);
 	int (*prepare)(struct snd_usb_substream *subs, struct snd_pcm_runtime *runtime, struct urb *u);
 	int (*retire)(struct snd_usb_substream *subs, struct snd_pcm_runtime *runtime, struct urb *u);
 	int (*prepare_sync)(struct snd_usb_substream *subs, struct snd_pcm_runtime *runtime, struct urb *u);
@@ -73,6 +75,8 @@ struct snd_usb_substream {
 	unsigned int fill_max: 1;	/* fill max packet size always */
 	unsigned int txfr_quirk:1;	/* allow sub-frame alignment */
 	unsigned int fmt_type;		/* USB audio format type (1-3) */
+	unsigned int next_out_urb;	/* index of next URB to use for output
+					   (implicit feedback mode only) */
 
 	unsigned int running: 1;	/* running status */
 
@@ -103,6 +107,8 @@ struct snd_usb_stream {
 	unsigned int fmt_type;		/* USB audio format type (1-3) */
 	struct snd_usb_substream substream[2];
 	struct list_head list;
+	unsigned int implicit_feedback: 1; 	/* stream uses its capture data
+						   substream to clock its playback substream */
 };
 
 #endif /* __USBAUDIO_CARD_H */
diff --git a/sound/usb/pcm.c b/sound/usb/pcm.c
index b8dcbf4..1cd1db2 100644
--- a/sound/usb/pcm.c
+++ b/sound/usb/pcm.c
@@ -185,7 +185,8 @@ int snd_usb_init_pitch(struct snd_usb_audio *chip, int iface,
 /*
  * find a matching format and set up the interface
  */
-static int set_format(struct snd_usb_substream *subs, struct audioformat *fmt)
+int snd_usb_set_pcm_format(struct snd_usb_substream *subs,
+			   struct audioformat *fmt)
 {
 	struct usb_device *dev = subs->dev;
 	struct usb_host_interface *alts;
@@ -206,6 +207,8 @@ static int set_format(struct snd_usb_substream *subs, struct audioformat *fmt)
 	if (fmt == subs->cur_audiofmt)
 		return 0;
 
+printk(KERN_ERR "%s() :%d\n", __func__, __LINE__);
+
 	/* close the old interface */
 	if (subs->interface >= 0 && subs->interface != fmt->iface) {
 		if (usb_set_interface(subs->dev, subs->interface, 0) < 0) {
@@ -292,6 +295,11 @@ static int set_format(struct snd_usb_substream *subs, struct audioformat *fmt)
 	if (fmt->attributes & UAC_EP_CS_ATTR_FILL_MAX)
 		subs->fill_max = 1;
 
+	if (!is_playback &&
+	    (fmt->ep_attr & USB_ENDPOINT_XFERTYPE_MASK) == USB_ENDPOINT_XFER_ISOC &&
+	    (fmt->ep_attr & USB_ENDPOINT_USAGE_MASK) == USB_ENDPOINT_USAGE_IMPLICIT_FB)
+		subs->stream->implicit_feedback = 1;
+
 	if ((err = snd_usb_init_pitch(subs->stream->chip, subs->interface, alts, fmt)) < 0)
 		return err;
 
@@ -299,6 +307,9 @@ static int set_format(struct snd_usb_substream *subs, struct audioformat *fmt)
 
 	snd_usb_set_format_quirk(subs, fmt);
 
+	if (subs->stream->implicit_feedback)
+		snd_printk(KERN_INFO "operating in implicit feedback mode\n");
+
 #if 0
 	printk(KERN_DEBUG
 	       "setting done: format = %d, rate = %d..%d, channels = %d\n",
@@ -347,7 +358,16 @@ static int snd_usb_hw_params(struct snd_pcm_substream *substream,
 	changed = subs->cur_audiofmt != fmt ||
 		subs->period_bytes != params_period_bytes(hw_params) ||
 		subs->cur_rate != rate;
-	if ((ret = set_format(subs, fmt)) < 0)
+
+	if (subs->stream->implicit_feedback) {
+		struct snd_usb_substream *other =
+			&subs->stream->substream[!subs->direction];
+
+		if (other && other->running && changed)
+			return -EBUSY;
+	}
+
+	if ((ret = snd_usb_set_pcm_format(subs, fmt)) < 0)
 		return ret;
 
 	if (subs->cur_rate != rate) {
@@ -815,6 +835,9 @@ static int snd_usb_pcm_close(struct snd_pcm_substream *substream, int direction)
 	struct snd_usb_stream *as = snd_pcm_substream_chip(substream);
 	struct snd_usb_substream *subs = &as->substream[direction];
 
+	if (snd_usb_capture_subs_used_by_playback(subs))
+		return 0;
+
 	if (!as->chip->shutdown && subs->interface >= 0) {
 		usb_set_interface(subs->dev, subs->interface, 0);
 		subs->interface = -1;
diff --git a/sound/usb/pcm.h b/sound/usb/pcm.h
index ed3e283..9e02cf8 100644
--- a/sound/usb/pcm.h
+++ b/sound/usb/pcm.h
@@ -3,6 +3,9 @@
 
 void snd_usb_set_pcm_ops(struct snd_pcm *pcm, int stream);
 
+int snd_usb_set_pcm_format(struct snd_usb_substream *subs,
+			   struct audioformat *fmt);
+
 int snd_usb_init_pitch(struct snd_usb_audio *chip, int iface,
 		       struct usb_host_interface *alts,
 		       struct audioformat *fmt);
diff --git a/sound/usb/quirks.c b/sound/usb/quirks.c
index 090e193..1353663 100644
--- a/sound/usb/quirks.c
+++ b/sound/usb/quirks.c
@@ -644,6 +644,10 @@ void snd_usb_set_format_quirk(struct snd_usb_substream *subs,
 	case USB_ID(0x041e, 0x3f19): /* E-Mu 0204 USB */
 		set_format_emu_quirk(subs, fmt);
 		break;
+	case USB_ID(0x0763, 0x2080): /* M-Audio FastTrack Ultra */
+	case USB_ID(0x0763, 0x2081):
+		subs->stream->implicit_feedback = 1;
+		break;
 	}
 }
 
diff --git a/sound/usb/urb.c b/sound/usb/urb.c
index e184349..3b7a81b 100644
--- a/sound/usb/urb.c
+++ b/sound/usb/urb.c
@@ -29,6 +29,25 @@
 #include "urb.h"
 #include "pcm.h"
 
+/* Streaming modes
+ *
+ * This driver can operate in different streaming modes which use the internal
+ * functions of this file differently.
+ *
+ * One is independent input and output streaming which is the default and most
+ * usual for USB audio devices. IN endpoints (device sinks) can either take any
+ * amount of data that is sent or provide a sync endpoint to tell the host at
+ * which data rate the stream runs at. This streaming model allows playback and
+ * capture streams to be started independently.
+ *
+ * The other is an 'implicit feedback mode' in which the device does not tell
+ * the host its speed through an sync endpoint but expects the driver to always
+ * receive the record stream and use the data rate to determine the actual
+ * device speed. For the USB side, this means that the driver has to queue
+ * capture URBs even if the userspace is not interested in actual capture data.
+ *
+ */
+
 /*
  * convert a sampling rate into our full speed format (fs/1000 in Q16.16)
  * this will overflow at approx 524 kHz
@@ -135,10 +154,26 @@ static int wait_clear_urbs(struct snd_usb_substream *subs)
 		schedule_timeout_uninterruptible(1);
 	} while (time_before(jiffies, end_time));
 	if (alive)
-		snd_printk(KERN_ERR "timeout: still %d active urbs..\n", alive);
+		snd_printk(KERN_ERR "timeout: still %d active urbs (%s)\n",
+			   alive, subs->direction == SNDRV_PCM_STREAM_CAPTURE ?
+						"capture" : "playback");
 	return 0;
 }
 
+int snd_usb_capture_subs_used_by_playback(struct snd_usb_substream *capture)
+{
+	struct snd_usb_stream *stream = capture->stream;
+	struct snd_usb_substream *playback = &stream->substream[SNDRV_PCM_STREAM_PLAYBACK];
+
+	if (!playback)
+		return 0;
+
+	if (capture->direction != SNDRV_PCM_STREAM_CAPTURE)
+		return 0;
+
+	return stream->implicit_feedback && playback->running;
+}
+
 /*
  * release a substream
  */
@@ -146,6 +181,9 @@ void snd_usb_release_substream_urbs(struct snd_usb_substream *subs, int force)
 {
 	int i;
 
+	if (snd_usb_capture_subs_used_by_playback(subs))
+		return;
+
 	/* stop urbs (to be sure) */
 	deactivate_urbs(subs, force, 1);
 	wait_clear_urbs(subs);
@@ -168,17 +206,34 @@ static void snd_complete_urb(struct urb *urb)
 	struct snd_urb_ctx *ctx = urb->context;
 	struct snd_usb_substream *subs = ctx->subs;
 	struct snd_pcm_substream *substream = ctx->subs->pcm_substream;
+	int is_playback = subs->direction == SNDRV_PCM_STREAM_PLAYBACK;
 	int err = 0;
 
 	if ((subs->running && subs->ops.retire(subs, substream->runtime, urb)) ||
-	    !subs->running || /* can be stopped during retire callback */
-	    (err = subs->ops.prepare(subs, substream->runtime, urb)) < 0 ||
-	    (err = usb_submit_urb(urb, GFP_ATOMIC)) < 0) {
-		clear_bit(ctx->index, &subs->active_mask);
-		if (err < 0) {
-			snd_printd(KERN_ERR "cannot submit urb (err = %d)\n", err);
-			snd_pcm_stop(substream, SNDRV_PCM_STATE_XRUN);
-		}
+	    !subs->running /* can be stopped during retire callback */)
+		goto exit_clear_bit;
+
+	/*
+	 * For devices that operate in implicit feedback mode, we won't requeue
+	 * the URB at this point. Instead, we will wait for the next record
+	 * input packet to arrive and queue a packet from the corresponding
+	 * retire callback.
+	 */
+	if (is_playback && subs->stream->implicit_feedback)
+		goto exit_clear_bit;
+
+	if ((err = subs->ops.prepare(subs, substream->runtime, urb)) == 0 &&
+	    (err = subs->ops.prepare_size(subs, substream->runtime, urb)) == 0 &&
+	    (err = usb_submit_urb(urb, GFP_ATOMIC)) < 0)
+		return;
+
+	/* fall through */
+
+exit_clear_bit:
+	clear_bit(ctx->index, &subs->active_mask);
+	if (err < 0) {
+		snd_printd(KERN_ERR "cannot submit urb (err = %d)\n", err);
+		snd_pcm_stop(substream, SNDRV_PCM_STATE_XRUN);
 	}
 }
 
@@ -250,7 +305,7 @@ int snd_usb_init_substream_urbs(struct snd_usb_substream *subs,
 	else
 		packs_per_ms = 1;
 
-	if (is_playback) {
+	if (is_playback && !subs->stream->implicit_feedback) {
 		urb_packs = max(chip->nrpacks, 1);
 		urb_packs = min(urb_packs, (unsigned int)MAX_PACKS);
 	} else
@@ -260,7 +315,7 @@ int snd_usb_init_substream_urbs(struct snd_usb_substream *subs,
 		urb_packs = min(urb_packs, 1U << subs->syncinterval);
 
 	/* decide how many packets to be used */
-	if (is_playback) {
+	if (is_playback && !subs->stream->implicit_feedback) {
 		unsigned int minsize, maxpacks;
 		/* determine how small a packet can be */
 		minsize = (subs->freqn >> (16 - subs->datainterval))
@@ -320,6 +375,9 @@ int snd_usb_init_substream_urbs(struct snd_usb_substream *subs,
 		u->urb->complete = snd_complete_urb;
 	}
 
+	if (subs->stream->implicit_feedback)
+		subs->syncpipe = 0;
+
 	if (subs->syncpipe) {
 		/* allocate and initialize sync urbs */
 		subs->syncbuf = usb_alloc_coherent(subs->dev, SYNC_URBS * 4,
@@ -410,6 +468,15 @@ static int retire_capture_sync_urb(struct snd_usb_substream *subs,
 }
 
 /*
+ * prepare data sizes for caputure urbs. nothing to do. */
+static int prepare_capture_size_urb(struct snd_usb_substream *subs,
+				    struct snd_pcm_runtime *runtime,
+				    struct urb *urb)
+{
+	return 0;
+}
+
+/*
  * prepare urb for capture data pipe
  *
  * fill the offset and length of each descriptor.
@@ -438,11 +505,93 @@ static int prepare_capture_urb(struct snd_usb_substream *subs,
 	return 0;
 }
 
+static int queue_next_playback_urb(struct snd_usb_substream *capture,
+				   struct snd_pcm_runtime *runtime,
+				   struct urb *in_urb)
+{
+	unsigned int stride = runtime->frame_bits >> 3;
+	unsigned int bytes = 0, i;
+	unsigned long flags;
+	struct snd_urb_ctx *in_ctx = in_urb->context;
+	struct snd_usb_substream *playback =
+		&capture->stream->substream[SNDRV_PCM_STREAM_PLAYBACK];
+	struct snd_urb_ctx *out_ctx;
+	struct urb *out_urb;
+	int err;
+
+	/* this may happen during substream transitions */
+	if (stride == 0)
+		return 0;
+
+	if (!playback->running)
+		return 0;
+
+	/* Count overall packet size */
+	for (i = 0; i < in_ctx->packets; i++)
+		if (in_urb->iso_frame_desc[i].status == 0)
+			bytes += in_urb->iso_frame_desc[i].actual_length;
+
+	/* skip empty packets. At least M-Audio's Fast Track Ultra stops
+	 * streaming once it received a 0-byte OUT URB */
+	if (bytes == 0)
+		return 0;
+
+	spin_lock_irqsave(&capture->lock, flags);
+	out_ctx = &playback->dataurb[playback->next_out_urb];
+	spin_unlock_irqrestore(&capture->lock, flags);
+
+	out_urb = out_ctx->urb;
+
+	/* If the output urb is still in use, we have to drop this packet.
+	 * This usually only occurs when the stream is starting */
+	if (test_bit(out_ctx->index, &playback->active_mask))
+		return 0;
+
+	/*
+	 * Iterate through the inbound packet and prepare the lengths
+	 * for output packets. The OUT packet we are about to send will
+	 * have the same amount of payload than the IN packet we just
+	 * received.
+	 */
+
+	out_ctx->packets = in_ctx->packets;
+	for (i = 0; i < in_ctx->packets; i++) {
+		if (in_urb->iso_frame_desc[i].status == 0)
+			out_ctx->packet_size[i] =
+				in_urb->iso_frame_desc[i].actual_length / stride;
+		else
+			out_ctx->packet_size[i] = 0;
+	}
+
+	err = playback->ops.prepare(playback, playback->pcm_substream->runtime, out_urb);
+	if (err < 0)
+		return err;
+
+	err = usb_submit_urb(out_urb, GFP_ATOMIC);
+	if (err < 0) {
+		snd_printk(KERN_ERR "%s(): Unable to submit urb #%d: %d\n",
+				__func__, out_ctx->index, err);
+		snd_pcm_stop(capture->pcm_substream, SNDRV_PCM_STATE_XRUN);
+		snd_pcm_stop(playback->pcm_substream, SNDRV_PCM_STATE_XRUN);
+		return err;
+	} else {
+		spin_lock_irqsave(&capture->lock, flags);
+		set_bit(out_ctx->index, &playback->active_mask);
+		playback->next_out_urb++;
+		playback->next_out_urb %= playback->nurbs;
+		spin_unlock_irqrestore(&capture->lock, flags);
+	}
+
+	return 0;
+}
+
 /*
  * process after capture complete
  *
  * copy the data from each desctiptor to the pcm buffer, and
  * update the current position.
+ *
+ * For implicit feedback mode, eventually call queue_next_playback_urb().
  */
 static int retire_capture_urb(struct snd_usb_substream *subs,
 			      struct snd_pcm_runtime *runtime,
@@ -499,16 +648,24 @@ static int retire_capture_urb(struct snd_usb_substream *subs,
 	}
 	if (period_elapsed)
 		snd_pcm_period_elapsed(subs->pcm_substream);
+
+	if (subs->stream->implicit_feedback)
+		return queue_next_playback_urb(subs, runtime, urb);
+
 	return 0;
 }
 
 /*
- * Process after capture complete when paused.  Nothing to do.
+ * Process after capture complete when paused.
+ * For implicit feedback mode, eventually call queue_next_playback_urb().
  */
 static int retire_paused_capture_urb(struct snd_usb_substream *subs,
 				     struct snd_pcm_runtime *runtime,
 				     struct urb *urb)
 {
+	if (subs->stream->implicit_feedback)
+		return queue_next_playback_urb(subs, runtime, urb);
+
 	return 0;
 }
 
@@ -615,6 +772,25 @@ static int snd_usb_audio_next_packet_size(struct snd_usb_substream *subs)
 }
 
 /*
+ * Prepare urb data sizes for asynchronous output streaming.
+ * This is seperated from the code that fills the data because syncronous
+ * streaming (in implicit feedback mode) uses a different method to determine
+ * the output data packet sizes.
+ */
+static int prepare_playback_size_urb(struct snd_usb_substream *subs,
+				     struct snd_pcm_runtime *runtime,
+				     struct urb *urb)
+{
+	int i;
+	struct snd_urb_ctx *ctx = urb->context;
+
+	for (i = 0; i < ctx->packets; ++i)
+		ctx->packet_size[i] = snd_usb_audio_next_packet_size(subs);
+
+	return 0;
+}
+
+/*
  * Prepare urb for streaming before playback starts or when paused.
  *
  * We don't have any data, so we send silence.
@@ -630,7 +806,7 @@ static int prepare_nodata_playback_urb(struct snd_usb_substream *subs,
 	offs = 0;
 	urb->dev = ctx->subs->dev;
 	for (i = 0; i < ctx->packets; ++i) {
-		counts = snd_usb_audio_next_packet_size(subs);
+		counts = ctx->packet_size[i];
 		urb->iso_frame_desc[i].offset = offs * stride;
 		urb->iso_frame_desc[i].length = counts * stride;
 		offs += counts;
@@ -668,7 +844,7 @@ static int prepare_playback_urb(struct snd_usb_substream *subs,
 	urb->number_of_packets = 0;
 	spin_lock_irqsave(&subs->lock, flags);
 	for (i = 0; i < ctx->packets; i++) {
-		counts = snd_usb_audio_next_packet_size(subs);
+		counts = ctx->packet_size[i];
 		/* set up descriptor */
 		urb->iso_frame_desc[i].offset = frames * stride;
 		urb->iso_frame_desc[i].length = counts * stride;
@@ -786,6 +962,10 @@ static int start_urbs(struct snd_usb_substream *subs, struct snd_pcm_runtime *ru
 	for (i = 0; i < subs->nurbs; i++) {
 		if (snd_BUG_ON(!subs->dataurb[i].urb))
 			return -EINVAL;
+		if (subs->ops.prepare_size(subs, runtime, subs->dataurb[i].urb) < 0) {
+			snd_printk(KERN_ERR "cannot prepare datapipe for urb %d\n", i);
+			goto __error;
+		}
 		if (subs->ops.prepare(subs, runtime, subs->dataurb[i].urb) < 0) {
 			snd_printk(KERN_ERR "cannot prepare datapipe for urb %d\n", i);
 			goto __error;
@@ -805,6 +985,7 @@ static int start_urbs(struct snd_usb_substream *subs, struct snd_pcm_runtime *ru
 	subs->active_mask = 0;
 	subs->unlink_mask = 0;
 	subs->running = 1;
+
 	for (i = 0; i < subs->nurbs; i++) {
 		err = usb_submit_urb(subs->dataurb[i].urb, GFP_ATOMIC);
 		if (err < 0) {
@@ -840,12 +1021,14 @@ static int start_urbs(struct snd_usb_substream *subs, struct snd_pcm_runtime *ru
  */
 static struct snd_urb_ops audio_urb_ops[2] = {
 	{
+		.prepare_size =	prepare_playback_size_urb,
 		.prepare =	prepare_nodata_playback_urb,
 		.retire =	retire_playback_urb,
 		.prepare_sync =	prepare_playback_sync_urb,
 		.retire_sync =	retire_playback_sync_urb,
 	},
 	{
+		.prepare_size =	prepare_capture_size_urb,
 		.prepare =	prepare_capture_urb,
 		.retire =	retire_capture_urb,
 		.prepare_sync =	prepare_capture_sync_urb,
@@ -892,6 +1075,18 @@ int snd_usb_substream_playback_trigger(struct snd_pcm_substream *substream, int
 		subs->ops.prepare = prepare_playback_urb;
 		return 0;
 	case SNDRV_PCM_TRIGGER_STOP:
+		if (subs->stream->implicit_feedback) {
+			struct snd_usb_substream *capture =
+				&subs->stream->substream[SNDRV_PCM_STREAM_CAPTURE];
+			if (capture &&
+			    capture->pcm_substream &&
+			    capture->pcm_substream->runtime) {
+				struct snd_pcm_runtime *runtime =
+					capture->pcm_substream->runtime;
+				if (runtime->status->state != SNDRV_PCM_STATE_OPEN)
+					deactivate_urbs(capture, 0, 0);
+			}
+		}
 		return deactivate_urbs(subs, 0, 0);
 	case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
 		subs->ops.prepare = prepare_nodata_playback_urb;
@@ -908,8 +1103,15 @@ int snd_usb_substream_capture_trigger(struct snd_pcm_substream *substream, int c
 	switch (cmd) {
 	case SNDRV_PCM_TRIGGER_START:
 		subs->ops.retire = retire_capture_urb;
-		return start_urbs(subs, substream->runtime);
+		if (!subs->running)
+			return start_urbs(subs, substream->runtime);
+
+		return 0;
 	case SNDRV_PCM_TRIGGER_STOP:
+		if (snd_usb_capture_subs_used_by_playback(subs)) {
+			subs->ops.retire = retire_paused_capture_urb;
+			return 0;
+		}
 		return deactivate_urbs(subs, 0, 0);
 	case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
 		subs->ops.retire = retire_paused_capture_urb;
@@ -922,18 +1124,90 @@ int snd_usb_substream_capture_trigger(struct snd_pcm_substream *substream, int c
 	return -EINVAL;
 }
 
+/*
+ * Fake a start for the capture stream.
+ * Only used for implicit feedback mode.
+ */
+static int start_capture_stream(struct snd_usb_substream *playback,
+				struct snd_usb_substream *capture,
+				struct snd_pcm_runtime *runtime)
+{
+	int err;
+
+
+usb_set_interface(capture->dev, 2, 1);
+
+	capture->ops.prepare = prepare_capture_urb;
+	capture->ops.retire = retire_paused_capture_urb;
+	capture->pcm_substream = playback->pcm_substream;
+	err = snd_usb_set_pcm_format(capture, playback->cur_audiofmt);
+	if (err)
+		return err;
+
+	err = snd_usb_init_substream_urbs(capture, playback->period_bytes,
+					  playback->cur_rate,
+					  (playback->curpacksize /
+					   playback->curframesize) * 8);
+	if (err)
+		return err;
+
+	return start_urbs(capture, runtime);
+}
+
 int snd_usb_substream_prepare(struct snd_usb_substream *subs,
 			      struct snd_pcm_runtime *runtime)
 {
 	/* clear urbs (to be sure) */
-	deactivate_urbs(subs, 0, 1);
-	wait_clear_urbs(subs);
+	if (!snd_usb_capture_subs_used_by_playback(subs)) {
+		deactivate_urbs(subs, 0, 1);
+		wait_clear_urbs(subs);
+	}
 
-	/* 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_nodata_playback_urb;
-		return start_urbs(subs, runtime);
+
+		if (subs->stream->implicit_feedback) {
+			struct snd_usb_substream *capture =
+				&subs->stream->substream[SNDRV_PCM_STREAM_CAPTURE];
+
+			if (!capture) {
+				snd_printk(KERN_ERR "Unable to start implicit feedback mode "
+					   "without capture stream\n");
+				return -EINVAL;
+			}
+
+			/*
+			 * Mark the stream running without calling start_urbs().
+			 * We don't want to queue any URBs yet at this point
+			 */
+			subs->active_mask = 0;
+			subs->unlink_mask = 0;
+			subs->running = 1;
+
+			/*
+			 * if this stream is in implicit feedback mode, start the
+			 * capture stream now as the playback stream relies on the
+			 * amount of data we see on the capture IN endpoint.
+			 */
+			if (!capture->running) {
+				int err = start_capture_stream(subs, capture, runtime);
+				if (err < 0) {
+					deactivate_urbs(subs, 0, 0);
+					return err;
+				}
+			}
+		} else {
+			/*
+			 * For playback, submit the URBs now; otherwise, the
+			 * first hwptr_done updates for all URBs would happen
+			 * at the same time when starting.
+			 * However, don't start the stream here if we are in
+			 * implicit feedback stream mode - all OUT URBs will
+			 * be queued once data is received on the IN endpooint
+			 * in this case.
+			 */
+			return start_urbs(subs, runtime);
+		}
 	}
 
 	return 0;
diff --git a/sound/usb/urb.h b/sound/usb/urb.h
index 888da38..593a9e1 100644
--- a/sound/usb/urb.h
+++ b/sound/usb/urb.h
@@ -17,5 +17,6 @@ int snd_usb_substream_prepare(struct snd_usb_substream *subs,
 
 int snd_usb_substream_playback_trigger(struct snd_pcm_substream *substream, int cmd);
 int snd_usb_substream_capture_trigger(struct snd_pcm_substream *substream, int cmd);
+int snd_usb_capture_subs_used_by_playback(struct snd_usb_substream *substream);
 
 #endif /* __USBAUDIO_URB_H */
