diff --git a/drivers/media/platform/omap3isp/ispccdc.c b/drivers/media/platform/omap3isp/ispccdc.c
index d5de843..882ebde 100644
--- a/drivers/media/platform/omap3isp/ispccdc.c
+++ b/drivers/media/platform/omap3isp/ispccdc.c
@@ -1147,6 +1147,8 @@ static void ccdc_configure(struct isp_ccdc_device *ccdc)
 
 		pdata = &((struct isp_v4l2_subdevs_group *)sensor->host_priv)
 			->bus.parallel;
+		if (ccdc->bt656)
+			ccdc->video_out.pipe.do_delayed_frames = true;
 	}
 
 	/* CCDC_PAD_SINK */
@@ -1321,9 +1323,23 @@ static void __ccdc_enable(struct isp_ccdc_device *ccdc, int enable)
 	* interrupts high enough that they won't be generated.
 	*/
 	if (enable) {
-		vd0 = format->height - 2;
-		vd1 = format->height * 2 / 3;
+		if (ccdc->bt656) {
+			/* Generate VD0 around the first line of the image
+			* and VD1 high enough to not be encountered for BT.656.
+			*/
+			vd0 = 1;
+			vd1 = 0xffff;
+		} else {
+			/* Generate VD0 on the last line of the image and VD1
+			* on the 2/3 height line.
+			*/
+			vd0 = format->height - 2;
+			vd1 = format->height * 2 / 3;
+		}
 	} else {
+		/* Set VD0 and VD1 interrupts high enough that they won't
+		* be generated.
+		*/
 		vd0 = 0xffff;
 		vd1 = 0xffff;
 	}
@@ -1617,7 +1633,7 @@ static int ccdc_isr_buffer(struct isp_ccdc_device *ccdc)
 	}
 
 	/* Wait for the CCDC to become idle. */
-	if (ccdc_sbl_wait_idle(ccdc, 1000)) {
+	if (!pipe->do_delayed_frames && ccdc_sbl_wait_idle(ccdc, 1000)) {
 		dev_info(isp->dev, "CCDC won't become idle!\n");
 		isp->crashed |= 1U << ccdc->subdev.entity.id;
 		omap3isp_pipeline_cancel_stream(pipe);
diff --git a/drivers/media/platform/omap3isp/ispvideo.c b/drivers/media/platform/omap3isp/ispvideo.c
index 3fe9047..2764463 100644
--- a/drivers/media/platform/omap3isp/ispvideo.c
+++ b/drivers/media/platform/omap3isp/ispvideo.c
@@ -370,6 +370,34 @@ static int isp_video_buffer_prepare(struct vb2_buffer *buf)
 }
 
 /*
+ * isp_video_buffer_queue_ready - Returns true if dmaqueue is in a state that
+ * warrants starting the stream.
+ * @video: Video stream
+ *
+ * This function checks to see if isp_video_buffer_queue should start streaming
+ * of the queue or not.  If we're not doing delayed frames, we should kickstart
+ * on the basis of 0 frames currently in the queue.  If we are doing delayed
+ * frames, it should be on the basis of 2 frames currently in the queue.
+ */
+static bool isp_video_buffer_queue_ready(struct isp_video *video)
+{
+	int cnt = 0;
+	struct isp_buffer *pos;
+	struct isp_pipeline *pipe = to_isp_pipeline(&video->video.entity);
+
+	if (!pipe->do_delayed_frames)
+		return list_empty(&video->dmaqueue);
+
+	list_for_each_entry(pos, &video->dmaqueue, irqlist)
+		if (++cnt > 2)
+			return false;
+
+	if (cnt == 2)
+		return true;
+	return false;
+}
+
+/*
  * isp_video_buffer_queue - Add buffer to streaming queue
  * @buf: Video buffer
  *
@@ -389,6 +417,8 @@ static void isp_video_buffer_queue(struct vb2_buffer *buf)
 	unsigned int empty;
 	unsigned int start;
 
+	buffer->delayed_state = 0;
+
 	spin_lock_irqsave(&video->irqlock, flags);
 
 	if (unlikely(video->error)) {
@@ -397,9 +427,17 @@ static void isp_video_buffer_queue(struct vb2_buffer *buf)
 		return;
 	}
 
-	empty = list_empty(&video->dmaqueue);
+	empty = isp_video_buffer_queue_ready(video);
+
 	list_add_tail(&buffer->irqlist, &video->dmaqueue);
 
+	/* If we're doing delayed frames, we always want to load the _first_
+	 * frame in the queue.
+	 */
+	if (pipe->do_delayed_frames)
+		buffer = list_first_entry(&video->dmaqueue, struct isp_buffer,
+					  irqlist);
+
 	spin_unlock_irqrestore(&video->irqlock, flags);
 
 	if (empty) {
@@ -450,10 +488,15 @@ struct isp_buffer *omap3isp_video_buffer_next(struct isp_video *video)
 {
 	struct isp_pipeline *pipe = to_isp_pipeline(&video->video.entity);
 	enum isp_pipeline_state state;
-	struct isp_buffer *buf;
+	struct isp_buffer *buf, *tmp;
+	struct isp_buffer *buf_to_complete = NULL;
+	bool end_video_capture = false;
+
 	unsigned long flags;
 	struct timespec ts;
 
+	ktime_get_ts(&ts);
+
 	spin_lock_irqsave(&video->irqlock, flags);
 	if (WARN_ON(list_empty(&video->dmaqueue))) {
 		spin_unlock_irqrestore(&video->irqlock, flags);
@@ -462,43 +505,104 @@ struct isp_buffer *omap3isp_video_buffer_next(struct isp_video *video)
 
 	buf = list_first_entry(&video->dmaqueue, struct isp_buffer,
 			       irqlist);
-	list_del(&buf->irqlist);
-	spin_unlock_irqrestore(&video->irqlock, flags);
 
-	ktime_get_ts(&ts);
-	buf->vb.v4l2_buf.timestamp.tv_sec = ts.tv_sec;
-	buf->vb.v4l2_buf.timestamp.tv_usec = ts.tv_nsec / NSEC_PER_USEC;
-
-	/* Do frame number propagation only if this is the output video node.
-	 * Frame number either comes from the CSI receivers or it gets
-	 * incremented here if H3A is not active.
-	 * Note: There is no guarantee that the output buffer will finish
-	 * first, so the input number might lag behind by 1 in some cases.
-	 */
-	if (video == pipe->output && !pipe->do_propagation)
-		buf->vb.v4l2_buf.sequence =
-			atomic_inc_return(&pipe->frame_number);
-	else
-		buf->vb.v4l2_buf.sequence = atomic_read(&pipe->frame_number);
+	if (pipe->do_delayed_frames) {
+		/* If the leading buffer is delayed, there could be others */
+		switch (buf->delayed_state) {
+		case 2: /* buf[N-2] - this buffer is ready to be completed */
+			buf_to_complete = buf;
+
+			/* Find the next buffer in the queue */
+			tmp = list_next_entry(buf, irqlist);
+
+			if (tmp == buf) {
+				buf = NULL;
+				break;
+			}
+			buf = tmp;
+
+			/* Fall through */
+		case 1: /* buf[N-1] - this buffer will be ready next time */
+			buf->delayed_state++;
+
+			/* Find the next buffer in the queue */
+			tmp = list_next_entry(buf, irqlist);
+
+			if (tmp == buf) {
+				buf = NULL;
+				break;
+			}
+			buf = tmp;
+
+			/* Fall through */
+		case 0: /* buf[N] - this buffer will be queued this time */
+			buf->delayed_state++;
+			break;
+		}
 
-	if (pipe->field != V4L2_FIELD_NONE)
-		buf->vb.v4l2_buf.sequence /= 2;
+		if (buf_to_complete != NULL)
+			list_del(&buf_to_complete->irqlist);
+	} else {
+		list_del(&buf->irqlist);
+	}
+
+	/* Buf is potentially NULL in the delayed_frames case only */
+	if (buf != NULL) {
+		buf->vb.v4l2_buf.timestamp.tv_sec = ts.tv_sec;
+		buf->vb.v4l2_buf.timestamp.tv_usec = ts.tv_nsec / NSEC_PER_USEC;
+
+		/* Do frame number propagation only if this is the output
+		* video node.  Frame number either comes from the CSI
+		* receivers or it gets incremented here if H3A is not active.
+		*
+		* Note: There is no guarantee that the output buffer will
+		* finish first, so the input number might lag behind by 1 in
+		* some cases.
+		*/
+		if (video == pipe->output && !pipe->do_propagation)
+			buf->vb.v4l2_buf.sequence =
+				atomic_inc_return(&pipe->frame_number);
+		else
+			buf->vb.v4l2_buf.sequence =
+				atomic_read(&pipe->frame_number);
 
-	buf->vb.v4l2_buf.field = pipe->field;
+		if (pipe->field != V4L2_FIELD_NONE)
+			buf->vb.v4l2_buf.sequence /= 2;
+
+		buf->vb.v4l2_buf.field = pipe->field;
+	}
 
 	/* Report pipeline errors to userspace on the capture device side. */
 	if (video->type == V4L2_BUF_TYPE_VIDEO_CAPTURE && pipe->error) {
-		state = VB2_BUF_STATE_ERROR;
+		buf->state = VB2_BUF_STATE_ERROR;
 		pipe->error = false;
 	} else {
-		state = VB2_BUF_STATE_DONE;
+		buf->state = VB2_BUF_STATE_DONE;
 	}
 
-	vb2_buffer_done(&buf->vb, state);
+	spin_unlock_irqrestore(&video->irqlock, flags);
+
+	if (!pipe->do_delayed_frames)
+		vb2_buffer_done(&buf->vb, buf->state);
+	else if (buf_to_complete != NULL)
+		vb2_buffer_done(&buf_to_complete->vb, buf_to_complete->state);
 
 	spin_lock_irqsave(&video->irqlock, flags);
 
-	if (list_empty(&video->dmaqueue)) {
+	if (pipe->do_delayed_frames) {
+		/* Find the first buffer available that hasn't been started.  If
+		 * there isn't one, we need to end video capture.
+		 */
+		end_video_capture = true;
+		list_for_each_entry(buf, &video->dmaqueue, irqlist)
+			if (buf->delayed_state == 0) {
+				end_video_capture = false;
+				break;
+			}
+	} else if (list_empty(&video->dmaqueue))
+		end_video_capture = true;
+
+	if (end_video_capture) {
 		spin_unlock_irqrestore(&video->irqlock, flags);
 
 		if (video->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
@@ -522,8 +626,11 @@ struct isp_buffer *omap3isp_video_buffer_next(struct isp_video *video)
 		spin_unlock(&pipe->lock);
 	}
 
-	buf = list_first_entry(&video->dmaqueue, struct isp_buffer,
-			       irqlist);
+	/* With delayed frames, we've already found our buffer above. */
+	if (!pipe->do_delayed_frames)
+		buf = list_first_entry(&video->dmaqueue, struct isp_buffer,
+				       irqlist);
+
 	buf->vb.state = VB2_BUF_STATE_ACTIVE;
 
 	spin_unlock_irqrestore(&video->irqlock, flags);
diff --git a/drivers/media/platform/omap3isp/ispvideo.h b/drivers/media/platform/omap3isp/ispvideo.h
index 4071dd7..5857ed9 100644
--- a/drivers/media/platform/omap3isp/ispvideo.h
+++ b/drivers/media/platform/omap3isp/ispvideo.h
@@ -100,6 +100,7 @@ struct isp_pipeline {
 	struct v4l2_subdev *external;
 	unsigned int external_rate;
 	unsigned int external_width;
+	bool do_delayed_frames;
 };
 
 #define to_isp_pipeline(__e) \
@@ -125,6 +126,8 @@ struct isp_buffer {
 	struct vb2_buffer vb;
 	struct list_head irqlist;
 	dma_addr_t dma;
+	int delayed_state;
+	enum isp_pipeline_state state;
 };
 
 #define to_isp_buffer(buf)	container_of(buf, struct isp_buffer, vb)
