SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/media/video/ivtv/ivtv-irq.c

   1 /* interrupt handling
   2     Copyright (C) 2003-2004  Kevin Thayer <nufan_wfk at yahoo.com>
   3     Copyright (C) 2004  Chris Kennedy <c@groovy.org>
   4     Copyright (C) 2005-2007  Hans Verkuil <hverkuil@xs4all.nl>
   5
   6     This program is free software; you can redistribute it and/or modify
   7     it under the terms of the GNU General Public License as published by
   8     the Free Software Foundation; either version 2 of the License, or
   9     (at your option) any later version.
  10
  11     This program is distributed in the hope that it will be useful,
  12     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14     GNU General Public License for more details.
  15
  16     You should have received a copy of the GNU General Public License
  17     along with this program; if not, write to the Free Software
  18     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  */
  20
  21 #include "ivtv-driver.h"
  22 #include "ivtv-queue.h"
  23 #include "ivtv-udma.h"
  24 #include "ivtv-irq.h"
  25 #include "ivtv-mailbox.h"
  26 #include "ivtv-vbi.h"
  27 #include "ivtv-yuv.h"
  28
  29 #define DMA_MAGIC_COOKIE 0x000001fe
  30
  31 static void ivtv_dma_dec_start(struct ivtv_stream *s);
  32
  33 static const int ivtv_stream_map[] = {
  34         IVTV_ENC_STREAM_TYPE_MPG,
  35         IVTV_ENC_STREAM_TYPE_YUV,
  36         IVTV_ENC_STREAM_TYPE_PCM,
  37         IVTV_ENC_STREAM_TYPE_VBI,
  38 };
  39
  40
  41 static void ivtv_pio_work_handler(struct ivtv *itv)
  42 {
  43         struct ivtv_stream *s = &itv->streams[itv->cur_pio_stream];
  44         struct ivtv_buffer *buf;
  45         int i = 0;
  46
  47         IVTV_DEBUG_HI_DMA("ivtv_pio_work_handler\n");
  48         if (itv->cur_pio_stream < 0 || itv->cur_pio_stream >= IVTV_MAX_STREAMS ||
  49                         s->v4l2dev == NULL || !ivtv_use_pio(s)) {
  50                 itv->cur_pio_stream = -1;
  51                 /* trigger PIO complete user interrupt */
  52                 write_reg(IVTV_IRQ_ENC_PIO_COMPLETE, 0x44);
  53                 return;
  54         }
  55         IVTV_DEBUG_HI_DMA("Process PIO %s\n", s->name);
  56         list_for_each_entry(buf, &s->q_dma.list, list) {
  57                 u32 size = s->sg_processing[i].size & 0x3ffff;
  58
  59                 /* Copy the data from the card to the buffer */
  60                 if (s->type == IVTV_DEC_STREAM_TYPE_VBI) {
  61                         memcpy_fromio(buf->buf, itv->dec_mem + s->sg_processing[i].src - IVTV_DECODER_OFFSET, size);
  62                 }
  63                 else {
  64                         memcpy_fromio(buf->buf, itv->enc_mem + s->sg_processing[i].src, size);
  65                 }
  66                 i++;
  67                 if (i == s->sg_processing_size)
  68                         break;
  69         }
  70         write_reg(IVTV_IRQ_ENC_PIO_COMPLETE, 0x44);
  71 }
  72
  73 void ivtv_irq_work_handler(struct work_struct *work)
  74 {
  75         struct ivtv *itv = container_of(work, struct ivtv, irq_work_queue);
  76
  77         DEFINE_WAIT(wait);
  78
  79         if (test_and_clear_bit(IVTV_F_I_WORK_HANDLER_PIO, &itv->i_flags))
  80                 ivtv_pio_work_handler(itv);
  81
  82         if (test_and_clear_bit(IVTV_F_I_WORK_HANDLER_VBI, &itv->i_flags))
  83                 ivtv_vbi_work_handler(itv);
  84
  85         if (test_and_clear_bit(IVTV_F_I_WORK_HANDLER_YUV, &itv->i_flags))
  86                 ivtv_yuv_work_handler(itv);
  87 }
  88
  89 /* Determine the required DMA size, setup enough buffers in the predma queue and
  90    actually copy the data from the card to the buffers in case a PIO transfer is
  91    required for this stream.
  92  */
  93 static int stream_enc_dma_append(struct ivtv_stream *s, u32 data[CX2341X_MBOX_MAX_DATA])
  94 {
  95         struct ivtv *itv = s->itv;
  96         struct ivtv_buffer *buf;
  97         u32 bytes_needed = 0;
  98         u32 offset, size;
  99         u32 UVoffset = 0, UVsize = 0;
 100         int skip_bufs = s->q_predma.buffers;
 101         int idx = s->sg_pending_size;
 102         int rc;
 103
 104         /* sanity checks */
 105         if (s->v4l2dev == NULL) {
 106                 IVTV_DEBUG_WARN("Stream %s not started\n", s->name);
 107                 return -1;
 108         }
 109         if (!test_bit(IVTV_F_S_CLAIMED, &s->s_flags)) {
 110                 IVTV_DEBUG_WARN("Stream %s not open\n", s->name);
 111                 return -1;
 112         }
 113
 114         /* determine offset, size and PTS for the various streams */
 115         switch (s->type) {
 116                 case IVTV_ENC_STREAM_TYPE_MPG:
 117                         offset = data[1];
 118                         size = data[2];
 119                         s->pending_pts = 0;
 120                         break;
 121
 122                 case IVTV_ENC_STREAM_TYPE_YUV:
 123                         offset = data[1];
 124                         size = data[2];
 125                         UVoffset = data[3];
 126                         UVsize = data[4];
 127                         s->pending_pts = ((u64) data[5] << 32) | data[6];
 128                         break;
 129
 130                 case IVTV_ENC_STREAM_TYPE_PCM:
 131                         offset = data[1] + 12;
 132                         size = data[2] - 12;
 133                         s->pending_pts = read_dec(offset - 8) |
 134                                 ((u64)(read_dec(offset - 12)) << 32);
 135                         if (itv->has_cx23415)
 136                                 offset += IVTV_DECODER_OFFSET;
 137                         break;
 138
 139                 case IVTV_ENC_STREAM_TYPE_VBI:
 140                         size = itv->vbi.enc_size * itv->vbi.fpi;
 141                         offset = read_enc(itv->vbi.enc_start - 4) + 12;
 142                         if (offset == 12) {
 143                                 IVTV_DEBUG_INFO("VBI offset == 0\n");
 144                                 return -1;
 145                         }
 146                         s->pending_pts = read_enc(offset - 4) | ((u64)read_enc(offset - 8) << 32);
 147                         break;
 148
 149                 case IVTV_DEC_STREAM_TYPE_VBI:
 150                         size = read_dec(itv->vbi.dec_start + 4) + 8;
 151                         offset = read_dec(itv->vbi.dec_start) + itv->vbi.dec_start;
 152                         s->pending_pts = 0;
 153                         offset += IVTV_DECODER_OFFSET;
 154                         break;
 155                 default:
 156                         /* shouldn't happen */
 157                         return -1;
 158         }
 159
 160         /* if this is the start of the DMA then fill in the magic cookie */
 161         if (s->sg_pending_size == 0 && ivtv_use_dma(s)) {
 162                 if (itv->has_cx23415 && (s->type == IVTV_ENC_STREAM_TYPE_PCM ||
 163                     s->type == IVTV_DEC_STREAM_TYPE_VBI)) {
 164                         s->pending_backup = read_dec(offset - IVTV_DECODER_OFFSET);
 165                         write_dec_sync(cpu_to_le32(DMA_MAGIC_COOKIE), offset - IVTV_DECODER_OFFSET);
 166                 }
 167                 else {
 168                         s->pending_backup = read_enc(offset);
 169                         write_enc_sync(cpu_to_le32(DMA_MAGIC_COOKIE), offset);
 170                 }
 171                 s->pending_offset = offset;
 172         }
 173
 174         bytes_needed = size;
 175         if (s->type == IVTV_ENC_STREAM_TYPE_YUV) {
 176                 /* The size for the Y samples needs to be rounded upwards to a
 177                    multiple of the buf_size. The UV samples then start in the
 178                    next buffer. */
 179                 bytes_needed = s->buf_size * ((bytes_needed + s->buf_size - 1) / s->buf_size);
 180                 bytes_needed += UVsize;
 181         }
 182
 183         IVTV_DEBUG_HI_DMA("%s %s: 0x%08x bytes at 0x%08x\n",
 184                 ivtv_use_pio(s) ? "PIO" : "DMA", s->name, bytes_needed, offset);
 185
 186         rc = ivtv_queue_move(s, &s->q_free, &s->q_full, &s->q_predma, bytes_needed);
 187         if (rc < 0) { /* Insufficient buffers */
 188                 IVTV_DEBUG_WARN("Cannot obtain %d bytes for %s data transfer\n",
 189                                 bytes_needed, s->name);
 190                 return -1;
 191         }
 192         if (rc && !s->buffers_stolen && (s->s_flags & IVTV_F_S_APPL_IO)) {
 193                 IVTV_WARN("All %s stream buffers are full. Dropping data.\n", s->name);
 194                 IVTV_WARN("Cause: the application is not reading fast enough.\n");
 195         }
 196         s->buffers_stolen = rc;
 197
 198         /* got the buffers, now fill in sg_pending */
 199         buf = list_entry(s->q_predma.list.next, struct ivtv_buffer, list);
 200         memset(buf->buf, 0, 128);
 201         list_for_each_entry(buf, &s->q_predma.list, list) {
 202                 if (skip_bufs-- > 0)
 203                         continue;
 204                 s->sg_pending[idx].dst = buf->dma_handle;
 205                 s->sg_pending[idx].src = offset;
 206                 s->sg_pending[idx].size = s->buf_size;
 207                 buf->bytesused = min(size, s->buf_size);
 208                 buf->dma_xfer_cnt = s->dma_xfer_cnt;
 209
 210                 s->q_predma.bytesused += buf->bytesused;
 211                 size -= buf->bytesused;
 212                 offset += s->buf_size;
 213
 214                 /* Sync SG buffers */
 215                 ivtv_buf_sync_for_device(s, buf);
 216
 217                 if (size == 0) {        /* YUV */
 218                         /* process the UV section */
 219                         offset = UVoffset;
 220                         size = UVsize;
 221                 }
 222                 idx++;
 223         }
 224         s->sg_pending_size = idx;
 225         return 0;
 226 }
 227
 228 static void dma_post(struct ivtv_stream *s)
 229 {
 230         struct ivtv *itv = s->itv;
 231         struct ivtv_buffer *buf = NULL;
 232         struct list_head *p;
 233         u32 offset;
 234         __le32 *u32buf;
 235         int x = 0;
 236
 237         IVTV_DEBUG_HI_DMA("%s %s completed (%x)\n", ivtv_use_pio(s) ? "PIO" : "DMA",
 238                         s->name, s->dma_offset);
 239         list_for_each(p, &s->q_dma.list) {
 240                 buf = list_entry(p, struct ivtv_buffer, list);
 241                 u32buf = (__le32 *)buf->buf;
 242
 243                 /* Sync Buffer */
 244                 ivtv_buf_sync_for_cpu(s, buf);
 245
 246                 if (x == 0 && ivtv_use_dma(s)) {
 247                         offset = s->dma_last_offset;
 248                         if (u32buf[offset / 4] != DMA_MAGIC_COOKIE)
 249                         {
 250                                 for (offset = 0; offset < 64; offset++) {
 251                                         if (u32buf[offset] == DMA_MAGIC_COOKIE) {
 252                                                 break;
 253                                         }
 254                                 }
 255                                 offset *= 4;
 256                                 if (offset == 256) {
 257                                         IVTV_DEBUG_WARN("%s: Couldn't find start of buffer within the first 256 bytes\n", s->name);
 258                                         offset = s->dma_last_offset;
 259                                 }
 260                                 if (s->dma_last_offset != offset)
 261                                         IVTV_DEBUG_WARN("%s: offset %d -> %d\n", s->name, s->dma_last_offset, offset);
 262                                 s->dma_last_offset = offset;
 263                         }
 264                         if (itv->has_cx23415 && (s->type == IVTV_ENC_STREAM_TYPE_PCM ||
 265                                                 s->type == IVTV_DEC_STREAM_TYPE_VBI)) {
 266                                 write_dec_sync(0, s->dma_offset - IVTV_DECODER_OFFSET);
 267                         }
 268                         else {
 269                                 write_enc_sync(0, s->dma_offset);
 270                         }
 271                         if (offset) {
 272                                 buf->bytesused -= offset;
 273                                 memcpy(buf->buf, buf->buf + offset, buf->bytesused + offset);
 274                         }
 275                         *u32buf = cpu_to_le32(s->dma_backup);
 276                 }
 277                 x++;
 278                 /* flag byteswap ABCD -> DCBA for MPG & VBI data outside irq */
 279                 if (s->type == IVTV_ENC_STREAM_TYPE_MPG ||
 280                     s->type == IVTV_ENC_STREAM_TYPE_VBI)
 281                         buf->b_flags |= IVTV_F_B_NEED_BUF_SWAP;
 282         }
 283         if (buf)
 284                 buf->bytesused += s->dma_last_offset;
 285         if (buf && s->type == IVTV_DEC_STREAM_TYPE_VBI) {
 286                 list_for_each_entry(buf, &s->q_dma.list, list) {
 287                         /* Parse and Groom VBI Data */
 288                         s->q_dma.bytesused -= buf->bytesused;
 289                         ivtv_process_vbi_data(itv, buf, 0, s->type);
 290                         s->q_dma.bytesused += buf->bytesused;
 291                 }
 292                 if (s->id == -1) {
 293                         ivtv_queue_move(s, &s->q_dma, NULL, &s->q_free, 0);
 294                         return;
 295                 }
 296         }
 297         ivtv_queue_move(s, &s->q_dma, NULL, &s->q_full, s->q_dma.bytesused);
 298         if (s->id != -1)
 299                 wake_up(&s->waitq);
 300 }
 301
 302 void ivtv_dma_stream_dec_prepare(struct ivtv_stream *s, u32 offset, int lock)
 303 {
 304         struct ivtv *itv = s->itv;
 305         struct yuv_playback_info *yi = &itv->yuv_info;
 306         u8 frame = yi->draw_frame;
 307         struct yuv_frame_info *f = &yi->new_frame_info[frame];
 308         struct ivtv_buffer *buf;
 309         u32 y_size = 720 * ((f->src_h + 31) & ~31);
 310         u32 uv_offset = offset + IVTV_YUV_BUFFER_UV_OFFSET;
 311         int y_done = 0;
 312         int bytes_written = 0;
 313         unsigned long flags = 0;
 314         int idx = 0;
 315
 316         IVTV_DEBUG_HI_DMA("DEC PREPARE DMA %s: %08x %08x\n", s->name, s->q_predma.bytesused, offset);
 317
 318         /* Insert buffer block for YUV if needed */
 319         if (s->type == IVTV_DEC_STREAM_TYPE_YUV && f->offset_y) {
 320                 if (yi->blanking_dmaptr) {
 321                         s->sg_pending[idx].src = yi->blanking_dmaptr;
 322                         s->sg_pending[idx].dst = offset;
 323                         s->sg_pending[idx].size = 720 * 16;
 324                 }
 325                 offset += 720 * 16;
 326                 idx++;
 327         }
 328
 329         list_for_each_entry(buf, &s->q_predma.list, list) {
 330                 /* YUV UV Offset from Y Buffer */
 331                 if (s->type == IVTV_DEC_STREAM_TYPE_YUV && !y_done &&
 332                                 (bytes_written + buf->bytesused) >= y_size) {
 333                         s->sg_pending[idx].src = buf->dma_handle;
 334                         s->sg_pending[idx].dst = offset;
 335                         s->sg_pending[idx].size = y_size - bytes_written;
 336                         offset = uv_offset;
 337                         if (s->sg_pending[idx].size != buf->bytesused) {
 338                                 idx++;
 339                                 s->sg_pending[idx].src =
 340                                   buf->dma_handle + s->sg_pending[idx - 1].size;
 341                                 s->sg_pending[idx].dst = offset;
 342                                 s->sg_pending[idx].size =
 343                                    buf->bytesused - s->sg_pending[idx - 1].size;
 344                                 offset += s->sg_pending[idx].size;
 345                         }
 346                         y_done = 1;
 347                 } else {
 348                         s->sg_pending[idx].src = buf->dma_handle;
 349                         s->sg_pending[idx].dst = offset;
 350                         s->sg_pending[idx].size = buf->bytesused;
 351                         offset += buf->bytesused;
 352                 }
 353                 bytes_written += buf->bytesused;
 354
 355                 /* Sync SG buffers */
 356                 ivtv_buf_sync_for_device(s, buf);
 357                 idx++;
 358         }
 359         s->sg_pending_size = idx;
 360
 361         /* Sync Hardware SG List of buffers */
 362         ivtv_stream_sync_for_device(s);
 363         if (lock)
 364                 spin_lock_irqsave(&itv->dma_reg_lock, flags);
 365         if (!test_bit(IVTV_F_I_DMA, &itv->i_flags)) {
 366                 ivtv_dma_dec_start(s);
 367         }
 368         else {
 369                 set_bit(IVTV_F_S_DMA_PENDING, &s->s_flags);
 370         }
 371         if (lock)
 372                 spin_unlock_irqrestore(&itv->dma_reg_lock, flags);
 373 }
 374
 375 static void ivtv_dma_enc_start_xfer(struct ivtv_stream *s)
 376 {
 377         struct ivtv *itv = s->itv;
 378
 379         s->sg_dma->src = cpu_to_le32(s->sg_processing[s->sg_processed].src);
 380         s->sg_dma->dst = cpu_to_le32(s->sg_processing[s->sg_processed].dst);
 381         s->sg_dma->size = cpu_to_le32(s->sg_processing[s->sg_processed].size | 0x80000000);
 382         s->sg_processed++;
 383         /* Sync Hardware SG List of buffers */
 384         ivtv_stream_sync_for_device(s);
 385         write_reg(s->sg_handle, IVTV_REG_ENCDMAADDR);
 386         write_reg_sync(read_reg(IVTV_REG_DMAXFER) | 0x02, IVTV_REG_DMAXFER);
 387         itv->dma_timer.expires = jiffies + msecs_to_jiffies(300);
 388         add_timer(&itv->dma_timer);
 389 }
 390
 391 static void ivtv_dma_dec_start_xfer(struct ivtv_stream *s)
 392 {
 393         struct ivtv *itv = s->itv;
 394
 395         s->sg_dma->src = cpu_to_le32(s->sg_processing[s->sg_processed].src);
 396         s->sg_dma->dst = cpu_to_le32(s->sg_processing[s->sg_processed].dst);
 397         s->sg_dma->size = cpu_to_le32(s->sg_processing[s->sg_processed].size | 0x80000000);
 398         s->sg_processed++;
 399         /* Sync Hardware SG List of buffers */
 400         ivtv_stream_sync_for_device(s);
 401         write_reg(s->sg_handle, IVTV_REG_DECDMAADDR);
 402         write_reg_sync(read_reg(IVTV_REG_DMAXFER) | 0x01, IVTV_REG_DMAXFER);
 403         itv->dma_timer.expires = jiffies + msecs_to_jiffies(300);
 404         add_timer(&itv->dma_timer);
 405 }
 406
 407 /* start the encoder DMA */
 408 static void ivtv_dma_enc_start(struct ivtv_stream *s)
 409 {
 410         struct ivtv *itv = s->itv;
 411         struct ivtv_stream *s_vbi = &itv->streams[IVTV_ENC_STREAM_TYPE_VBI];
 412         int i;
 413
 414         IVTV_DEBUG_HI_DMA("start %s for %s\n", ivtv_use_dma(s) ? "DMA" : "PIO", s->name);
 415
 416         if (s->q_predma.bytesused)
 417                 ivtv_queue_move(s, &s->q_predma, NULL, &s->q_dma, s->q_predma.bytesused);
 418
 419         if (ivtv_use_dma(s))
 420                 s->sg_pending[s->sg_pending_size - 1].size += 256;
 421
 422         /* If this is an MPEG stream, and VBI data is also pending, then append the
 423            VBI DMA to the MPEG DMA and transfer both sets of data at once.
 424
 425            VBI DMA is a second class citizen compared to MPEG and mixing them together
 426            will confuse the firmware (the end of a VBI DMA is seen as the end of a
 427            MPEG DMA, thus effectively dropping an MPEG frame). So instead we make
 428            sure we only use the MPEG DMA to transfer the VBI DMA if both are in
 429            use. This way no conflicts occur. */
 430         clear_bit(IVTV_F_S_DMA_HAS_VBI, &s->s_flags);
 431         if (s->type == IVTV_ENC_STREAM_TYPE_MPG && s_vbi->sg_pending_size &&
 432                         s->sg_pending_size + s_vbi->sg_pending_size <= s->buffers) {
 433                 ivtv_queue_move(s_vbi, &s_vbi->q_predma, NULL, &s_vbi->q_dma, s_vbi->q_predma.bytesused);
 434                 if (ivtv_use_dma(s_vbi))
 435                         s_vbi->sg_pending[s_vbi->sg_pending_size - 1].size += 256;
 436                 for (i = 0; i < s_vbi->sg_pending_size; i++) {
 437                         s->sg_pending[s->sg_pending_size++] = s_vbi->sg_pending[i];
 438                 }
 439                 s_vbi->dma_offset = s_vbi->pending_offset;
 440                 s_vbi->sg_pending_size = 0;
 441                 s_vbi->dma_xfer_cnt++;
 442                 set_bit(IVTV_F_S_DMA_HAS_VBI, &s->s_flags);
 443                 IVTV_DEBUG_HI_DMA("include DMA for %s\n", s_vbi->name);
 444         }
 445
 446         s->dma_xfer_cnt++;
 447         memcpy(s->sg_processing, s->sg_pending, sizeof(struct ivtv_sg_host_element) * s->sg_pending_size);
 448         s->sg_processing_size = s->sg_pending_size;
 449         s->sg_pending_size = 0;
 450         s->sg_processed = 0;
 451         s->dma_offset = s->pending_offset;
 452         s->dma_backup = s->pending_backup;
 453         s->dma_pts = s->pending_pts;
 454
 455         if (ivtv_use_pio(s)) {
 456                 set_bit(IVTV_F_I_WORK_HANDLER_PIO, &itv->i_flags);
 457                 set_bit(IVTV_F_I_HAVE_WORK, &itv->i_flags);
 458                 set_bit(IVTV_F_I_PIO, &itv->i_flags);
 459                 itv->cur_pio_stream = s->type;
 460         }
 461         else {
 462                 itv->dma_retries = 0;
 463                 ivtv_dma_enc_start_xfer(s);
 464                 set_bit(IVTV_F_I_DMA, &itv->i_flags);
 465                 itv->cur_dma_stream = s->type;
 466         }
 467 }
 468
 469 static void ivtv_dma_dec_start(struct ivtv_stream *s)
 470 {
 471         struct ivtv *itv = s->itv;
 472
 473         if (s->q_predma.bytesused)
 474                 ivtv_queue_move(s, &s->q_predma, NULL, &s->q_dma, s->q_predma.bytesused);
 475         s->dma_xfer_cnt++;
 476         memcpy(s->sg_processing, s->sg_pending, sizeof(struct ivtv_sg_host_element) * s->sg_pending_size);
 477         s->sg_processing_size = s->sg_pending_size;
 478         s->sg_pending_size = 0;
 479         s->sg_processed = 0;
 480
 481         IVTV_DEBUG_HI_DMA("start DMA for %s\n", s->name);
 482         itv->dma_retries = 0;
 483         ivtv_dma_dec_start_xfer(s);
 484         set_bit(IVTV_F_I_DMA, &itv->i_flags);
 485         itv->cur_dma_stream = s->type;
 486 }
 487
 488 static void ivtv_irq_dma_read(struct ivtv *itv)
 489 {
 490         struct ivtv_stream *s = NULL;
 491         struct ivtv_buffer *buf;
 492         int hw_stream_type = 0;
 493
 494         IVTV_DEBUG_HI_IRQ("DEC DMA READ\n");
 495
 496         del_timer(&itv->dma_timer);
 497
 498         if (!test_bit(IVTV_F_I_UDMA, &itv->i_flags) && itv->cur_dma_stream < 0)
 499                 return;
 500
 501         if (!test_bit(IVTV_F_I_UDMA, &itv->i_flags)) {
 502                 s = &itv->streams[itv->cur_dma_stream];
 503                 ivtv_stream_sync_for_cpu(s);
 504
 505                 if (read_reg(IVTV_REG_DMASTATUS) & 0x14) {
 506                         IVTV_DEBUG_WARN("DEC DMA ERROR %x (xfer %d of %d, retry %d)\n",
 507                                         read_reg(IVTV_REG_DMASTATUS),
 508                                         s->sg_processed, s->sg_processing_size, itv->dma_retries);
 509                         write_reg(read_reg(IVTV_REG_DMASTATUS) & 3, IVTV_REG_DMASTATUS);
 510                         if (itv->dma_retries == 3) {
 511                                 /* Too many retries, give up on this frame */
 512                                 itv->dma_retries = 0;
 513                                 s->sg_processed = s->sg_processing_size;
 514                         }
 515                         else {
 516                                 /* Retry, starting with the first xfer segment.
 517                                    Just retrying the current segment is not sufficient. */
 518                                 s->sg_processed = 0;
 519                                 itv->dma_retries++;
 520                         }
 521                 }
 522                 if (s->sg_processed < s->sg_processing_size) {
 523                         /* DMA next buffer */
 524                         ivtv_dma_dec_start_xfer(s);
 525                         return;
 526                 }
 527                 if (s->type == IVTV_DEC_STREAM_TYPE_YUV)
 528                         hw_stream_type = 2;
 529                 IVTV_DEBUG_HI_DMA("DEC DATA READ %s: %d\n", s->name, s->q_dma.bytesused);
 530
 531                 /* For some reason must kick the firmware, like PIO mode,
 532                    I think this tells the firmware we are done and the size
 533                    of the xfer so it can calculate what we need next.
 534                    I think we can do this part ourselves but would have to
 535                    fully calculate xfer info ourselves and not use interrupts
 536                  */
 537                 ivtv_vapi(itv, CX2341X_DEC_SCHED_DMA_FROM_HOST, 3, 0, s->q_dma.bytesused,
 538                                 hw_stream_type);
 539
 540                 /* Free last DMA call */
 541                 while ((buf = ivtv_dequeue(s, &s->q_dma)) != NULL) {
 542                         ivtv_buf_sync_for_cpu(s, buf);
 543                         ivtv_enqueue(s, buf, &s->q_free);
 544                 }
 545                 wake_up(&s->waitq);
 546         }
 547         clear_bit(IVTV_F_I_UDMA, &itv->i_flags);
 548         clear_bit(IVTV_F_I_DMA, &itv->i_flags);
 549         itv->cur_dma_stream = -1;
 550         wake_up(&itv->dma_waitq);
 551 }
 552
 553 static void ivtv_irq_enc_dma_complete(struct ivtv *itv)
 554 {
 555         u32 data[CX2341X_MBOX_MAX_DATA];
 556         struct ivtv_stream *s;
 557
 558         ivtv_api_get_data(&itv->enc_mbox, IVTV_MBOX_DMA_END, data);
 559         IVTV_DEBUG_HI_IRQ("ENC DMA COMPLETE %x %d (%d)\n", data[0], data[1], itv->cur_dma_stream);
 560
 561         del_timer(&itv->dma_timer);
 562
 563         if (itv->cur_dma_stream < 0)
 564                 return;
 565
 566         s = &itv->streams[itv->cur_dma_stream];
 567         ivtv_stream_sync_for_cpu(s);
 568
 569         if (data[0] & 0x18) {
 570                 IVTV_DEBUG_WARN("ENC DMA ERROR %x (offset %08x, xfer %d of %d, retry %d)\n", data[0],
 571                         s->dma_offset, s->sg_processed, s->sg_processing_size, itv->dma_retries);
 572                 write_reg(read_reg(IVTV_REG_DMASTATUS) & 3, IVTV_REG_DMASTATUS);
 573                 if (itv->dma_retries == 3) {
 574                         /* Too many retries, give up on this frame */
 575                         itv->dma_retries = 0;
 576                         s->sg_processed = s->sg_processing_size;
 577                 }
 578                 else {
 579                         /* Retry, starting with the first xfer segment.
 580                            Just retrying the current segment is not sufficient. */
 581                         s->sg_processed = 0;
 582                         itv->dma_retries++;
 583                 }
 584         }
 585         if (s->sg_processed < s->sg_processing_size) {
 586                 /* DMA next buffer */
 587                 ivtv_dma_enc_start_xfer(s);
 588                 return;
 589         }
 590         clear_bit(IVTV_F_I_DMA, &itv->i_flags);
 591         itv->cur_dma_stream = -1;
 592         dma_post(s);
 593         if (test_and_clear_bit(IVTV_F_S_DMA_HAS_VBI, &s->s_flags)) {
 594                 s = &itv->streams[IVTV_ENC_STREAM_TYPE_VBI];
 595                 dma_post(s);
 596         }
 597         s->sg_processing_size = 0;
 598         s->sg_processed = 0;
 599         wake_up(&itv->dma_waitq);
 600 }
 601
 602 static void ivtv_irq_enc_pio_complete(struct ivtv *itv)
 603 {
 604         struct ivtv_stream *s;
 605
 606         if (itv->cur_pio_stream < 0 || itv->cur_pio_stream >= IVTV_MAX_STREAMS) {
 607                 itv->cur_pio_stream = -1;
 608                 return;
 609         }
 610         s = &itv->streams[itv->cur_pio_stream];
 611         IVTV_DEBUG_HI_IRQ("ENC PIO COMPLETE %s\n", s->name);
 612         clear_bit(IVTV_F_I_PIO, &itv->i_flags);
 613         itv->cur_pio_stream = -1;
 614         dma_post(s);
 615         if (s->type == IVTV_ENC_STREAM_TYPE_MPG)
 616                 ivtv_vapi(itv, CX2341X_ENC_SCHED_DMA_TO_HOST, 3, 0, 0, 0);
 617         else if (s->type == IVTV_ENC_STREAM_TYPE_YUV)
 618                 ivtv_vapi(itv, CX2341X_ENC_SCHED_DMA_TO_HOST, 3, 0, 0, 1);
 619         else if (s->type == IVTV_ENC_STREAM_TYPE_PCM)
 620                 ivtv_vapi(itv, CX2341X_ENC_SCHED_DMA_TO_HOST, 3, 0, 0, 2);
 621         clear_bit(IVTV_F_I_PIO, &itv->i_flags);
 622         if (test_and_clear_bit(IVTV_F_S_DMA_HAS_VBI, &s->s_flags)) {
 623                 s = &itv->streams[IVTV_ENC_STREAM_TYPE_VBI];
 624                 dma_post(s);
 625         }
 626         wake_up(&itv->dma_waitq);
 627 }
 628
 629 static void ivtv_irq_dma_err(struct ivtv *itv)
 630 {
 631         u32 data[CX2341X_MBOX_MAX_DATA];
 632
 633         del_timer(&itv->dma_timer);
 634         ivtv_api_get_data(&itv->enc_mbox, IVTV_MBOX_DMA_END, data);
 635         IVTV_DEBUG_WARN("DMA ERROR %08x %08x %08x %d\n", data[0], data[1],
 636                                 read_reg(IVTV_REG_DMASTATUS), itv->cur_dma_stream);
 637         write_reg(read_reg(IVTV_REG_DMASTATUS) & 3, IVTV_REG_DMASTATUS);
 638         if (!test_bit(IVTV_F_I_UDMA, &itv->i_flags) &&
 639             itv->cur_dma_stream >= 0 && itv->cur_dma_stream < IVTV_MAX_STREAMS) {
 640                 struct ivtv_stream *s = &itv->streams[itv->cur_dma_stream];
 641
 642                 /* retry */
 643                 if (s->type >= IVTV_DEC_STREAM_TYPE_MPG)
 644                         ivtv_dma_dec_start(s);
 645                 else
 646                         ivtv_dma_enc_start(s);
 647                 return;
 648         }
 649         if (test_bit(IVTV_F_I_UDMA, &itv->i_flags)) {
 650                 ivtv_udma_start(itv);
 651                 return;
 652         }
 653         clear_bit(IVTV_F_I_UDMA, &itv->i_flags);
 654         clear_bit(IVTV_F_I_DMA, &itv->i_flags);
 655         itv->cur_dma_stream = -1;
 656         wake_up(&itv->dma_waitq);
 657 }
 658
 659 static void ivtv_irq_enc_start_cap(struct ivtv *itv)
 660 {
 661         u32 data[CX2341X_MBOX_MAX_DATA];
 662         struct ivtv_stream *s;
 663
 664         /* Get DMA destination and size arguments from card */
 665         ivtv_api_get_data(&itv->enc_mbox, IVTV_MBOX_DMA, data);
 666         IVTV_DEBUG_HI_IRQ("ENC START CAP %d: %08x %08x\n", data[0], data[1], data[2]);
 667
 668         if (data[0] > 2 || data[1] == 0 || data[2] == 0) {
 669                 IVTV_DEBUG_WARN("Unknown input: %08x %08x %08x\n",
 670                                 data[0], data[1], data[2]);
 671                 return;
 672         }
 673         s = &itv->streams[ivtv_stream_map[data[0]]];
 674         if (!stream_enc_dma_append(s, data)) {
 675                 set_bit(ivtv_use_pio(s) ? IVTV_F_S_PIO_PENDING : IVTV_F_S_DMA_PENDING, &s->s_flags);
 676         }
 677 }
 678
 679 static void ivtv_irq_enc_vbi_cap(struct ivtv *itv)
 680 {
 681         struct ivtv_stream *s_mpg = &itv->streams[IVTV_ENC_STREAM_TYPE_MPG];
 682         u32 data[CX2341X_MBOX_MAX_DATA];
 683         struct ivtv_stream *s;
 684
 685         IVTV_DEBUG_HI_IRQ("ENC START VBI CAP\n");
 686         s = &itv->streams[IVTV_ENC_STREAM_TYPE_VBI];
 687
 688         /* If more than two VBI buffers are pending, then
 689            clear the old ones and start with this new one.
 690            This can happen during transition stages when MPEG capturing is
 691            started, but the first interrupts haven't arrived yet. During
 692            that period VBI requests can accumulate without being able to
 693            DMA the data. Since at most four VBI DMA buffers are available,
 694            we just drop the old requests when there are already three
 695            requests queued. */
 696         if (s->sg_pending_size > 2) {
 697                 struct ivtv_buffer *buf;
 698                 list_for_each_entry(buf, &s->q_predma.list, list)
 699                         ivtv_buf_sync_for_cpu(s, buf);
 700                 ivtv_queue_move(s, &s->q_predma, NULL, &s->q_free, 0);
 701                 s->sg_pending_size = 0;
 702         }
 703         /* if we can append the data, and the MPEG stream isn't capturing,
 704            then start a DMA request for just the VBI data. */
 705         if (!stream_enc_dma_append(s, data) &&
 706                         !test_bit(IVTV_F_S_STREAMING, &s_mpg->s_flags)) {
 707                 set_bit(ivtv_use_pio(s) ? IVTV_F_S_PIO_PENDING : IVTV_F_S_DMA_PENDING, &s->s_flags);
 708         }
 709 }
 710
 711 static void ivtv_irq_dec_vbi_reinsert(struct ivtv *itv)
 712 {
 713         u32 data[CX2341X_MBOX_MAX_DATA];
 714         struct ivtv_stream *s = &itv->streams[IVTV_DEC_STREAM_TYPE_VBI];
 715
 716         IVTV_DEBUG_HI_IRQ("DEC VBI REINSERT\n");
 717         if (test_bit(IVTV_F_S_CLAIMED, &s->s_flags) &&
 718                         !stream_enc_dma_append(s, data)) {
 719                 set_bit(IVTV_F_S_PIO_PENDING, &s->s_flags);
 720         }
 721 }
 722
 723 static void ivtv_irq_dec_data_req(struct ivtv *itv)
 724 {
 725         u32 data[CX2341X_MBOX_MAX_DATA];
 726         struct ivtv_stream *s;
 727
 728         /* YUV or MPG */
 729         ivtv_api_get_data(&itv->dec_mbox, IVTV_MBOX_DMA, data);
 730
 731         if (test_bit(IVTV_F_I_DEC_YUV, &itv->i_flags)) {
 732                 itv->dma_data_req_size =
 733                                  1080 * ((itv->yuv_info.v4l2_src_h + 31) & ~31);
 734                 itv->dma_data_req_offset = data[1];
 735                 if (atomic_read(&itv->yuv_info.next_dma_frame) >= 0)
 736                         ivtv_yuv_frame_complete(itv);
 737                 s = &itv->streams[IVTV_DEC_STREAM_TYPE_YUV];
 738         }
 739         else {
 740                 itv->dma_data_req_size = min_t(u32, data[2], 0x10000);
 741                 itv->dma_data_req_offset = data[1];
 742                 s = &itv->streams[IVTV_DEC_STREAM_TYPE_MPG];
 743         }
 744         IVTV_DEBUG_HI_IRQ("DEC DATA REQ %s: %d %08x %u\n", s->name, s->q_full.bytesused,
 745                        itv->dma_data_req_offset, itv->dma_data_req_size);
 746         if (itv->dma_data_req_size == 0 || s->q_full.bytesused < itv->dma_data_req_size) {
 747                 set_bit(IVTV_F_S_NEEDS_DATA, &s->s_flags);
 748         }
 749         else {
 750                 if (test_bit(IVTV_F_I_DEC_YUV, &itv->i_flags))
 751                         ivtv_yuv_setup_stream_frame(itv);
 752                 clear_bit(IVTV_F_S_NEEDS_DATA, &s->s_flags);
 753                 ivtv_queue_move(s, &s->q_full, NULL, &s->q_predma, itv->dma_data_req_size);
 754                 ivtv_dma_stream_dec_prepare(s, itv->dma_data_req_offset + IVTV_DECODER_OFFSET, 0);
 755         }
 756 }
 757
 758 static void ivtv_irq_vsync(struct ivtv *itv)
 759 {
 760         /* The vsync interrupt is unusual in that it won't clear until
 761          * the end of the first line for the current field, at which
 762          * point it clears itself. This can result in repeated vsync
 763          * interrupts, or a missed vsync. Read some of the registers
 764          * to determine the line being displayed and ensure we handle
 765          * one vsync per frame.
 766          */
 767         unsigned int frame = read_reg(0x28c0) & 1;
 768         struct yuv_playback_info *yi = &itv->yuv_info;
 769         int last_dma_frame = atomic_read(&itv->yuv_info.next_dma_frame);
 770         struct yuv_frame_info *f = &yi->new_frame_info[last_dma_frame];
 771
 772         if (0) IVTV_DEBUG_IRQ("DEC VSYNC\n");
 773
 774         if (((frame ^ f->sync_field) == 0 &&
 775                 ((itv->last_vsync_field & 1) ^ f->sync_field)) ||
 776                         (frame != (itv->last_vsync_field & 1) && !f->interlaced)) {
 777                 int next_dma_frame = last_dma_frame;
 778
 779                 if (!(f->interlaced && f->delay && yi->fields_lapsed < 1)) {
 780                         if (next_dma_frame >= 0 && next_dma_frame != atomic_read(&yi->next_fill_frame)) {
 781                                 write_reg(yuv_offset[next_dma_frame] >> 4, 0x82c);
 782                                 write_reg((yuv_offset[next_dma_frame] + IVTV_YUV_BUFFER_UV_OFFSET) >> 4, 0x830);
 783                                 write_reg(yuv_offset[next_dma_frame] >> 4, 0x834);
 784                                 write_reg((yuv_offset[next_dma_frame] + IVTV_YUV_BUFFER_UV_OFFSET) >> 4, 0x838);
 785                                 next_dma_frame = (next_dma_frame + 1) % IVTV_YUV_BUFFERS;
 786                                 atomic_set(&yi->next_dma_frame, next_dma_frame);
 787                                 yi->fields_lapsed = -1;
 788                         }
 789                 }
 790         }
 791         if (frame != (itv->last_vsync_field & 1)) {
 792                 struct ivtv_stream *s = ivtv_get_output_stream(itv);
 793
 794                 itv->last_vsync_field += 1;
 795                 if (frame == 0) {
 796                         clear_bit(IVTV_F_I_VALID_DEC_TIMINGS, &itv->i_flags);
 797                         clear_bit(IVTV_F_I_EV_VSYNC_FIELD, &itv->i_flags);
 798                 }
 799                 else {
 800                         set_bit(IVTV_F_I_EV_VSYNC_FIELD, &itv->i_flags);
 801                 }
 802                 if (test_bit(IVTV_F_I_EV_VSYNC_ENABLED, &itv->i_flags)) {
 803                         set_bit(IVTV_F_I_EV_VSYNC, &itv->i_flags);
 804                         wake_up(&itv->event_waitq);
 805                 }
 806                 wake_up(&itv->vsync_waitq);
 807                 if (s)
 808                         wake_up(&s->waitq);
 809
 810                 /* Send VBI to saa7127 */
 811                 if (frame && (itv->output_mode == OUT_PASSTHROUGH ||
 812                         test_bit(IVTV_F_I_UPDATE_WSS, &itv->i_flags) ||
 813                         test_bit(IVTV_F_I_UPDATE_VPS, &itv->i_flags) ||
 814                         test_bit(IVTV_F_I_UPDATE_CC, &itv->i_flags))) {
 815                         set_bit(IVTV_F_I_WORK_HANDLER_VBI, &itv->i_flags);
 816                         set_bit(IVTV_F_I_HAVE_WORK, &itv->i_flags);
 817                 }
 818
 819                 /* Check if we need to update the yuv registers */
 820                 if ((yi->yuv_forced_update || f->update) && last_dma_frame != -1) {
 821                         if (!f->update) {
 822                                 last_dma_frame = (u8)(last_dma_frame - 1) % IVTV_YUV_BUFFERS;
 823                                 f = &yi->new_frame_info[last_dma_frame];
 824                         }
 825
 826                         if (f->src_w) {
 827                                 yi->update_frame = last_dma_frame;
 828                                 f->update = 0;
 829                                 yi->yuv_forced_update = 0;
 830                                 set_bit(IVTV_F_I_WORK_HANDLER_YUV, &itv->i_flags);
 831                                 set_bit(IVTV_F_I_HAVE_WORK, &itv->i_flags);
 832                         }
 833                 }
 834
 835                 yi->fields_lapsed++;
 836         }
 837 }
 838
 839 #define IVTV_IRQ_DMA (IVTV_IRQ_DMA_READ | IVTV_IRQ_ENC_DMA_COMPLETE | IVTV_IRQ_DMA_ERR | IVTV_IRQ_ENC_START_CAP | IVTV_IRQ_ENC_VBI_CAP | IVTV_IRQ_DEC_DATA_REQ | IVTV_IRQ_DEC_VBI_RE_INSERT)
 840
 841 irqreturn_t ivtv_irq_handler(int irq, void *dev_id)
 842 {
 843         struct ivtv *itv = (struct ivtv *)dev_id;
 844         u32 combo;
 845         u32 stat;
 846         int i;
 847         u8 vsync_force = 0;
 848
 849         spin_lock(&itv->dma_reg_lock);
 850         /* get contents of irq status register */
 851         stat = read_reg(IVTV_REG_IRQSTATUS);
 852
 853         combo = ~itv->irqmask & stat;
 854
 855         /* Clear out IRQ */
 856         if (combo) write_reg(combo, IVTV_REG_IRQSTATUS);
 857
 858         if (0 == combo) {
 859                 /* The vsync interrupt is unusual and clears itself. If we
 860                  * took too long, we may have missed it. Do some checks
 861                  */
 862                 if (~itv->irqmask & IVTV_IRQ_DEC_VSYNC) {
 863                         /* vsync is enabled, see if we're in a new field */
 864                         if ((itv->last_vsync_field & 1) != (read_reg(0x28c0) & 1)) {
 865                                 /* New field, looks like we missed it */
 866                                 IVTV_DEBUG_YUV("VSync interrupt missed %d\n",read_reg(0x28c0)>>16);
 867                                 vsync_force = 1;
 868                         }
 869                 }
 870
 871                 if (!vsync_force) {
 872                         /* No Vsync expected, wasn't for us */
 873                         spin_unlock(&itv->dma_reg_lock);
 874                         return IRQ_NONE;
 875                 }
 876         }
 877
 878         /* Exclude interrupts noted below from the output, otherwise the log is flooded with
 879            these messages */
 880         if (combo & ~0xff6d0400)
 881                 IVTV_DEBUG_HI_IRQ("======= valid IRQ bits: 0x%08x ======\n", combo);
 882
 883         if (combo & IVTV_IRQ_DEC_DMA_COMPLETE) {
 884                 IVTV_DEBUG_HI_IRQ("DEC DMA COMPLETE\n");
 885         }
 886
 887         if (combo & IVTV_IRQ_DMA_READ) {
 888                 ivtv_irq_dma_read(itv);
 889         }
 890
 891         if (combo & IVTV_IRQ_ENC_DMA_COMPLETE) {
 892                 ivtv_irq_enc_dma_complete(itv);
 893         }
 894
 895         if (combo & IVTV_IRQ_ENC_PIO_COMPLETE) {
 896                 ivtv_irq_enc_pio_complete(itv);
 897         }
 898
 899         if (combo & IVTV_IRQ_DMA_ERR) {
 900                 ivtv_irq_dma_err(itv);
 901         }
 902
 903         if (combo & IVTV_IRQ_ENC_START_CAP) {
 904                 ivtv_irq_enc_start_cap(itv);
 905         }
 906
 907         if (combo & IVTV_IRQ_ENC_VBI_CAP) {
 908                 ivtv_irq_enc_vbi_cap(itv);
 909         }
 910
 911         if (combo & IVTV_IRQ_DEC_VBI_RE_INSERT) {
 912                 ivtv_irq_dec_vbi_reinsert(itv);
 913         }
 914
 915         if (combo & IVTV_IRQ_ENC_EOS) {
 916                 IVTV_DEBUG_IRQ("ENC EOS\n");
 917                 set_bit(IVTV_F_I_EOS, &itv->i_flags);
 918                 wake_up(&itv->eos_waitq);
 919         }
 920
 921         if (combo & IVTV_IRQ_DEC_DATA_REQ) {
 922                 ivtv_irq_dec_data_req(itv);
 923         }
 924
 925         /* Decoder Vertical Sync - We can't rely on 'combo', so check if vsync enabled */
 926         if (~itv->irqmask & IVTV_IRQ_DEC_VSYNC) {
 927                 ivtv_irq_vsync(itv);
 928         }
 929
 930         if (combo & IVTV_IRQ_ENC_VIM_RST) {
 931                 IVTV_DEBUG_IRQ("VIM RST\n");
 932                 /*ivtv_vapi(itv, CX2341X_ENC_REFRESH_INPUT, 0); */
 933         }
 934
 935         if (combo & IVTV_IRQ_DEC_AUD_MODE_CHG) {
 936                 IVTV_DEBUG_INFO("Stereo mode changed\n");
 937         }
 938
 939         if ((combo & IVTV_IRQ_DMA) && !test_bit(IVTV_F_I_DMA, &itv->i_flags)) {
 940                 itv->irq_rr_idx++;
 941                 for (i = 0; i < IVTV_MAX_STREAMS; i++) {
 942                         int idx = (i + itv->irq_rr_idx) % IVTV_MAX_STREAMS;
 943                         struct ivtv_stream *s = &itv->streams[idx];
 944
 945                         if (!test_and_clear_bit(IVTV_F_S_DMA_PENDING, &s->s_flags))
 946                                 continue;
 947                         if (s->type >= IVTV_DEC_STREAM_TYPE_MPG)
 948                                 ivtv_dma_dec_start(s);
 949                         else
 950                                 ivtv_dma_enc_start(s);
 951                         break;
 952                 }
 953                 if (i == IVTV_MAX_STREAMS && test_and_clear_bit(IVTV_F_I_UDMA_PENDING, &itv->i_flags)) {
 954                         ivtv_udma_start(itv);
 955                 }
 956         }
 957
 958         if ((combo & IVTV_IRQ_DMA) && !test_bit(IVTV_F_I_PIO, &itv->i_flags)) {
 959                 itv->irq_rr_idx++;
 960                 for (i = 0; i < IVTV_MAX_STREAMS; i++) {
 961                         int idx = (i + itv->irq_rr_idx) % IVTV_MAX_STREAMS;
 962                         struct ivtv_stream *s = &itv->streams[idx];
 963
 964                         if (!test_and_clear_bit(IVTV_F_S_PIO_PENDING, &s->s_flags))
 965                                 continue;
 966                         if (s->type == IVTV_DEC_STREAM_TYPE_VBI || s->type < IVTV_DEC_STREAM_TYPE_MPG)
 967                                 ivtv_dma_enc_start(s);
 968                         break;
 969                 }
 970         }
 971
 972         if (test_and_clear_bit(IVTV_F_I_HAVE_WORK, &itv->i_flags)) {
 973                 queue_work(itv->irq_work_queues, &itv->irq_work_queue);
 974         }
 975
 976         spin_unlock(&itv->dma_reg_lock);
 977
 978         /* If we've just handled a 'forced' vsync, it's safest to say it
 979          * wasn't ours. Another device may have triggered it at just
 980          * the right time.
 981          */
 982         return vsync_force ? IRQ_NONE : IRQ_HANDLED;
 983 }
 984
 985 void ivtv_unfinished_dma(unsigned long arg)
 986 {
 987         struct ivtv *itv = (struct ivtv *)arg;
 988
 989         if (!test_bit(IVTV_F_I_DMA, &itv->i_flags))
 990                 return;
 991         IVTV_ERR("DMA TIMEOUT %08x %d\n", read_reg(IVTV_REG_DMASTATUS), itv->cur_dma_stream);
 992
 993         write_reg(read_reg(IVTV_REG_DMASTATUS) & 3, IVTV_REG_DMASTATUS);
 994         clear_bit(IVTV_F_I_UDMA, &itv->i_flags);
 995         clear_bit(IVTV_F_I_DMA, &itv->i_flags);
 996         itv->cur_dma_stream = -1;
 997         wake_up(&itv->dma_waitq);
 998 }