V4L/DVB (6047): ivtv: Fix scatter/gather DMA timeouts

It turns out that the cx23415/6 DMA engine cannot do scatter/gather DMA
reliably. Every so often depending on the phase of the moon and your
hardware configuration the cx2341x DMA engine simply chokes on it and
you have to reboot to get it working again.

This change replaced the scatter/gather DMA by single transfers at a time,
where the driver is now responsible for DMA-ing each buffer.

UDMA is still done using scatter/gather DMA, that will be fixed soon.

Many thanks to Mark Bryars <mark.bryars@etvinteractive.com> for discovering
the link between scatter/gather and the DMA timeouts.

Signed-off-by: Hans Verkuil <hverkuil@xs4all.nl>
Signed-off-by: Mauro Carvalho Chehab <mchehab@infradead.org>

1 files changed, 141 insertions, 93 deletions

diff --git a/drivers/media/video/ivtv/ivtv-irq.c b/drivers/media/video/ivtv/ivtv-irq.c
index 8644f3dda31e..9695e5356163 100644
--- a/drivers/media/video/ivtv/ivtv-irq.c
+++ b/drivers/media/video/ivtv/ivtv-irq.c
@@ -60,18 +60,18 @@ static void ivtv_pio_work_handler(struct ivtv *itv)
         buf = list_entry(s->q_dma.list.next, struct ivtv_buffer, list);
         list_for_each(p, &s->q_dma.list) {
                 struct ivtv_buffer *buf = list_entry(p, struct ivtv_buffer, list);
-                u32 size = s->PIOarray[i].size & 0x3ffff;
+                u32 size = s->sg_processing[i].size & 0x3ffff;
 
                 /* Copy the data from the card to the buffer */
                 if (s->type == IVTV_DEC_STREAM_TYPE_VBI) {
-                        memcpy_fromio(buf->buf, itv->dec_mem + s->PIOarray[i].src - IVTV_DECODER_OFFSET, size);
+                        memcpy_fromio(buf->buf, itv->dec_mem + s->sg_processing[i].src - IVTV_DECODER_OFFSET, size);
                 }
                 else {
-                        memcpy_fromio(buf->buf, itv->enc_mem + s->PIOarray[i].src, size);
+                        memcpy_fromio(buf->buf, itv->enc_mem + s->sg_processing[i].src, size);
                 }
-                if (s->PIOarray[i].size & 0x80000000)
-                        break;
                 i++;
+                if (i == s->sg_processing_size)
+                        break;
         }
         write_reg(IVTV_IRQ_ENC_PIO_COMPLETE, 0x44);
 }
@@ -105,7 +105,7 @@ static int stream_enc_dma_append(struct ivtv_stream *s, u32 data[CX2341X_MBOX_MA
         u32 offset, size;
         u32 UVoffset = 0, UVsize = 0;
         int skip_bufs = s->q_predma.buffers;
-        int idx = s->SG_length;
+        int idx = s->sg_pending_size;
         int rc;
 
         /* sanity checks */
@@ -123,7 +123,7 @@ static int stream_enc_dma_append(struct ivtv_stream *s, u32 data[CX2341X_MBOX_MA
                 case IVTV_ENC_STREAM_TYPE_MPG:
                         offset = data[1];
                         size = data[2];
-                        s->dma_pts = 0;
+                        s->pending_pts = 0;
                         break;
 
                 case IVTV_ENC_STREAM_TYPE_YUV:
@@ -131,13 +131,13 @@ static int stream_enc_dma_append(struct ivtv_stream *s, u32 data[CX2341X_MBOX_MA
                         size = data[2];
                         UVoffset = data[3];
                         UVsize = data[4];
-                        s->dma_pts = ((u64) data[5] << 32) | data[6];
+                        s->pending_pts = ((u64) data[5] << 32) | data[6];
                         break;
 
                 case IVTV_ENC_STREAM_TYPE_PCM:
                         offset = data[1] + 12;
                         size = data[2] - 12;
-                        s->dma_pts = read_dec(offset - 8) |
+                        s->pending_pts = read_dec(offset - 8) |
                                 ((u64)(read_dec(offset - 12)) << 32);
                         if (itv->has_cx23415)
                                 offset += IVTV_DECODER_OFFSET;
@@ -150,13 +150,13 @@ static int stream_enc_dma_append(struct ivtv_stream *s, u32 data[CX2341X_MBOX_MA
                                 IVTV_DEBUG_INFO("VBI offset == 0\n");
                                 return -1;
                         }
-                        s->dma_pts = read_enc(offset - 4) | ((u64)read_enc(offset - 8) << 32);
+                        s->pending_pts = read_enc(offset - 4) | ((u64)read_enc(offset - 8) << 32);
                         break;
 
                 case IVTV_DEC_STREAM_TYPE_VBI:
                         size = read_dec(itv->vbi.dec_start + 4) + 8;
                         offset = read_dec(itv->vbi.dec_start) + itv->vbi.dec_start;
-                        s->dma_pts = 0;
+                        s->pending_pts = 0;
                         offset += IVTV_DECODER_OFFSET;
                         break;
                 default:
@@ -165,17 +165,17 @@ static int stream_enc_dma_append(struct ivtv_stream *s, u32 data[CX2341X_MBOX_MA
         }
 
         /* if this is the start of the DMA then fill in the magic cookie */
-        if (s->SG_length == 0) {
+        if (s->sg_pending_size == 0) {
                 if (itv->has_cx23415 && (s->type == IVTV_ENC_STREAM_TYPE_PCM ||
                     s->type == IVTV_DEC_STREAM_TYPE_VBI)) {
-                        s->dma_backup = read_dec(offset - IVTV_DECODER_OFFSET);
+                        s->pending_backup = read_dec(offset - IVTV_DECODER_OFFSET);
                         write_dec_sync(cpu_to_le32(DMA_MAGIC_COOKIE), offset - IVTV_DECODER_OFFSET);
                 }
                 else {
-                        s->dma_backup = read_enc(offset);
+                        s->pending_backup = read_enc(offset);
                         write_enc_sync(cpu_to_le32(DMA_MAGIC_COOKIE), offset);
                 }
-                s->dma_offset = offset;
+                s->pending_offset = offset;
         }
 
         bytes_needed = size;
@@ -202,7 +202,7 @@ static int stream_enc_dma_append(struct ivtv_stream *s, u32 data[CX2341X_MBOX_MA
         }
         s->buffers_stolen = rc;
 
-        /* got the buffers, now fill in SGarray (DMA) */
+        /* got the buffers, now fill in sg_pending */
         buf = list_entry(s->q_predma.list.next, struct ivtv_buffer, list);
         memset(buf->buf, 0, 128);
         list_for_each(p, &s->q_predma.list) {
@@ -210,9 +210,9 @@ static int stream_enc_dma_append(struct ivtv_stream *s, u32 data[CX2341X_MBOX_MA
 
                 if (skip_bufs-- > 0)
                         continue;
-                s->SGarray[idx].dst = cpu_to_le32(buf->dma_handle);
-                s->SGarray[idx].src = cpu_to_le32(offset);
-                s->SGarray[idx].size = cpu_to_le32(s->buf_size);
+                s->sg_pending[idx].dst = buf->dma_handle;
+                s->sg_pending[idx].src = offset;
+                s->sg_pending[idx].size = s->buf_size;
                 buf->bytesused = (size < s->buf_size) ? size : s->buf_size;
                 buf->dma_xfer_cnt = s->dma_xfer_cnt;
 
@@ -230,7 +230,7 @@ static int stream_enc_dma_append(struct ivtv_stream *s, u32 data[CX2341X_MBOX_MA
                 }
                 idx++;
         }
-        s->SG_length = idx;
+        s->sg_pending_size = idx;
         return 0;
 }
 
@@ -332,9 +332,9 @@ void ivtv_dma_stream_dec_prepare(struct ivtv_stream *s, u32 offset, int lock)
                         offset = uv_offset;
                         y_done = 1;
                 }
-                s->SGarray[idx].src = cpu_to_le32(buf->dma_handle);
-                s->SGarray[idx].dst = cpu_to_le32(offset);
-                s->SGarray[idx].size = cpu_to_le32(buf->bytesused);
+                s->sg_pending[idx].src = buf->dma_handle;
+                s->sg_pending[idx].dst = offset;
+                s->sg_pending[idx].size = buf->bytesused;
 
                 offset += buf->bytesused;
                 bytes_written += buf->bytesused;
@@ -343,10 +343,7 @@ void ivtv_dma_stream_dec_prepare(struct ivtv_stream *s, u32 offset, int lock)
                 ivtv_buf_sync_for_device(s, buf);
                 idx++;
         }
-        s->SG_length = idx;
-
-        /* Mark last buffer size for Interrupt flag */
-        s->SGarray[s->SG_length - 1].size |= cpu_to_le32(0x80000000);
+        s->sg_pending_size = idx;
 
         /* Sync Hardware SG List of buffers */
         ivtv_stream_sync_for_device(s);
@@ -362,6 +359,34 @@ void ivtv_dma_stream_dec_prepare(struct ivtv_stream *s, u32 offset, int lock)
                 spin_unlock_irqrestore(&itv->dma_reg_lock, flags);
 }
 
+static void ivtv_dma_enc_start_xfer(struct ivtv_stream *s)
+{
+        struct ivtv *itv = s->itv;
+
+        s->sg_dma->src = cpu_to_le32(s->sg_processing[s->sg_processed].src);
+        s->sg_dma->dst = cpu_to_le32(s->sg_processing[s->sg_processed].dst);
+        s->sg_dma->size = cpu_to_le32(s->sg_processing[s->sg_processed].size | 0x80000000);
+        s->sg_processed++;
+        /* Sync Hardware SG List of buffers */
+        ivtv_stream_sync_for_device(s);
+        write_reg(s->sg_handle, IVTV_REG_ENCDMAADDR);
+        write_reg_sync(read_reg(IVTV_REG_DMAXFER) | 0x02, IVTV_REG_DMAXFER);
+}
+
+static void ivtv_dma_dec_start_xfer(struct ivtv_stream *s)
+{
+        struct ivtv *itv = s->itv;
+
+        s->sg_dma->src = cpu_to_le32(s->sg_processing[s->sg_processed].src);
+        s->sg_dma->dst = cpu_to_le32(s->sg_processing[s->sg_processed].dst);
+        s->sg_dma->size = cpu_to_le32(s->sg_processing[s->sg_processed].size | 0x80000000);
+        s->sg_processed++;
+        /* Sync Hardware SG List of buffers */
+        ivtv_stream_sync_for_device(s);
+        write_reg(s->sg_handle, IVTV_REG_DECDMAADDR);
+        write_reg_sync(read_reg(IVTV_REG_DMAXFER) | 0x01, IVTV_REG_DMAXFER);
+}
+
 /* start the encoder DMA */
 static void ivtv_dma_enc_start(struct ivtv_stream *s)
 {
@@ -375,8 +400,7 @@ static void ivtv_dma_enc_start(struct ivtv_stream *s)
                 ivtv_queue_move(s, &s->q_predma, NULL, &s->q_dma, s->q_predma.bytesused);
 
         if (ivtv_use_dma(s))
-                s->SGarray[s->SG_length - 1].size =
-                        cpu_to_le32(le32_to_cpu(s->SGarray[s->SG_length - 1].size) + 256);
+                s->sg_pending[s->sg_pending_size - 1].size += 256;
 
         /* If this is an MPEG stream, and VBI data is also pending, then append the
            VBI DMA to the MPEG DMA and transfer both sets of data at once.
@@ -387,45 +411,39 @@ static void ivtv_dma_enc_start(struct ivtv_stream *s)
            sure we only use the MPEG DMA to transfer the VBI DMA if both are in
            use. This way no conflicts occur. */
         clear_bit(IVTV_F_S_DMA_HAS_VBI, &s->s_flags);
-        if (s->type == IVTV_ENC_STREAM_TYPE_MPG && s_vbi->SG_length &&
-                        s->SG_length + s_vbi->SG_length <= s->buffers) {
+        if (s->type == IVTV_ENC_STREAM_TYPE_MPG && s_vbi->sg_pending_size &&
+                        s->sg_pending_size + s_vbi->sg_pending_size <= s->buffers) {
                 ivtv_queue_move(s_vbi, &s_vbi->q_predma, NULL, &s_vbi->q_dma, s_vbi->q_predma.bytesused);
                 if (ivtv_use_dma(s_vbi))
-                        s_vbi->SGarray[s_vbi->SG_length - 1].size = cpu_to_le32(le32_to_cpu(s_vbi->SGarray[s->SG_length - 1].size) + 256);
-                for (i = 0; i < s_vbi->SG_length; i++) {
-                        s->SGarray[s->SG_length++] = s_vbi->SGarray[i];
+                        s_vbi->sg_pending[s_vbi->sg_pending_size - 1].size += 256;
+                for (i = 0; i < s_vbi->sg_pending_size; i++) {
+                        s->sg_pending[s->sg_pending_size++] = s_vbi->sg_pending[i];
                 }
-                itv->vbi.dma_offset = s_vbi->dma_offset;
-                s_vbi->SG_length = 0;
+                s_vbi->dma_offset = s_vbi->pending_offset;
+                s_vbi->sg_pending_size = 0;
                 s_vbi->dma_xfer_cnt++;
                 set_bit(IVTV_F_S_DMA_HAS_VBI, &s->s_flags);
                 IVTV_DEBUG_HI_DMA("include DMA for %s\n", s->name);
         }
 
-        /* Mark last buffer size for Interrupt flag */
-        s->SGarray[s->SG_length - 1].size |= cpu_to_le32(0x80000000);
         s->dma_xfer_cnt++;
-
-        if (s->type == IVTV_ENC_STREAM_TYPE_VBI)
-                set_bit(IVTV_F_I_ENC_VBI, &itv->i_flags);
-        else
-                clear_bit(IVTV_F_I_ENC_VBI, &itv->i_flags);
+        memcpy(s->sg_processing, s->sg_pending, sizeof(struct ivtv_sg_element) * s->sg_pending_size);
+        s->sg_processing_size = s->sg_pending_size;
+        s->sg_pending_size = 0;
+        s->sg_processed = 0;
+        s->dma_offset = s->pending_offset;
+        s->dma_backup = s->pending_backup;
+        s->dma_pts = s->pending_pts;
 
         if (ivtv_use_pio(s)) {
-                for (i = 0; i < s->SG_length; i++) {
-                        s->PIOarray[i].src = le32_to_cpu(s->SGarray[i].src);
-                        s->PIOarray[i].size = le32_to_cpu(s->SGarray[i].size);
-                }
                 set_bit(IVTV_F_I_WORK_HANDLER_PIO, &itv->i_flags);
                 set_bit(IVTV_F_I_HAVE_WORK, &itv->i_flags);
                 set_bit(IVTV_F_I_PIO, &itv->i_flags);
                 itv->cur_pio_stream = s->type;
         }
         else {
-                /* Sync Hardware SG List of buffers */
-                ivtv_stream_sync_for_device(s);
-                write_reg(s->SG_handle, IVTV_REG_ENCDMAADDR);
-                write_reg_sync(read_reg(IVTV_REG_DMAXFER) | 0x02, IVTV_REG_DMAXFER);
+                itv->dma_retries = 0;
+                ivtv_dma_enc_start_xfer(s);
                 set_bit(IVTV_F_I_DMA, &itv->i_flags);
                 itv->cur_dma_stream = s->type;
                 itv->dma_timer.expires = jiffies + msecs_to_jiffies(100);
@@ -439,10 +457,15 @@ static void ivtv_dma_dec_start(struct ivtv_stream *s)
 
         if (s->q_predma.bytesused)
                 ivtv_queue_move(s, &s->q_predma, NULL, &s->q_dma, s->q_predma.bytesused);
+        s->dma_xfer_cnt++;
+        memcpy(s->sg_processing, s->sg_pending, sizeof(struct ivtv_sg_element) * s->sg_pending_size);
+        s->sg_processing_size = s->sg_pending_size;
+        s->sg_pending_size = 0;
+        s->sg_processed = 0;
+
         IVTV_DEBUG_HI_DMA("start DMA for %s\n", s->name);
-        /* put SG Handle into register 0x0c */
-        write_reg(s->SG_handle, IVTV_REG_DECDMAADDR);
-        write_reg_sync(read_reg(IVTV_REG_DMAXFER) | 0x01, IVTV_REG_DMAXFER);
+        itv->dma_retries = 0;
+        ivtv_dma_dec_start_xfer(s);
         set_bit(IVTV_F_I_DMA, &itv->i_flags);
         itv->cur_dma_stream = s->type;
         itv->dma_timer.expires = jiffies + msecs_to_jiffies(100);
@@ -453,27 +476,42 @@ static void ivtv_irq_dma_read(struct ivtv *itv)
 {
         struct ivtv_stream *s = NULL;
         struct ivtv_buffer *buf;
-        int hw_stream_type;
+        int hw_stream_type = 0;
 
         IVTV_DEBUG_HI_IRQ("DEC DMA READ\n");
-        del_timer(&itv->dma_timer);
-        if (read_reg(IVTV_REG_DMASTATUS) & 0x14) {
-                IVTV_DEBUG_WARN("DEC DMA ERROR %x\n", read_reg(IVTV_REG_DMASTATUS));
-                write_reg(read_reg(IVTV_REG_DMASTATUS) & 3, IVTV_REG_DMASTATUS);
+        if (!test_bit(IVTV_F_I_UDMA, &itv->i_flags) && itv->cur_dma_stream < 0) {
+                del_timer(&itv->dma_timer);
+                return;
         }
+
         if (!test_bit(IVTV_F_I_UDMA, &itv->i_flags)) {
-                if (test_bit(IVTV_F_I_DEC_YUV, &itv->i_flags)) {
-                        s = &itv->streams[IVTV_DEC_STREAM_TYPE_YUV];
-                        hw_stream_type = 2;
+                s = &itv->streams[itv->cur_dma_stream];
+                ivtv_stream_sync_for_cpu(s);
+
+                if (read_reg(IVTV_REG_DMASTATUS) & 0x14) {
+                        IVTV_DEBUG_WARN("DEC DMA ERROR %x (xfer %d of %d, retry %d)\n",
+                                        read_reg(IVTV_REG_DMASTATUS),
+                                        s->sg_processed, s->sg_processing_size, itv->dma_retries);
+                        write_reg(read_reg(IVTV_REG_DMASTATUS) & 3, IVTV_REG_DMASTATUS);
+                        if (itv->dma_retries == 3) {
+                                itv->dma_retries = 0;
+                        }
+                        else {
+                                /* Retry, starting with the first xfer segment.
+                                   Just retrying the current segment is not sufficient. */
+                                s->sg_processed = 0;
+                                itv->dma_retries++;
+                        }
                 }
-                else {
-                        s = &itv->streams[IVTV_DEC_STREAM_TYPE_MPG];
-                        hw_stream_type = 0;
+                if (s->sg_processed < s->sg_processing_size) {
+                        /* DMA next buffer */
+                        ivtv_dma_dec_start_xfer(s);
+                        return;
                 }
+                if (s->type == IVTV_DEC_STREAM_TYPE_YUV)
+                        hw_stream_type = 2;
                 IVTV_DEBUG_HI_DMA("DEC DATA READ %s: %d\n", s->name, s->q_dma.bytesused);
 
-                ivtv_stream_sync_for_cpu(s);
-
                 /* For some reason must kick the firmware, like PIO mode,
                    I think this tells the firmware we are done and the size
                    of the xfer so it can calculate what we need next.
@@ -490,6 +528,7 @@ static void ivtv_irq_dma_read(struct ivtv *itv)
                 }
                 wake_up(&s->waitq);
         }
+        del_timer(&itv->dma_timer);
         clear_bit(IVTV_F_I_UDMA, &itv->i_flags);
         clear_bit(IVTV_F_I_DMA, &itv->i_flags);
         itv->cur_dma_stream = -1;
@@ -501,33 +540,44 @@ static void ivtv_irq_enc_dma_complete(struct ivtv *itv)
         u32 data[CX2341X_MBOX_MAX_DATA];
         struct ivtv_stream *s;
 
-        del_timer(&itv->dma_timer);
         ivtv_api_get_data(&itv->enc_mbox, IVTV_MBOX_DMA_END, data);
-        IVTV_DEBUG_HI_IRQ("ENC DMA COMPLETE %x %d\n", data[0], data[1]);
-        if (test_and_clear_bit(IVTV_F_I_ENC_VBI, &itv->i_flags))
-                data[1] = 3;
-        else if (data[1] > 2)
+        IVTV_DEBUG_HI_IRQ("ENC DMA COMPLETE %x %d (%d)\n", data[0], data[1], itv->cur_dma_stream);
+        if (itv->cur_dma_stream < 0) {
+                del_timer(&itv->dma_timer);
                 return;
-        s = &itv->streams[ivtv_stream_map[data[1]]];
+        }
+        s = &itv->streams[itv->cur_dma_stream];
+        ivtv_stream_sync_for_cpu(s);
+
         if (data[0] & 0x18) {
-                IVTV_DEBUG_WARN("ENC DMA ERROR %x\n", data[0]);
+                IVTV_DEBUG_WARN("ENC DMA ERROR %x (offset %08x, xfer %d of %d, retry %d)\n", data[0],
+                        s->dma_offset, s->sg_processed, s->sg_processing_size, itv->dma_retries);
                 write_reg(read_reg(IVTV_REG_DMASTATUS) & 3, IVTV_REG_DMASTATUS);
-                ivtv_vapi(itv, CX2341X_ENC_SCHED_DMA_TO_HOST, 3, 0, 0, data[1]);
+                if (itv->dma_retries == 3) {
+                        itv->dma_retries = 0;
+                }
+                else {
+                        /* Retry, starting with the first xfer segment.
+                           Just retrying the current segment is not sufficient. */
+                        s->sg_processed = 0;
+                        itv->dma_retries++;
+                }
         }
-        s->SG_length = 0;
+        if (s->sg_processed < s->sg_processing_size) {
+                /* DMA next buffer */
+                ivtv_dma_enc_start_xfer(s);
+                return;
+        }
+        del_timer(&itv->dma_timer);
         clear_bit(IVTV_F_I_DMA, &itv->i_flags);
         itv->cur_dma_stream = -1;
         dma_post(s);
-        ivtv_stream_sync_for_cpu(s);
         if (test_and_clear_bit(IVTV_F_S_DMA_HAS_VBI, &s->s_flags)) {
-                u32 tmp;
-
                 s = &itv->streams[IVTV_ENC_STREAM_TYPE_VBI];
-                tmp = s->dma_offset;
-                s->dma_offset = itv->vbi.dma_offset;
                 dma_post(s);
-                s->dma_offset = tmp;
         }
+        s->sg_processing_size = 0;
+        s->sg_processed = 0;
         wake_up(&itv->dma_waitq);
 }
 
@@ -541,8 +591,7 @@ static void ivtv_irq_enc_pio_complete(struct ivtv *itv)
         }
         s = &itv->streams[itv->cur_pio_stream];
         IVTV_DEBUG_HI_IRQ("ENC PIO COMPLETE %s\n", s->name);
-        s->SG_length = 0;
-        clear_bit(IVTV_F_I_ENC_VBI, &itv->i_flags);
+        s->sg_pending_size = 0;
         clear_bit(IVTV_F_I_PIO, &itv->i_flags);
         itv->cur_pio_stream = -1;
         dma_post(s);
@@ -554,13 +603,8 @@ static void ivtv_irq_enc_pio_complete(struct ivtv *itv)
                 ivtv_vapi(itv, CX2341X_ENC_SCHED_DMA_TO_HOST, 3, 0, 0, 2);
         clear_bit(IVTV_F_I_PIO, &itv->i_flags);
         if (test_and_clear_bit(IVTV_F_S_DMA_HAS_VBI, &s->s_flags)) {
-                u32 tmp;
-
                 s = &itv->streams[IVTV_ENC_STREAM_TYPE_VBI];
-                tmp = s->dma_offset;
-                s->dma_offset = itv->vbi.dma_offset;
                 dma_post(s);
-                s->dma_offset = tmp;
         }
         wake_up(&itv->dma_waitq);
 }
@@ -572,19 +616,23 @@ static void ivtv_irq_dma_err(struct ivtv *itv)
         del_timer(&itv->dma_timer);
         ivtv_api_get_data(&itv->enc_mbox, IVTV_MBOX_DMA_END, data);
         IVTV_DEBUG_WARN("DMA ERROR %08x %08x %08x %d\n", data[0], data[1],
-                                        read_reg(IVTV_REG_DMASTATUS), itv->cur_dma_stream);
+                                read_reg(IVTV_REG_DMASTATUS), itv->cur_dma_stream);
+        write_reg(read_reg(IVTV_REG_DMASTATUS) & 3, IVTV_REG_DMASTATUS);
         if (!test_bit(IVTV_F_I_UDMA, &itv->i_flags) &&
             itv->cur_dma_stream >= 0 && itv->cur_dma_stream < IVTV_MAX_STREAMS) {
                 struct ivtv_stream *s = &itv->streams[itv->cur_dma_stream];
 
                 /* retry */
-                write_reg(read_reg(IVTV_REG_DMASTATUS) & 3, IVTV_REG_DMASTATUS);
                 if (s->type >= IVTV_DEC_STREAM_TYPE_MPG)
                         ivtv_dma_dec_start(s);
                 else
                         ivtv_dma_enc_start(s);
                 return;
         }
+        if (test_bit(IVTV_F_I_UDMA, &itv->i_flags)) {
+                ivtv_udma_start(itv);
+                return;
+        }
         clear_bit(IVTV_F_I_UDMA, &itv->i_flags);
         clear_bit(IVTV_F_I_DMA, &itv->i_flags);
         itv->cur_dma_stream = -1;
@@ -628,14 +676,14 @@ static void ivtv_irq_enc_vbi_cap(struct ivtv *itv)
            DMA the data. Since at most four VBI DMA buffers are available,
            we just drop the old requests when there are already three
            requests queued. */
-        if (s->SG_length > 2) {
+        if (s->sg_pending_size > 2) {
                 struct list_head *p;
                 list_for_each(p, &s->q_predma.list) {
                         struct ivtv_buffer *buf = list_entry(p, struct ivtv_buffer, list);
                         ivtv_buf_sync_for_cpu(s, buf);
                 }
                 ivtv_queue_move(s, &s->q_predma, NULL, &s->q_free, 0);
-                s->SG_length = 0;
+                s->sg_pending_size = 0;
         }
         /* if we can append the data, and the MPEG stream isn't capturing,
            then start a DMA request for just the VBI data. */