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>
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.
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.
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
21 #include "ivtv-driver.h"
22 #include "ivtv-queue.h"
23 #include "ivtv-udma.h"
25 #include "ivtv-mailbox.h"
29 #define DMA_MAGIC_COOKIE 0x000001fe
31 static void ivtv_dma_dec_start(struct ivtv_stream
*s
);
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
,
41 static void ivtv_pio_work_handler(struct ivtv
*itv
)
43 struct ivtv_stream
*s
= &itv
->streams
[itv
->cur_pio_stream
];
44 struct ivtv_buffer
*buf
;
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);
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;
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
);
64 memcpy_fromio(buf
->buf
, itv
->enc_mem
+ s
->sg_processing
[i
].src
, size
);
67 if (i
== s
->sg_processing_size
)
70 write_reg(IVTV_IRQ_ENC_PIO_COMPLETE
, 0x44);
73 void ivtv_irq_work_handler(struct work_struct
*work
)
75 struct ivtv
*itv
= container_of(work
, struct ivtv
, irq_work_queue
);
79 if (test_and_clear_bit(IVTV_F_I_WORK_HANDLER_PIO
, &itv
->i_flags
))
80 ivtv_pio_work_handler(itv
);
82 if (test_and_clear_bit(IVTV_F_I_WORK_HANDLER_VBI
, &itv
->i_flags
))
83 ivtv_vbi_work_handler(itv
);
85 if (test_and_clear_bit(IVTV_F_I_WORK_HANDLER_YUV
, &itv
->i_flags
))
86 ivtv_yuv_work_handler(itv
);
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.
93 static int stream_enc_dma_append(struct ivtv_stream
*s
, u32 data
[CX2341X_MBOX_MAX_DATA
])
95 struct ivtv
*itv
= s
->itv
;
96 struct ivtv_buffer
*buf
;
99 u32 UVoffset
= 0, UVsize
= 0;
100 int skip_bufs
= s
->q_predma
.buffers
;
101 int idx
= s
->sg_pending_size
;
105 if (s
->v4l2dev
== NULL
) {
106 IVTV_DEBUG_WARN("Stream %s not started\n", s
->name
);
109 if (!test_bit(IVTV_F_S_CLAIMED
, &s
->s_flags
)) {
110 IVTV_DEBUG_WARN("Stream %s not open\n", s
->name
);
114 /* determine offset, size and PTS for the various streams */
116 case IVTV_ENC_STREAM_TYPE_MPG
:
122 case IVTV_ENC_STREAM_TYPE_YUV
:
127 s
->pending_pts
= ((u64
) data
[5] << 32) | data
[6];
130 case IVTV_ENC_STREAM_TYPE_PCM
:
131 offset
= data
[1] + 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
;
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;
143 IVTV_DEBUG_INFO("VBI offset == 0\n");
146 s
->pending_pts
= read_enc(offset
- 4) | ((u64
)read_enc(offset
- 8) << 32);
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
;
153 offset
+= IVTV_DECODER_OFFSET
;
156 /* shouldn't happen */
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
);
168 s
->pending_backup
= read_enc(offset
);
169 write_enc_sync(cpu_to_le32(DMA_MAGIC_COOKIE
), offset
);
171 s
->pending_offset
= offset
;
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
179 bytes_needed
= s
->buf_size
* ((bytes_needed
+ s
->buf_size
- 1) / s
->buf_size
);
180 bytes_needed
+= UVsize
;
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
);
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
);
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");
196 s
->buffers_stolen
= rc
;
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
) {
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
= (size
< s
->buf_size
) ? size
: s
->buf_size
;
208 buf
->dma_xfer_cnt
= s
->dma_xfer_cnt
;
210 s
->q_predma
.bytesused
+= buf
->bytesused
;
211 size
-= buf
->bytesused
;
212 offset
+= s
->buf_size
;
214 /* Sync SG buffers */
215 ivtv_buf_sync_for_device(s
, buf
);
217 if (size
== 0) { /* YUV */
218 /* process the UV section */
224 s
->sg_pending_size
= idx
;
228 static void dma_post(struct ivtv_stream
*s
)
230 struct ivtv
*itv
= s
->itv
;
231 struct ivtv_buffer
*buf
= NULL
;
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
= (u32
*)buf
->buf
;
244 ivtv_buf_sync_for_cpu(s
, buf
);
246 if (x
== 0 && ivtv_use_dma(s
)) {
247 offset
= s
->dma_last_offset
;
248 if (u32buf
[offset
/ 4] != DMA_MAGIC_COOKIE
)
250 for (offset
= 0; offset
< 64; offset
++) {
251 if (u32buf
[offset
] == DMA_MAGIC_COOKIE
) {
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
;
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
;
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
);
269 write_enc_sync(0, s
->dma_offset
);
272 buf
->bytesused
-= offset
;
273 memcpy(buf
->buf
, buf
->buf
+ offset
, buf
->bytesused
+ offset
);
275 *u32buf
= cpu_to_le32(s
->dma_backup
);
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
;
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
;
293 ivtv_queue_move(s
, &s
->q_dma
, NULL
, &s
->q_free
, 0);
297 ivtv_queue_move(s
, &s
->q_dma
, NULL
, &s
->q_full
, s
->q_dma
.bytesused
);
302 void ivtv_dma_stream_dec_prepare(struct ivtv_stream
*s
, u32 offset
, int lock
)
304 struct ivtv
*itv
= s
->itv
;
305 struct ivtv_buffer
*buf
;
306 u32 y_size
= itv
->params
.height
* itv
->params
.width
;
307 u32 uv_offset
= offset
+ IVTV_YUV_BUFFER_UV_OFFSET
;
309 int bytes_written
= 0;
310 unsigned long flags
= 0;
313 IVTV_DEBUG_HI_DMA("DEC PREPARE DMA %s: %08x %08x\n", s
->name
, s
->q_predma
.bytesused
, offset
);
314 list_for_each_entry(buf
, &s
->q_predma
.list
, list
) {
315 /* YUV UV Offset from Y Buffer */
316 if (s
->type
== IVTV_DEC_STREAM_TYPE_YUV
&& !y_done
&&
317 (bytes_written
+ buf
->bytesused
) >= y_size
) {
318 s
->sg_pending
[idx
].src
= buf
->dma_handle
;
319 s
->sg_pending
[idx
].dst
= offset
;
320 s
->sg_pending
[idx
].size
= y_size
- bytes_written
;
322 if (s
->sg_pending
[idx
].size
!= buf
->bytesused
) {
324 s
->sg_pending
[idx
].src
=
325 buf
->dma_handle
+ s
->sg_pending
[idx
- 1].size
;
326 s
->sg_pending
[idx
].dst
= offset
;
327 s
->sg_pending
[idx
].size
=
328 buf
->bytesused
- s
->sg_pending
[idx
- 1].size
;
329 offset
+= s
->sg_pending
[idx
].size
;
333 s
->sg_pending
[idx
].src
= buf
->dma_handle
;
334 s
->sg_pending
[idx
].dst
= offset
;
335 s
->sg_pending
[idx
].size
= buf
->bytesused
;
336 offset
+= buf
->bytesused
;
338 bytes_written
+= buf
->bytesused
;
340 /* Sync SG buffers */
341 ivtv_buf_sync_for_device(s
, buf
);
344 s
->sg_pending_size
= idx
;
346 /* Sync Hardware SG List of buffers */
347 ivtv_stream_sync_for_device(s
);
349 spin_lock_irqsave(&itv
->dma_reg_lock
, flags
);
350 if (!test_bit(IVTV_F_I_DMA
, &itv
->i_flags
)) {
351 ivtv_dma_dec_start(s
);
354 set_bit(IVTV_F_S_DMA_PENDING
, &s
->s_flags
);
357 spin_unlock_irqrestore(&itv
->dma_reg_lock
, flags
);
360 static void ivtv_dma_enc_start_xfer(struct ivtv_stream
*s
)
362 struct ivtv
*itv
= s
->itv
;
364 s
->sg_dma
->src
= cpu_to_le32(s
->sg_processing
[s
->sg_processed
].src
);
365 s
->sg_dma
->dst
= cpu_to_le32(s
->sg_processing
[s
->sg_processed
].dst
);
366 s
->sg_dma
->size
= cpu_to_le32(s
->sg_processing
[s
->sg_processed
].size
| 0x80000000);
368 /* Sync Hardware SG List of buffers */
369 ivtv_stream_sync_for_device(s
);
370 write_reg(s
->sg_handle
, IVTV_REG_ENCDMAADDR
);
371 write_reg_sync(read_reg(IVTV_REG_DMAXFER
) | 0x02, IVTV_REG_DMAXFER
);
374 static void ivtv_dma_dec_start_xfer(struct ivtv_stream
*s
)
376 struct ivtv
*itv
= s
->itv
;
378 s
->sg_dma
->src
= cpu_to_le32(s
->sg_processing
[s
->sg_processed
].src
);
379 s
->sg_dma
->dst
= cpu_to_le32(s
->sg_processing
[s
->sg_processed
].dst
);
380 s
->sg_dma
->size
= cpu_to_le32(s
->sg_processing
[s
->sg_processed
].size
| 0x80000000);
382 /* Sync Hardware SG List of buffers */
383 ivtv_stream_sync_for_device(s
);
384 write_reg(s
->sg_handle
, IVTV_REG_DECDMAADDR
);
385 write_reg_sync(read_reg(IVTV_REG_DMAXFER
) | 0x01, IVTV_REG_DMAXFER
);
388 /* start the encoder DMA */
389 static void ivtv_dma_enc_start(struct ivtv_stream
*s
)
391 struct ivtv
*itv
= s
->itv
;
392 struct ivtv_stream
*s_vbi
= &itv
->streams
[IVTV_ENC_STREAM_TYPE_VBI
];
395 IVTV_DEBUG_HI_DMA("start %s for %s\n", ivtv_use_dma(s
) ? "DMA" : "PIO", s
->name
);
397 if (s
->q_predma
.bytesused
)
398 ivtv_queue_move(s
, &s
->q_predma
, NULL
, &s
->q_dma
, s
->q_predma
.bytesused
);
401 s
->sg_pending
[s
->sg_pending_size
- 1].size
+= 256;
403 /* If this is an MPEG stream, and VBI data is also pending, then append the
404 VBI DMA to the MPEG DMA and transfer both sets of data at once.
406 VBI DMA is a second class citizen compared to MPEG and mixing them together
407 will confuse the firmware (the end of a VBI DMA is seen as the end of a
408 MPEG DMA, thus effectively dropping an MPEG frame). So instead we make
409 sure we only use the MPEG DMA to transfer the VBI DMA if both are in
410 use. This way no conflicts occur. */
411 clear_bit(IVTV_F_S_DMA_HAS_VBI
, &s
->s_flags
);
412 if (s
->type
== IVTV_ENC_STREAM_TYPE_MPG
&& s_vbi
->sg_pending_size
&&
413 s
->sg_pending_size
+ s_vbi
->sg_pending_size
<= s
->buffers
) {
414 ivtv_queue_move(s_vbi
, &s_vbi
->q_predma
, NULL
, &s_vbi
->q_dma
, s_vbi
->q_predma
.bytesused
);
415 if (ivtv_use_dma(s_vbi
))
416 s_vbi
->sg_pending
[s_vbi
->sg_pending_size
- 1].size
+= 256;
417 for (i
= 0; i
< s_vbi
->sg_pending_size
; i
++) {
418 s
->sg_pending
[s
->sg_pending_size
++] = s_vbi
->sg_pending
[i
];
420 s_vbi
->dma_offset
= s_vbi
->pending_offset
;
421 s_vbi
->sg_pending_size
= 0;
422 s_vbi
->dma_xfer_cnt
++;
423 set_bit(IVTV_F_S_DMA_HAS_VBI
, &s
->s_flags
);
424 IVTV_DEBUG_HI_DMA("include DMA for %s\n", s
->name
);
428 memcpy(s
->sg_processing
, s
->sg_pending
, sizeof(struct ivtv_sg_element
) * s
->sg_pending_size
);
429 s
->sg_processing_size
= s
->sg_pending_size
;
430 s
->sg_pending_size
= 0;
432 s
->dma_offset
= s
->pending_offset
;
433 s
->dma_backup
= s
->pending_backup
;
434 s
->dma_pts
= s
->pending_pts
;
436 if (ivtv_use_pio(s
)) {
437 set_bit(IVTV_F_I_WORK_HANDLER_PIO
, &itv
->i_flags
);
438 set_bit(IVTV_F_I_HAVE_WORK
, &itv
->i_flags
);
439 set_bit(IVTV_F_I_PIO
, &itv
->i_flags
);
440 itv
->cur_pio_stream
= s
->type
;
443 itv
->dma_retries
= 0;
444 ivtv_dma_enc_start_xfer(s
);
445 set_bit(IVTV_F_I_DMA
, &itv
->i_flags
);
446 itv
->cur_dma_stream
= s
->type
;
447 itv
->dma_timer
.expires
= jiffies
+ msecs_to_jiffies(100);
448 add_timer(&itv
->dma_timer
);
452 static void ivtv_dma_dec_start(struct ivtv_stream
*s
)
454 struct ivtv
*itv
= s
->itv
;
456 if (s
->q_predma
.bytesused
)
457 ivtv_queue_move(s
, &s
->q_predma
, NULL
, &s
->q_dma
, s
->q_predma
.bytesused
);
459 memcpy(s
->sg_processing
, s
->sg_pending
, sizeof(struct ivtv_sg_element
) * s
->sg_pending_size
);
460 s
->sg_processing_size
= s
->sg_pending_size
;
461 s
->sg_pending_size
= 0;
464 IVTV_DEBUG_HI_DMA("start DMA for %s\n", s
->name
);
465 itv
->dma_retries
= 0;
466 ivtv_dma_dec_start_xfer(s
);
467 set_bit(IVTV_F_I_DMA
, &itv
->i_flags
);
468 itv
->cur_dma_stream
= s
->type
;
469 itv
->dma_timer
.expires
= jiffies
+ msecs_to_jiffies(100);
470 add_timer(&itv
->dma_timer
);
473 static void ivtv_irq_dma_read(struct ivtv
*itv
)
475 struct ivtv_stream
*s
= NULL
;
476 struct ivtv_buffer
*buf
;
477 int hw_stream_type
= 0;
479 IVTV_DEBUG_HI_IRQ("DEC DMA READ\n");
480 if (!test_bit(IVTV_F_I_UDMA
, &itv
->i_flags
) && itv
->cur_dma_stream
< 0) {
481 del_timer(&itv
->dma_timer
);
485 if (!test_bit(IVTV_F_I_UDMA
, &itv
->i_flags
)) {
486 s
= &itv
->streams
[itv
->cur_dma_stream
];
487 ivtv_stream_sync_for_cpu(s
);
489 if (read_reg(IVTV_REG_DMASTATUS
) & 0x14) {
490 IVTV_DEBUG_WARN("DEC DMA ERROR %x (xfer %d of %d, retry %d)\n",
491 read_reg(IVTV_REG_DMASTATUS
),
492 s
->sg_processed
, s
->sg_processing_size
, itv
->dma_retries
);
493 write_reg(read_reg(IVTV_REG_DMASTATUS
) & 3, IVTV_REG_DMASTATUS
);
494 if (itv
->dma_retries
== 3) {
495 /* Too many retries, give up on this frame */
496 itv
->dma_retries
= 0;
497 s
->sg_processed
= s
->sg_processing_size
;
500 /* Retry, starting with the first xfer segment.
501 Just retrying the current segment is not sufficient. */
506 if (s
->sg_processed
< s
->sg_processing_size
) {
507 /* DMA next buffer */
508 ivtv_dma_dec_start_xfer(s
);
511 if (s
->type
== IVTV_DEC_STREAM_TYPE_YUV
)
513 IVTV_DEBUG_HI_DMA("DEC DATA READ %s: %d\n", s
->name
, s
->q_dma
.bytesused
);
515 /* For some reason must kick the firmware, like PIO mode,
516 I think this tells the firmware we are done and the size
517 of the xfer so it can calculate what we need next.
518 I think we can do this part ourselves but would have to
519 fully calculate xfer info ourselves and not use interrupts
521 ivtv_vapi(itv
, CX2341X_DEC_SCHED_DMA_FROM_HOST
, 3, 0, s
->q_dma
.bytesused
,
524 /* Free last DMA call */
525 while ((buf
= ivtv_dequeue(s
, &s
->q_dma
)) != NULL
) {
526 ivtv_buf_sync_for_cpu(s
, buf
);
527 ivtv_enqueue(s
, buf
, &s
->q_free
);
531 del_timer(&itv
->dma_timer
);
532 clear_bit(IVTV_F_I_UDMA
, &itv
->i_flags
);
533 clear_bit(IVTV_F_I_DMA
, &itv
->i_flags
);
534 itv
->cur_dma_stream
= -1;
535 wake_up(&itv
->dma_waitq
);
538 static void ivtv_irq_enc_dma_complete(struct ivtv
*itv
)
540 u32 data
[CX2341X_MBOX_MAX_DATA
];
541 struct ivtv_stream
*s
;
543 ivtv_api_get_data(&itv
->enc_mbox
, IVTV_MBOX_DMA_END
, data
);
544 IVTV_DEBUG_HI_IRQ("ENC DMA COMPLETE %x %d (%d)\n", data
[0], data
[1], itv
->cur_dma_stream
);
545 if (itv
->cur_dma_stream
< 0) {
546 del_timer(&itv
->dma_timer
);
549 s
= &itv
->streams
[itv
->cur_dma_stream
];
550 ivtv_stream_sync_for_cpu(s
);
552 if (data
[0] & 0x18) {
553 IVTV_DEBUG_WARN("ENC DMA ERROR %x (offset %08x, xfer %d of %d, retry %d)\n", data
[0],
554 s
->dma_offset
, s
->sg_processed
, s
->sg_processing_size
, itv
->dma_retries
);
555 write_reg(read_reg(IVTV_REG_DMASTATUS
) & 3, IVTV_REG_DMASTATUS
);
556 if (itv
->dma_retries
== 3) {
557 /* Too many retries, give up on this frame */
558 itv
->dma_retries
= 0;
559 s
->sg_processed
= s
->sg_processing_size
;
562 /* Retry, starting with the first xfer segment.
563 Just retrying the current segment is not sufficient. */
568 if (s
->sg_processed
< s
->sg_processing_size
) {
569 /* DMA next buffer */
570 ivtv_dma_enc_start_xfer(s
);
573 del_timer(&itv
->dma_timer
);
574 clear_bit(IVTV_F_I_DMA
, &itv
->i_flags
);
575 itv
->cur_dma_stream
= -1;
577 if (test_and_clear_bit(IVTV_F_S_DMA_HAS_VBI
, &s
->s_flags
)) {
578 s
= &itv
->streams
[IVTV_ENC_STREAM_TYPE_VBI
];
581 s
->sg_processing_size
= 0;
583 wake_up(&itv
->dma_waitq
);
586 static void ivtv_irq_enc_pio_complete(struct ivtv
*itv
)
588 struct ivtv_stream
*s
;
590 if (itv
->cur_pio_stream
< 0 || itv
->cur_pio_stream
>= IVTV_MAX_STREAMS
) {
591 itv
->cur_pio_stream
= -1;
594 s
= &itv
->streams
[itv
->cur_pio_stream
];
595 IVTV_DEBUG_HI_IRQ("ENC PIO COMPLETE %s\n", s
->name
);
596 clear_bit(IVTV_F_I_PIO
, &itv
->i_flags
);
597 itv
->cur_pio_stream
= -1;
599 if (s
->type
== IVTV_ENC_STREAM_TYPE_MPG
)
600 ivtv_vapi(itv
, CX2341X_ENC_SCHED_DMA_TO_HOST
, 3, 0, 0, 0);
601 else if (s
->type
== IVTV_ENC_STREAM_TYPE_YUV
)
602 ivtv_vapi(itv
, CX2341X_ENC_SCHED_DMA_TO_HOST
, 3, 0, 0, 1);
603 else if (s
->type
== IVTV_ENC_STREAM_TYPE_PCM
)
604 ivtv_vapi(itv
, CX2341X_ENC_SCHED_DMA_TO_HOST
, 3, 0, 0, 2);
605 clear_bit(IVTV_F_I_PIO
, &itv
->i_flags
);
606 if (test_and_clear_bit(IVTV_F_S_DMA_HAS_VBI
, &s
->s_flags
)) {
607 s
= &itv
->streams
[IVTV_ENC_STREAM_TYPE_VBI
];
610 wake_up(&itv
->dma_waitq
);
613 static void ivtv_irq_dma_err(struct ivtv
*itv
)
615 u32 data
[CX2341X_MBOX_MAX_DATA
];
617 del_timer(&itv
->dma_timer
);
618 ivtv_api_get_data(&itv
->enc_mbox
, IVTV_MBOX_DMA_END
, data
);
619 IVTV_DEBUG_WARN("DMA ERROR %08x %08x %08x %d\n", data
[0], data
[1],
620 read_reg(IVTV_REG_DMASTATUS
), itv
->cur_dma_stream
);
621 write_reg(read_reg(IVTV_REG_DMASTATUS
) & 3, IVTV_REG_DMASTATUS
);
622 if (!test_bit(IVTV_F_I_UDMA
, &itv
->i_flags
) &&
623 itv
->cur_dma_stream
>= 0 && itv
->cur_dma_stream
< IVTV_MAX_STREAMS
) {
624 struct ivtv_stream
*s
= &itv
->streams
[itv
->cur_dma_stream
];
627 if (s
->type
>= IVTV_DEC_STREAM_TYPE_MPG
)
628 ivtv_dma_dec_start(s
);
630 ivtv_dma_enc_start(s
);
633 if (test_bit(IVTV_F_I_UDMA
, &itv
->i_flags
)) {
634 ivtv_udma_start(itv
);
637 clear_bit(IVTV_F_I_UDMA
, &itv
->i_flags
);
638 clear_bit(IVTV_F_I_DMA
, &itv
->i_flags
);
639 itv
->cur_dma_stream
= -1;
640 wake_up(&itv
->dma_waitq
);
643 static void ivtv_irq_enc_start_cap(struct ivtv
*itv
)
645 u32 data
[CX2341X_MBOX_MAX_DATA
];
646 struct ivtv_stream
*s
;
648 /* Get DMA destination and size arguments from card */
649 ivtv_api_get_data(&itv
->enc_mbox
, IVTV_MBOX_DMA
, data
);
650 IVTV_DEBUG_HI_IRQ("ENC START CAP %d: %08x %08x\n", data
[0], data
[1], data
[2]);
652 if (data
[0] > 2 || data
[1] == 0 || data
[2] == 0) {
653 IVTV_DEBUG_WARN("Unknown input: %08x %08x %08x\n",
654 data
[0], data
[1], data
[2]);
657 s
= &itv
->streams
[ivtv_stream_map
[data
[0]]];
658 if (!stream_enc_dma_append(s
, data
)) {
659 set_bit(ivtv_use_pio(s
) ? IVTV_F_S_PIO_PENDING
: IVTV_F_S_DMA_PENDING
, &s
->s_flags
);
663 static void ivtv_irq_enc_vbi_cap(struct ivtv
*itv
)
665 struct ivtv_stream
*s_mpg
= &itv
->streams
[IVTV_ENC_STREAM_TYPE_MPG
];
666 u32 data
[CX2341X_MBOX_MAX_DATA
];
667 struct ivtv_stream
*s
;
669 IVTV_DEBUG_HI_IRQ("ENC START VBI CAP\n");
670 s
= &itv
->streams
[IVTV_ENC_STREAM_TYPE_VBI
];
672 /* If more than two VBI buffers are pending, then
673 clear the old ones and start with this new one.
674 This can happen during transition stages when MPEG capturing is
675 started, but the first interrupts haven't arrived yet. During
676 that period VBI requests can accumulate without being able to
677 DMA the data. Since at most four VBI DMA buffers are available,
678 we just drop the old requests when there are already three
680 if (s
->sg_pending_size
> 2) {
681 struct ivtv_buffer
*buf
;
682 list_for_each_entry(buf
, &s
->q_predma
.list
, list
)
683 ivtv_buf_sync_for_cpu(s
, buf
);
684 ivtv_queue_move(s
, &s
->q_predma
, NULL
, &s
->q_free
, 0);
685 s
->sg_pending_size
= 0;
687 /* if we can append the data, and the MPEG stream isn't capturing,
688 then start a DMA request for just the VBI data. */
689 if (!stream_enc_dma_append(s
, data
) &&
690 !test_bit(IVTV_F_S_STREAMING
, &s_mpg
->s_flags
)) {
691 set_bit(ivtv_use_pio(s
) ? IVTV_F_S_PIO_PENDING
: IVTV_F_S_DMA_PENDING
, &s
->s_flags
);
695 static void ivtv_irq_dec_vbi_reinsert(struct ivtv
*itv
)
697 u32 data
[CX2341X_MBOX_MAX_DATA
];
698 struct ivtv_stream
*s
= &itv
->streams
[IVTV_DEC_STREAM_TYPE_VBI
];
700 IVTV_DEBUG_HI_IRQ("DEC VBI REINSERT\n");
701 if (test_bit(IVTV_F_S_CLAIMED
, &s
->s_flags
) &&
702 !stream_enc_dma_append(s
, data
)) {
703 set_bit(IVTV_F_S_PIO_PENDING
, &s
->s_flags
);
707 static void ivtv_irq_dec_data_req(struct ivtv
*itv
)
709 u32 data
[CX2341X_MBOX_MAX_DATA
];
710 struct ivtv_stream
*s
;
713 ivtv_api_get_data(&itv
->dec_mbox
, IVTV_MBOX_DMA
, data
);
715 if (test_bit(IVTV_F_I_DEC_YUV
, &itv
->i_flags
)) {
716 itv
->dma_data_req_size
= itv
->params
.width
* itv
->params
.height
* 3 / 2;
717 itv
->dma_data_req_offset
= data
[1] ? data
[1] : yuv_offset
[0];
718 s
= &itv
->streams
[IVTV_DEC_STREAM_TYPE_YUV
];
721 itv
->dma_data_req_size
= data
[2] >= 0x10000 ? 0x10000 : data
[2];
722 itv
->dma_data_req_offset
= data
[1];
723 s
= &itv
->streams
[IVTV_DEC_STREAM_TYPE_MPG
];
725 IVTV_DEBUG_HI_IRQ("DEC DATA REQ %s: %d %08x %u\n", s
->name
, s
->q_full
.bytesused
,
726 itv
->dma_data_req_offset
, itv
->dma_data_req_size
);
727 if (itv
->dma_data_req_size
== 0 || s
->q_full
.bytesused
< itv
->dma_data_req_size
) {
728 set_bit(IVTV_F_S_NEEDS_DATA
, &s
->s_flags
);
731 clear_bit(IVTV_F_S_NEEDS_DATA
, &s
->s_flags
);
732 ivtv_queue_move(s
, &s
->q_full
, NULL
, &s
->q_predma
, itv
->dma_data_req_size
);
733 ivtv_dma_stream_dec_prepare(s
, itv
->dma_data_req_offset
+ IVTV_DECODER_OFFSET
, 0);
737 static void ivtv_irq_vsync(struct ivtv
*itv
)
739 /* The vsync interrupt is unusual in that it won't clear until
740 * the end of the first line for the current field, at which
741 * point it clears itself. This can result in repeated vsync
742 * interrupts, or a missed vsync. Read some of the registers
743 * to determine the line being displayed and ensure we handle
744 * one vsync per frame.
746 unsigned int frame
= read_reg(0x28c0) & 1;
747 struct yuv_playback_info
*yi
= &itv
->yuv_info
;
748 int last_dma_frame
= atomic_read(&itv
->yuv_info
.next_dma_frame
);
750 if (0) IVTV_DEBUG_IRQ("DEC VSYNC\n");
752 if (((frame
^ yi
->sync_field
[last_dma_frame
]) == 0 &&
753 ((itv
->last_vsync_field
& 1) ^ yi
->sync_field
[last_dma_frame
])) ||
754 (frame
!= (itv
->last_vsync_field
& 1) && !yi
->frame_interlaced
)) {
755 int next_dma_frame
= last_dma_frame
;
757 if (!(yi
->frame_interlaced
&& yi
->field_delay
[next_dma_frame
] && yi
->fields_lapsed
< 1)) {
758 if (next_dma_frame
>= 0 && next_dma_frame
!= atomic_read(&yi
->next_fill_frame
)) {
759 write_reg(yuv_offset
[next_dma_frame
] >> 4, 0x82c);
760 write_reg((yuv_offset
[next_dma_frame
] + IVTV_YUV_BUFFER_UV_OFFSET
) >> 4, 0x830);
761 write_reg(yuv_offset
[next_dma_frame
] >> 4, 0x834);
762 write_reg((yuv_offset
[next_dma_frame
] + IVTV_YUV_BUFFER_UV_OFFSET
) >> 4, 0x838);
763 next_dma_frame
= (next_dma_frame
+ 1) % IVTV_YUV_BUFFERS
;
764 atomic_set(&yi
->next_dma_frame
, next_dma_frame
);
765 yi
->fields_lapsed
= -1;
769 if (frame
!= (itv
->last_vsync_field
& 1)) {
770 struct ivtv_stream
*s
= ivtv_get_output_stream(itv
);
772 itv
->last_vsync_field
+= 1;
774 clear_bit(IVTV_F_I_VALID_DEC_TIMINGS
, &itv
->i_flags
);
775 clear_bit(IVTV_F_I_EV_VSYNC_FIELD
, &itv
->i_flags
);
778 set_bit(IVTV_F_I_EV_VSYNC_FIELD
, &itv
->i_flags
);
780 if (test_bit(IVTV_F_I_EV_VSYNC_ENABLED
, &itv
->i_flags
)) {
781 set_bit(IVTV_F_I_EV_VSYNC
, &itv
->i_flags
);
782 wake_up(&itv
->event_waitq
);
784 wake_up(&itv
->vsync_waitq
);
788 /* Send VBI to saa7127 */
789 if (frame
&& (itv
->output_mode
== OUT_PASSTHROUGH
||
790 test_bit(IVTV_F_I_UPDATE_WSS
, &itv
->i_flags
) ||
791 test_bit(IVTV_F_I_UPDATE_VPS
, &itv
->i_flags
) ||
792 test_bit(IVTV_F_I_UPDATE_CC
, &itv
->i_flags
))) {
793 set_bit(IVTV_F_I_WORK_HANDLER_VBI
, &itv
->i_flags
);
794 set_bit(IVTV_F_I_HAVE_WORK
, &itv
->i_flags
);
797 /* Check if we need to update the yuv registers */
798 if ((yi
->yuv_forced_update
|| yi
->new_frame_info
[last_dma_frame
].update
) && last_dma_frame
!= -1) {
799 if (!yi
->new_frame_info
[last_dma_frame
].update
)
800 last_dma_frame
= (u8
)(last_dma_frame
- 1) % IVTV_YUV_BUFFERS
;
802 if (yi
->new_frame_info
[last_dma_frame
].src_w
) {
803 yi
->update_frame
= last_dma_frame
;
804 yi
->new_frame_info
[last_dma_frame
].update
= 0;
805 yi
->yuv_forced_update
= 0;
806 set_bit(IVTV_F_I_WORK_HANDLER_YUV
, &itv
->i_flags
);
807 set_bit(IVTV_F_I_HAVE_WORK
, &itv
->i_flags
);
815 #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)
817 irqreturn_t
ivtv_irq_handler(int irq
, void *dev_id
)
819 struct ivtv
*itv
= (struct ivtv
*)dev_id
;
825 spin_lock(&itv
->dma_reg_lock
);
826 /* get contents of irq status register */
827 stat
= read_reg(IVTV_REG_IRQSTATUS
);
829 combo
= ~itv
->irqmask
& stat
;
832 if (combo
) write_reg(combo
, IVTV_REG_IRQSTATUS
);
835 /* The vsync interrupt is unusual and clears itself. If we
836 * took too long, we may have missed it. Do some checks
838 if (~itv
->irqmask
& IVTV_IRQ_DEC_VSYNC
) {
839 /* vsync is enabled, see if we're in a new field */
840 if ((itv
->last_vsync_field
& 1) != (read_reg(0x28c0) & 1)) {
841 /* New field, looks like we missed it */
842 IVTV_DEBUG_YUV("VSync interrupt missed %d\n",read_reg(0x28c0)>>16);
848 /* No Vsync expected, wasn't for us */
849 spin_unlock(&itv
->dma_reg_lock
);
854 /* Exclude interrupts noted below from the output, otherwise the log is flooded with
856 if (combo
& ~0xff6d0400)
857 IVTV_DEBUG_HI_IRQ("======= valid IRQ bits: 0x%08x ======\n", combo
);
859 if (combo
& IVTV_IRQ_DEC_DMA_COMPLETE
) {
860 IVTV_DEBUG_HI_IRQ("DEC DMA COMPLETE\n");
863 if (combo
& IVTV_IRQ_DMA_READ
) {
864 ivtv_irq_dma_read(itv
);
867 if (combo
& IVTV_IRQ_ENC_DMA_COMPLETE
) {
868 ivtv_irq_enc_dma_complete(itv
);
871 if (combo
& IVTV_IRQ_ENC_PIO_COMPLETE
) {
872 ivtv_irq_enc_pio_complete(itv
);
875 if (combo
& IVTV_IRQ_DMA_ERR
) {
876 ivtv_irq_dma_err(itv
);
879 if (combo
& IVTV_IRQ_ENC_START_CAP
) {
880 ivtv_irq_enc_start_cap(itv
);
883 if (combo
& IVTV_IRQ_ENC_VBI_CAP
) {
884 ivtv_irq_enc_vbi_cap(itv
);
887 if (combo
& IVTV_IRQ_DEC_VBI_RE_INSERT
) {
888 ivtv_irq_dec_vbi_reinsert(itv
);
891 if (combo
& IVTV_IRQ_ENC_EOS
) {
892 IVTV_DEBUG_IRQ("ENC EOS\n");
893 set_bit(IVTV_F_I_EOS
, &itv
->i_flags
);
894 wake_up(&itv
->eos_waitq
);
897 if (combo
& IVTV_IRQ_DEC_DATA_REQ
) {
898 ivtv_irq_dec_data_req(itv
);
901 /* Decoder Vertical Sync - We can't rely on 'combo', so check if vsync enabled */
902 if (~itv
->irqmask
& IVTV_IRQ_DEC_VSYNC
) {
906 if (combo
& IVTV_IRQ_ENC_VIM_RST
) {
907 IVTV_DEBUG_IRQ("VIM RST\n");
908 /*ivtv_vapi(itv, CX2341X_ENC_REFRESH_INPUT, 0); */
911 if (combo
& IVTV_IRQ_DEC_AUD_MODE_CHG
) {
912 IVTV_DEBUG_INFO("Stereo mode changed\n");
915 if ((combo
& IVTV_IRQ_DMA
) && !test_bit(IVTV_F_I_DMA
, &itv
->i_flags
)) {
917 for (i
= 0; i
< IVTV_MAX_STREAMS
; i
++) {
918 int idx
= (i
+ itv
->irq_rr_idx
) % IVTV_MAX_STREAMS
;
919 struct ivtv_stream
*s
= &itv
->streams
[idx
];
921 if (!test_and_clear_bit(IVTV_F_S_DMA_PENDING
, &s
->s_flags
))
923 if (s
->type
>= IVTV_DEC_STREAM_TYPE_MPG
)
924 ivtv_dma_dec_start(s
);
926 ivtv_dma_enc_start(s
);
929 if (i
== IVTV_MAX_STREAMS
&& test_and_clear_bit(IVTV_F_I_UDMA_PENDING
, &itv
->i_flags
)) {
930 ivtv_udma_start(itv
);
934 if ((combo
& IVTV_IRQ_DMA
) && !test_bit(IVTV_F_I_PIO
, &itv
->i_flags
)) {
936 for (i
= 0; i
< IVTV_MAX_STREAMS
; i
++) {
937 int idx
= (i
+ itv
->irq_rr_idx
) % IVTV_MAX_STREAMS
;
938 struct ivtv_stream
*s
= &itv
->streams
[idx
];
940 if (!test_and_clear_bit(IVTV_F_S_PIO_PENDING
, &s
->s_flags
))
942 if (s
->type
== IVTV_DEC_STREAM_TYPE_VBI
|| s
->type
< IVTV_DEC_STREAM_TYPE_MPG
)
943 ivtv_dma_enc_start(s
);
948 if (test_and_clear_bit(IVTV_F_I_HAVE_WORK
, &itv
->i_flags
)) {
949 queue_work(itv
->irq_work_queues
, &itv
->irq_work_queue
);
952 spin_unlock(&itv
->dma_reg_lock
);
954 /* If we've just handled a 'forced' vsync, it's safest to say it
955 * wasn't ours. Another device may have triggered it at just
958 return vsync_force
? IRQ_NONE
: IRQ_HANDLED
;
961 void ivtv_unfinished_dma(unsigned long arg
)
963 struct ivtv
*itv
= (struct ivtv
*)arg
;
965 if (!test_bit(IVTV_F_I_DMA
, &itv
->i_flags
))
967 IVTV_ERR("DMA TIMEOUT %08x %d\n", read_reg(IVTV_REG_DMASTATUS
), itv
->cur_dma_stream
);
969 write_reg(read_reg(IVTV_REG_DMASTATUS
) & 3, IVTV_REG_DMASTATUS
);
970 clear_bit(IVTV_F_I_UDMA
, &itv
->i_flags
);
971 clear_bit(IVTV_F_I_DMA
, &itv
->i_flags
);
972 itv
->cur_dma_stream
= -1;
973 wake_up(&itv
->dma_waitq
);