2 * cx18 init/start/stop/exit stream functions
4 * Derived from ivtv-streams.c
6 * Copyright (C) 2007 Hans Verkuil <hverkuil@xs4all.nl>
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
24 #include "cx18-driver.h"
26 #include "cx18-fileops.h"
27 #include "cx18-mailbox.h"
29 #include "cx18-queue.h"
30 #include "cx18-ioctl.h"
31 #include "cx18-streams.h"
32 #include "cx18-cards.h"
34 #include "cx18-av-core.h"
37 #define CX18_DSP0_INTERRUPT_MASK 0xd0004C
39 static struct file_operations cx18_v4l2_enc_fops
= {
41 .read
= cx18_v4l2_read
,
42 .open
= cx18_v4l2_open
,
43 /* FIXME change to video_ioctl2 if serialization lock can be removed */
44 .ioctl
= cx18_v4l2_ioctl
,
45 .compat_ioctl
= v4l_compat_ioctl32
,
46 .release
= cx18_v4l2_close
,
47 .poll
= cx18_v4l2_enc_poll
,
50 /* offset from 0 to register ts v4l2 minors on */
51 #define CX18_V4L2_ENC_TS_OFFSET 16
52 /* offset from 0 to register pcm v4l2 minors on */
53 #define CX18_V4L2_ENC_PCM_OFFSET 24
54 /* offset from 0 to register yuv v4l2 minors on */
55 #define CX18_V4L2_ENC_YUV_OFFSET 32
62 enum v4l2_buf_type buf_type
;
63 struct file_operations
*fops
;
64 } cx18_stream_info
[] = {
65 { /* CX18_ENC_STREAM_TYPE_MPG */
68 PCI_DMA_FROMDEVICE
, V4L2_BUF_TYPE_VIDEO_CAPTURE
,
71 { /* CX18_ENC_STREAM_TYPE_TS */
74 PCI_DMA_FROMDEVICE
, V4L2_BUF_TYPE_VIDEO_CAPTURE
,
77 { /* CX18_ENC_STREAM_TYPE_YUV */
79 VFL_TYPE_GRABBER
, CX18_V4L2_ENC_YUV_OFFSET
,
80 PCI_DMA_FROMDEVICE
, V4L2_BUF_TYPE_VIDEO_CAPTURE
,
83 { /* CX18_ENC_STREAM_TYPE_VBI */
86 PCI_DMA_FROMDEVICE
, V4L2_BUF_TYPE_VBI_CAPTURE
,
89 { /* CX18_ENC_STREAM_TYPE_PCM */
91 VFL_TYPE_GRABBER
, CX18_V4L2_ENC_PCM_OFFSET
,
92 PCI_DMA_FROMDEVICE
, V4L2_BUF_TYPE_PRIVATE
,
95 { /* CX18_ENC_STREAM_TYPE_IDX */
98 PCI_DMA_FROMDEVICE
, V4L2_BUF_TYPE_VIDEO_CAPTURE
,
101 { /* CX18_ENC_STREAM_TYPE_RAD */
104 PCI_DMA_NONE
, V4L2_BUF_TYPE_PRIVATE
,
109 static void cx18_stream_init(struct cx18
*cx
, int type
)
111 struct cx18_stream
*s
= &cx
->streams
[type
];
112 struct video_device
*dev
= s
->v4l2dev
;
113 u32 max_size
= cx
->options
.megabytes
[type
] * 1024 * 1024;
115 /* we need to keep v4l2dev, so restore it afterwards */
116 memset(s
, 0, sizeof(*s
));
119 /* initialize cx18_stream fields */
122 s
->name
= cx18_stream_info
[type
].name
;
123 s
->handle
= CX18_INVALID_TASK_HANDLE
;
125 s
->dma
= cx18_stream_info
[type
].dma
;
126 s
->buf_size
= cx
->stream_buf_size
[type
];
128 s
->buffers
= max_size
/ s
->buf_size
;
129 if (s
->buffers
> 63) {
130 /* Each stream has a maximum of 63 buffers,
131 ensure we do not exceed that. */
133 s
->buf_size
= (max_size
/ s
->buffers
) & ~0xfff;
135 spin_lock_init(&s
->qlock
);
136 init_waitqueue_head(&s
->waitq
);
138 cx18_queue_init(&s
->q_free
);
139 cx18_queue_init(&s
->q_full
);
140 cx18_queue_init(&s
->q_io
);
143 static int cx18_prep_dev(struct cx18
*cx
, int type
)
145 struct cx18_stream
*s
= &cx
->streams
[type
];
146 u32 cap
= cx
->v4l2_cap
;
147 int num_offset
= cx18_stream_info
[type
].num_offset
;
148 int num
= cx
->num
+ cx18_first_minor
+ num_offset
;
150 /* These four fields are always initialized. If v4l2dev == NULL, then
151 this stream is not in use. In that case no other fields but these
156 s
->name
= cx18_stream_info
[type
].name
;
158 /* Check whether the radio is supported */
159 if (type
== CX18_ENC_STREAM_TYPE_RAD
&& !(cap
& V4L2_CAP_RADIO
))
162 /* Check whether VBI is supported */
163 if (type
== CX18_ENC_STREAM_TYPE_VBI
&&
164 !(cap
& (V4L2_CAP_VBI_CAPTURE
| V4L2_CAP_SLICED_VBI_CAPTURE
)))
167 /* User explicitly selected 0 buffers for these streams, so don't
169 if (cx18_stream_info
[type
].dma
!= PCI_DMA_NONE
&&
170 cx
->options
.megabytes
[type
] == 0) {
171 CX18_INFO("Disabled %s device\n", cx18_stream_info
[type
].name
);
175 cx18_stream_init(cx
, type
);
177 if (num_offset
== -1)
180 /* allocate and initialize the v4l2 video device structure */
181 s
->v4l2dev
= video_device_alloc();
182 if (s
->v4l2dev
== NULL
) {
183 CX18_ERR("Couldn't allocate v4l2 video_device for %s\n",
188 snprintf(s
->v4l2dev
->name
, sizeof(s
->v4l2dev
->name
), "cx18-%d",
191 s
->v4l2dev
->num
= num
;
192 s
->v4l2dev
->parent
= &cx
->dev
->dev
;
193 s
->v4l2dev
->fops
= cx18_stream_info
[type
].fops
;
194 s
->v4l2dev
->release
= video_device_release
;
195 s
->v4l2dev
->tvnorms
= V4L2_STD_ALL
;
196 cx18_set_funcs(s
->v4l2dev
);
200 /* Initialize v4l2 variables and register v4l2 devices */
201 int cx18_streams_setup(struct cx18
*cx
)
205 /* Setup V4L2 Devices */
206 for (type
= 0; type
< CX18_MAX_STREAMS
; type
++) {
208 if (cx18_prep_dev(cx
, type
))
211 /* Allocate Stream */
212 if (cx18_stream_alloc(&cx
->streams
[type
]))
215 if (type
== CX18_MAX_STREAMS
)
218 /* One or more streams could not be initialized. Clean 'em all up. */
219 cx18_streams_cleanup(cx
, 0);
223 static int cx18_reg_dev(struct cx18
*cx
, int type
)
225 struct cx18_stream
*s
= &cx
->streams
[type
];
226 int vfl_type
= cx18_stream_info
[type
].vfl_type
;
229 /* TODO: Shouldn't this be a VFL_TYPE_TRANSPORT or something?
230 * We need a VFL_TYPE_TS defined.
232 if (strcmp("TS", s
->name
) == 0) {
233 /* just return if no DVB is supported */
234 if ((cx
->card
->hw_all
& CX18_HW_DVB
) == 0)
236 if (cx18_dvb_register(s
) < 0) {
237 CX18_ERR("DVB failed to register\n");
242 if (s
->v4l2dev
== NULL
)
245 num
= s
->v4l2dev
->num
;
246 /* card number + user defined offset + device offset */
247 if (type
!= CX18_ENC_STREAM_TYPE_MPG
) {
248 struct cx18_stream
*s_mpg
= &cx
->streams
[CX18_ENC_STREAM_TYPE_MPG
];
251 num
= s_mpg
->v4l2dev
->num
+ cx18_stream_info
[type
].num_offset
;
254 /* Register device. First try the desired minor, then any free one. */
255 if (video_register_device(s
->v4l2dev
, vfl_type
, num
)) {
256 CX18_ERR("Couldn't register v4l2 device for %s kernel number %d\n",
258 video_device_release(s
->v4l2dev
);
262 num
= s
->v4l2dev
->num
;
265 case VFL_TYPE_GRABBER
:
266 CX18_INFO("Registered device video%d for %s (%d MB)\n",
267 num
, s
->name
, cx
->options
.megabytes
[type
]);
271 CX18_INFO("Registered device radio%d for %s\n",
276 if (cx
->options
.megabytes
[type
])
277 CX18_INFO("Registered device vbi%d for %s (%d MB)\n",
279 s
->name
, cx
->options
.megabytes
[type
]);
281 CX18_INFO("Registered device vbi%d for %s\n",
289 /* Register v4l2 devices */
290 int cx18_streams_register(struct cx18
*cx
)
295 /* Register V4L2 devices */
296 for (type
= 0; type
< CX18_MAX_STREAMS
; type
++)
297 err
|= cx18_reg_dev(cx
, type
);
302 /* One or more streams could not be initialized. Clean 'em all up. */
303 cx18_streams_cleanup(cx
, 1);
307 /* Unregister v4l2 devices */
308 void cx18_streams_cleanup(struct cx18
*cx
, int unregister
)
310 struct video_device
*vdev
;
313 /* Teardown all streams */
314 for (type
= 0; type
< CX18_MAX_STREAMS
; type
++) {
315 if (cx
->streams
[type
].dvb
.enabled
) {
316 cx18_dvb_unregister(&cx
->streams
[type
]);
317 cx
->streams
[type
].dvb
.enabled
= false;
320 vdev
= cx
->streams
[type
].v4l2dev
;
322 cx
->streams
[type
].v4l2dev
= NULL
;
326 cx18_stream_free(&cx
->streams
[type
]);
328 /* Unregister or release device */
330 video_unregister_device(vdev
);
332 video_device_release(vdev
);
336 static void cx18_vbi_setup(struct cx18_stream
*s
)
338 struct cx18
*cx
= s
->cx
;
339 int raw
= cx
->vbi
.sliced_in
->service_set
== 0;
340 u32 data
[CX2341X_MBOX_MAX_DATA
];
345 cx
->vbi
.start
[0] = 10;
346 cx
->vbi
.start
[1] = 273;
347 } else { /* PAL/SECAM */
349 cx
->vbi
.start
[0] = 6;
350 cx
->vbi
.start
[1] = 318;
353 /* setup VBI registers */
354 cx18_av_cmd(cx
, VIDIOC_S_FMT
, &cx
->vbi
.in
);
356 /* determine number of lines and total number of VBI bytes.
357 A raw line takes 1443 bytes: 2 * 720 + 4 byte frame header - 1
358 The '- 1' byte is probably an unused U or V byte. Or something...
359 A sliced line takes 51 bytes: 4 byte frame header, 4 byte internal
360 header, 42 data bytes + checksum (to be confirmed) */
362 lines
= cx
->vbi
.count
* 2;
364 lines
= cx
->is_60hz
? 24 : 38;
369 cx
->vbi
.enc_size
= lines
*
370 (raw
? cx
->vbi
.raw_size
: cx
->vbi
.sliced_size
);
373 /* Lines per field */
374 data
[1] = (lines
/ 2) | ((lines
/ 2) << 16);
376 data
[2] = (raw
? cx
->vbi
.raw_size
: cx
->vbi
.sliced_size
);
377 /* Every X number of frames a VBI interrupt arrives
378 (frames as in 25 or 30 fps) */
380 /* Setup VBI for the cx25840 digitizer */
382 data
[4] = 0x20602060;
383 data
[5] = 0x30703070;
385 data
[4] = 0xB0F0B0F0;
386 data
[5] = 0xA0E0A0E0;
389 CX18_DEBUG_INFO("Setup VBI h: %d lines %x bpl %d fr %d %x %x\n",
390 data
[0], data
[1], data
[2], data
[3], data
[4], data
[5]);
392 if (s
->type
== CX18_ENC_STREAM_TYPE_VBI
)
393 cx18_api(cx
, CX18_CPU_SET_RAW_VBI_PARAM
, 6, data
);
396 int cx18_start_v4l2_encode_stream(struct cx18_stream
*s
)
398 u32 data
[MAX_MB_ARGUMENTS
];
399 struct cx18
*cx
= s
->cx
;
404 if (s
->v4l2dev
== NULL
&& s
->dvb
.enabled
== 0)
407 CX18_DEBUG_INFO("Start encoder stream %s\n", s
->name
);
410 case CX18_ENC_STREAM_TYPE_MPG
:
411 captype
= CAPTURE_CHANNEL_TYPE_MPEG
;
412 cx
->mpg_data_received
= cx
->vbi_data_inserted
= 0;
413 cx
->dualwatch_jiffies
= jiffies
;
414 cx
->dualwatch_stereo_mode
= cx
->params
.audio_properties
& 0x300;
415 cx
->search_pack_header
= 0;
418 case CX18_ENC_STREAM_TYPE_TS
:
419 captype
= CAPTURE_CHANNEL_TYPE_TS
;
422 case CX18_ENC_STREAM_TYPE_YUV
:
423 captype
= CAPTURE_CHANNEL_TYPE_YUV
;
425 case CX18_ENC_STREAM_TYPE_PCM
:
426 captype
= CAPTURE_CHANNEL_TYPE_PCM
;
428 case CX18_ENC_STREAM_TYPE_VBI
:
429 captype
= cx
->vbi
.sliced_in
->service_set
?
430 CAPTURE_CHANNEL_TYPE_SLICED_VBI
: CAPTURE_CHANNEL_TYPE_VBI
;
432 cx
->vbi
.inserted_frame
= 0;
433 memset(cx
->vbi
.sliced_mpeg_size
,
434 0, sizeof(cx
->vbi
.sliced_mpeg_size
));
440 /* mute/unmute video */
441 cx18_vapi(cx
, CX18_CPU_SET_VIDEO_MUTE
, 2,
442 s
->handle
, !!test_bit(CX18_F_I_RADIO_USER
, &cx
->i_flags
));
444 /* Clear Streamoff flags in case left from last capture */
445 clear_bit(CX18_F_S_STREAMOFF
, &s
->s_flags
);
447 cx18_vapi_result(cx
, data
, CX18_CREATE_TASK
, 1, CPU_CMD_MASK_CAPTURE
);
449 cx18_vapi(cx
, CX18_CPU_SET_CHANNEL_TYPE
, 2, s
->handle
, captype
);
451 if (atomic_read(&cx
->ana_capturing
) == 0 && !ts
) {
452 /* Stuff from Windows, we don't know what it is */
453 cx18_vapi(cx
, CX18_CPU_SET_VER_CROP_LINE
, 2, s
->handle
, 0);
454 cx18_vapi(cx
, CX18_CPU_SET_MISC_PARAMETERS
, 3, s
->handle
, 3, 1);
455 cx18_vapi(cx
, CX18_CPU_SET_MISC_PARAMETERS
, 3, s
->handle
, 8, 0);
456 cx18_vapi(cx
, CX18_CPU_SET_MISC_PARAMETERS
, 3, s
->handle
, 4, 1);
457 cx18_vapi(cx
, CX18_CPU_SET_MISC_PARAMETERS
, 2, s
->handle
, 12);
459 cx18_vapi(cx
, CX18_CPU_SET_CAPTURE_LINE_NO
, 3,
460 s
->handle
, cx
->digitizer
, cx
->digitizer
);
463 if (cx
->v4l2_cap
& V4L2_CAP_VBI_CAPTURE
)
466 /* assign program index info.
467 Mask 7: select I/P/B, Num_req: 400 max */
468 cx18_vapi_result(cx
, data
, CX18_CPU_SET_INDEXTABLE
, 1, 0);
470 /* Setup API for Stream */
471 cx2341x_update(cx
, cx18_api_func
, NULL
, &cx
->params
);
474 if (atomic_read(&cx
->tot_capturing
) == 0) {
475 clear_bit(CX18_F_I_EOS
, &cx
->i_flags
);
476 cx18_write_reg(cx
, 7, CX18_DSP0_INTERRUPT_MASK
);
479 cx18_vapi(cx
, CX18_CPU_DE_SET_MDL_ACK
, 3, s
->handle
,
480 (void __iomem
*)&cx
->scb
->cpu_mdl_ack
[s
->type
][0] - cx
->enc_mem
,
481 (void __iomem
*)&cx
->scb
->cpu_mdl_ack
[s
->type
][1] - cx
->enc_mem
);
483 list_for_each(p
, &s
->q_free
.list
) {
484 struct cx18_buffer
*buf
= list_entry(p
, struct cx18_buffer
, list
);
486 cx18_writel(cx
, buf
->dma_handle
,
487 &cx
->scb
->cpu_mdl
[buf
->id
].paddr
);
488 cx18_writel(cx
, s
->buf_size
, &cx
->scb
->cpu_mdl
[buf
->id
].length
);
489 cx18_vapi(cx
, CX18_CPU_DE_SET_MDL
, 5, s
->handle
,
490 (void __iomem
*)&cx
->scb
->cpu_mdl
[buf
->id
] - cx
->enc_mem
,
491 1, buf
->id
, s
->buf_size
);
494 if (cx18_vapi(cx
, CX18_CPU_CAPTURE_START
, 1, s
->handle
)) {
495 CX18_DEBUG_WARN("Error starting capture!\n");
496 /* Ensure we're really not capturing before releasing MDLs */
497 if (s
->type
== CX18_ENC_STREAM_TYPE_MPG
)
498 cx18_vapi(cx
, CX18_CPU_CAPTURE_STOP
, 2, s
->handle
, 1);
500 cx18_vapi(cx
, CX18_CPU_CAPTURE_STOP
, 1, s
->handle
);
501 cx18_vapi(cx
, CX18_CPU_DE_RELEASE_MDL
, 1, s
->handle
);
502 cx18_vapi(cx
, CX18_DESTROY_TASK
, 1, s
->handle
);
503 /* FIXME - clean-up DSP0_INT mask, i_flags, s_flags, etc. */
507 /* you're live! sit back and await interrupts :) */
509 atomic_inc(&cx
->ana_capturing
);
510 atomic_inc(&cx
->tot_capturing
);
514 void cx18_stop_all_captures(struct cx18
*cx
)
518 for (i
= CX18_MAX_STREAMS
- 1; i
>= 0; i
--) {
519 struct cx18_stream
*s
= &cx
->streams
[i
];
521 if (s
->v4l2dev
== NULL
&& s
->dvb
.enabled
== 0)
523 if (test_bit(CX18_F_S_STREAMING
, &s
->s_flags
))
524 cx18_stop_v4l2_encode_stream(s
, 0);
528 int cx18_stop_v4l2_encode_stream(struct cx18_stream
*s
, int gop_end
)
530 struct cx18
*cx
= s
->cx
;
533 if (s
->v4l2dev
== NULL
&& s
->dvb
.enabled
== 0)
536 /* This function assumes that you are allowed to stop the capture
537 and that we are actually capturing */
539 CX18_DEBUG_INFO("Stop Capture\n");
541 if (atomic_read(&cx
->tot_capturing
) == 0)
544 if (s
->type
== CX18_ENC_STREAM_TYPE_MPG
)
545 cx18_vapi(cx
, CX18_CPU_CAPTURE_STOP
, 2, s
->handle
, !gop_end
);
547 cx18_vapi(cx
, CX18_CPU_CAPTURE_STOP
, 1, s
->handle
);
551 if (s
->type
== CX18_ENC_STREAM_TYPE_MPG
&& gop_end
) {
552 CX18_INFO("ignoring gop_end: not (yet?) supported by the firmware\n");
555 /* Tell the CX23418 it can't use our buffers anymore */
556 cx18_vapi(cx
, CX18_CPU_DE_RELEASE_MDL
, 1, s
->handle
);
558 if (s
->type
!= CX18_ENC_STREAM_TYPE_TS
)
559 atomic_dec(&cx
->ana_capturing
);
560 atomic_dec(&cx
->tot_capturing
);
562 /* Clear capture and no-read bits */
563 clear_bit(CX18_F_S_STREAMING
, &s
->s_flags
);
565 cx18_vapi(cx
, CX18_DESTROY_TASK
, 1, s
->handle
);
566 s
->handle
= CX18_INVALID_TASK_HANDLE
;
568 if (atomic_read(&cx
->tot_capturing
) > 0)
571 cx18_write_reg(cx
, 5, CX18_DSP0_INTERRUPT_MASK
);
577 u32
cx18_find_handle(struct cx18
*cx
)
581 /* find first available handle to be used for global settings */
582 for (i
= 0; i
< CX18_MAX_STREAMS
; i
++) {
583 struct cx18_stream
*s
= &cx
->streams
[i
];
585 if (s
->v4l2dev
&& (s
->handle
!= CX18_INVALID_TASK_HANDLE
))
588 return CX18_INVALID_TASK_HANDLE
;