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"
25 #include "cx18-fileops.h"
26 #include "cx18-mailbox.h"
28 #include "cx18-queue.h"
29 #include "cx18-ioctl.h"
30 #include "cx18-streams.h"
31 #include "cx18-cards.h"
33 #include "cx18-av-core.h"
36 #define CX18_DSP0_INTERRUPT_MASK 0xd0004C
38 static struct file_operations cx18_v4l2_enc_fops
= {
40 .read
= cx18_v4l2_read
,
41 .open
= cx18_v4l2_open
,
42 .ioctl
= cx18_v4l2_ioctl
,
43 .release
= cx18_v4l2_close
,
44 .poll
= cx18_v4l2_enc_poll
,
47 /* offset from 0 to register ts v4l2 minors on */
48 #define CX18_V4L2_ENC_TS_OFFSET 16
49 /* offset from 0 to register pcm v4l2 minors on */
50 #define CX18_V4L2_ENC_PCM_OFFSET 24
51 /* offset from 0 to register yuv v4l2 minors on */
52 #define CX18_V4L2_ENC_YUV_OFFSET 32
59 enum v4l2_buf_type buf_type
;
60 struct file_operations
*fops
;
61 } cx18_stream_info
[] = {
62 { /* CX18_ENC_STREAM_TYPE_MPG */
65 PCI_DMA_FROMDEVICE
, V4L2_BUF_TYPE_VIDEO_CAPTURE
,
68 { /* CX18_ENC_STREAM_TYPE_TS */
71 PCI_DMA_FROMDEVICE
, V4L2_BUF_TYPE_VIDEO_CAPTURE
,
74 { /* CX18_ENC_STREAM_TYPE_YUV */
76 VFL_TYPE_GRABBER
, CX18_V4L2_ENC_YUV_OFFSET
,
77 PCI_DMA_FROMDEVICE
, V4L2_BUF_TYPE_VIDEO_CAPTURE
,
80 { /* CX18_ENC_STREAM_TYPE_VBI */
83 PCI_DMA_FROMDEVICE
, V4L2_BUF_TYPE_VBI_CAPTURE
,
86 { /* CX18_ENC_STREAM_TYPE_PCM */
88 VFL_TYPE_GRABBER
, CX18_V4L2_ENC_PCM_OFFSET
,
89 PCI_DMA_FROMDEVICE
, V4L2_BUF_TYPE_PRIVATE
,
92 { /* CX18_ENC_STREAM_TYPE_IDX */
95 PCI_DMA_FROMDEVICE
, V4L2_BUF_TYPE_VIDEO_CAPTURE
,
98 { /* CX18_ENC_STREAM_TYPE_RAD */
101 PCI_DMA_NONE
, V4L2_BUF_TYPE_PRIVATE
,
106 static void cx18_stream_init(struct cx18
*cx
, int type
)
108 struct cx18_stream
*s
= &cx
->streams
[type
];
109 struct video_device
*dev
= s
->v4l2dev
;
110 u32 max_size
= cx
->options
.megabytes
[type
] * 1024 * 1024;
112 /* we need to keep v4l2dev, so restore it afterwards */
113 memset(s
, 0, sizeof(*s
));
116 /* initialize cx18_stream fields */
119 s
->name
= cx18_stream_info
[type
].name
;
120 s
->handle
= 0xffffffff;
122 s
->dma
= cx18_stream_info
[type
].dma
;
123 s
->buf_size
= cx
->stream_buf_size
[type
];
125 s
->buffers
= max_size
/ s
->buf_size
;
126 if (s
->buffers
> 63) {
127 /* Each stream has a maximum of 63 buffers,
128 ensure we do not exceed that. */
130 s
->buf_size
= (max_size
/ s
->buffers
) & ~0xfff;
132 spin_lock_init(&s
->qlock
);
133 init_waitqueue_head(&s
->waitq
);
135 cx18_queue_init(&s
->q_free
);
136 cx18_queue_init(&s
->q_full
);
137 cx18_queue_init(&s
->q_io
);
140 static int cx18_prep_dev(struct cx18
*cx
, int type
)
142 struct cx18_stream
*s
= &cx
->streams
[type
];
143 u32 cap
= cx
->v4l2_cap
;
144 int minor_offset
= cx18_stream_info
[type
].minor_offset
;
147 /* These four fields are always initialized. If v4l2dev == NULL, then
148 this stream is not in use. In that case no other fields but these
153 s
->name
= cx18_stream_info
[type
].name
;
155 /* Check whether the radio is supported */
156 if (type
== CX18_ENC_STREAM_TYPE_RAD
&& !(cap
& V4L2_CAP_RADIO
))
159 /* Check whether VBI is supported */
160 if (type
== CX18_ENC_STREAM_TYPE_VBI
&&
161 !(cap
& (V4L2_CAP_VBI_CAPTURE
| V4L2_CAP_SLICED_VBI_CAPTURE
)))
164 /* card number + user defined offset + device offset */
165 minor
= cx
->num
+ cx18_first_minor
+ minor_offset
;
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 (minor_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",
189 VID_TYPE_CAPTURE
| VID_TYPE_TUNER
| VID_TYPE_TELETEXT
|
190 VID_TYPE_CLIPPING
| VID_TYPE_SCALES
| VID_TYPE_MPEG_ENCODER
;
191 snprintf(s
->v4l2dev
->name
, sizeof(s
->v4l2dev
->name
), "cx18%d %s",
194 s
->v4l2dev
->minor
= minor
;
195 s
->v4l2dev
->dev
= &cx
->dev
->dev
;
196 s
->v4l2dev
->fops
= cx18_stream_info
[type
].fops
;
197 s
->v4l2dev
->release
= video_device_release
;
202 /* Initialize v4l2 variables and register v4l2 devices */
203 int cx18_streams_setup(struct cx18
*cx
)
207 /* Setup V4L2 Devices */
208 for (type
= 0; type
< CX18_MAX_STREAMS
; type
++) {
210 if (cx18_prep_dev(cx
, type
))
213 /* Allocate Stream */
214 if (cx18_stream_alloc(&cx
->streams
[type
]))
217 if (type
== CX18_MAX_STREAMS
)
220 /* One or more streams could not be initialized. Clean 'em all up. */
221 cx18_streams_cleanup(cx
, 0);
225 static int cx18_reg_dev(struct cx18
*cx
, int type
)
227 struct cx18_stream
*s
= &cx
->streams
[type
];
228 int vfl_type
= cx18_stream_info
[type
].vfl_type
;
231 /* TODO: Shouldn't this be a VFL_TYPE_TRANSPORT or something?
232 * We need a VFL_TYPE_TS defined.
234 if (strcmp("TS", s
->name
) == 0) {
235 /* just return if no DVB is supported */
236 if ((cx
->card
->hw_all
& CX18_HW_DVB
) == 0)
238 if (cx18_dvb_register(s
) < 0) {
239 CX18_ERR("DVB failed to register\n");
244 if (s
->v4l2dev
== NULL
)
247 minor
= s
->v4l2dev
->minor
;
249 /* Register device. First try the desired minor, then any free one. */
250 if (video_register_device(s
->v4l2dev
, vfl_type
, minor
) &&
251 video_register_device(s
->v4l2dev
, vfl_type
, -1)) {
252 CX18_ERR("Couldn't register v4l2 device for %s minor %d\n",
254 video_device_release(s
->v4l2dev
);
258 minor
= s
->v4l2dev
->minor
;
261 case VFL_TYPE_GRABBER
:
262 CX18_INFO("Registered device video%d for %s (%d MB)\n",
263 minor
, s
->name
, cx
->options
.megabytes
[type
]);
267 CX18_INFO("Registered device radio%d for %s\n",
268 minor
- MINOR_VFL_TYPE_RADIO_MIN
, s
->name
);
272 if (cx
->options
.megabytes
[type
])
273 CX18_INFO("Registered device vbi%d for %s (%d MB)\n",
274 minor
- MINOR_VFL_TYPE_VBI_MIN
,
275 s
->name
, cx
->options
.megabytes
[type
]);
277 CX18_INFO("Registered device vbi%d for %s\n",
278 minor
- MINOR_VFL_TYPE_VBI_MIN
, s
->name
);
285 /* Register v4l2 devices */
286 int cx18_streams_register(struct cx18
*cx
)
291 /* Register V4L2 devices */
292 for (type
= 0; type
< CX18_MAX_STREAMS
; type
++)
293 err
|= cx18_reg_dev(cx
, type
);
298 /* One or more streams could not be initialized. Clean 'em all up. */
299 cx18_streams_cleanup(cx
, 1);
303 /* Unregister v4l2 devices */
304 void cx18_streams_cleanup(struct cx18
*cx
, int unregister
)
306 struct video_device
*vdev
;
309 /* Teardown all streams */
310 for (type
= 0; type
< CX18_MAX_STREAMS
; type
++) {
311 if (cx
->streams
[type
].dvb
.enabled
)
312 cx18_dvb_unregister(&cx
->streams
[type
]);
314 vdev
= cx
->streams
[type
].v4l2dev
;
316 cx
->streams
[type
].v4l2dev
= NULL
;
320 cx18_stream_free(&cx
->streams
[type
]);
322 /* Unregister or release device */
324 video_unregister_device(vdev
);
326 video_device_release(vdev
);
330 static void cx18_vbi_setup(struct cx18_stream
*s
)
332 struct cx18
*cx
= s
->cx
;
333 int raw
= cx
->vbi
.sliced_in
->service_set
== 0;
334 u32 data
[CX2341X_MBOX_MAX_DATA
];
339 cx
->vbi
.start
[0] = 10;
340 cx
->vbi
.start
[1] = 273;
341 } else { /* PAL/SECAM */
343 cx
->vbi
.start
[0] = 6;
344 cx
->vbi
.start
[1] = 318;
347 /* setup VBI registers */
348 cx18_av_cmd(cx
, VIDIOC_S_FMT
, &cx
->vbi
.in
);
350 /* determine number of lines and total number of VBI bytes.
351 A raw line takes 1443 bytes: 2 * 720 + 4 byte frame header - 1
352 The '- 1' byte is probably an unused U or V byte. Or something...
353 A sliced line takes 51 bytes: 4 byte frame header, 4 byte internal
354 header, 42 data bytes + checksum (to be confirmed) */
356 lines
= cx
->vbi
.count
* 2;
358 lines
= cx
->is_60hz
? 24 : 38;
363 cx
->vbi
.enc_size
= lines
*
364 (raw
? cx
->vbi
.raw_size
: cx
->vbi
.sliced_size
);
367 /* Lines per field */
368 data
[1] = (lines
/ 2) | ((lines
/ 2) << 16);
370 data
[2] = (raw
? cx
->vbi
.raw_size
: cx
->vbi
.sliced_size
);
371 /* Every X number of frames a VBI interrupt arrives
372 (frames as in 25 or 30 fps) */
374 /* Setup VBI for the cx25840 digitizer */
376 data
[4] = 0x20602060;
377 data
[5] = 0x30703070;
379 data
[4] = 0xB0F0B0F0;
380 data
[5] = 0xA0E0A0E0;
383 CX18_DEBUG_INFO("Setup VBI h: %d lines %x bpl %d fr %d %x %x\n",
384 data
[0], data
[1], data
[2], data
[3], data
[4], data
[5]);
386 if (s
->type
== CX18_ENC_STREAM_TYPE_VBI
)
387 cx18_api(cx
, CX18_CPU_SET_RAW_VBI_PARAM
, 6, data
);
390 int cx18_start_v4l2_encode_stream(struct cx18_stream
*s
)
392 u32 data
[MAX_MB_ARGUMENTS
];
393 struct cx18
*cx
= s
->cx
;
398 if (s
->v4l2dev
== NULL
&& s
->dvb
.enabled
== 0)
401 CX18_DEBUG_INFO("Start encoder stream %s\n", s
->name
);
404 case CX18_ENC_STREAM_TYPE_MPG
:
405 captype
= CAPTURE_CHANNEL_TYPE_MPEG
;
406 cx
->mpg_data_received
= cx
->vbi_data_inserted
= 0;
407 cx
->dualwatch_jiffies
= jiffies
;
408 cx
->dualwatch_stereo_mode
= cx
->params
.audio_properties
& 0x300;
409 cx
->search_pack_header
= 0;
412 case CX18_ENC_STREAM_TYPE_TS
:
413 captype
= CAPTURE_CHANNEL_TYPE_TS
;
416 case CX18_ENC_STREAM_TYPE_YUV
:
417 captype
= CAPTURE_CHANNEL_TYPE_YUV
;
419 case CX18_ENC_STREAM_TYPE_PCM
:
420 captype
= CAPTURE_CHANNEL_TYPE_PCM
;
422 case CX18_ENC_STREAM_TYPE_VBI
:
423 captype
= cx
->vbi
.sliced_in
->service_set
?
424 CAPTURE_CHANNEL_TYPE_SLICED_VBI
: CAPTURE_CHANNEL_TYPE_VBI
;
426 cx
->vbi
.inserted_frame
= 0;
427 memset(cx
->vbi
.sliced_mpeg_size
,
428 0, sizeof(cx
->vbi
.sliced_mpeg_size
));
433 s
->buffers_stolen
= 0;
435 /* mute/unmute video */
436 cx18_vapi(cx
, CX18_CPU_SET_VIDEO_MUTE
, 2,
437 s
->handle
, !!test_bit(CX18_F_I_RADIO_USER
, &cx
->i_flags
));
439 /* Clear Streamoff flags in case left from last capture */
440 clear_bit(CX18_F_S_STREAMOFF
, &s
->s_flags
);
442 cx18_vapi_result(cx
, data
, CX18_CREATE_TASK
, 1, CPU_CMD_MASK_CAPTURE
);
444 cx18_vapi(cx
, CX18_CPU_SET_CHANNEL_TYPE
, 2, s
->handle
, captype
);
446 if (atomic_read(&cx
->capturing
) == 0 && !ts
) {
447 /* Stuff from Windows, we don't know what it is */
448 cx18_vapi(cx
, CX18_CPU_SET_VER_CROP_LINE
, 2, s
->handle
, 0);
449 cx18_vapi(cx
, CX18_CPU_SET_MISC_PARAMETERS
, 3, s
->handle
, 3, 1);
450 cx18_vapi(cx
, CX18_CPU_SET_MISC_PARAMETERS
, 3, s
->handle
, 8, 0);
451 cx18_vapi(cx
, CX18_CPU_SET_MISC_PARAMETERS
, 3, s
->handle
, 4, 1);
452 cx18_vapi(cx
, CX18_CPU_SET_MISC_PARAMETERS
, 2, s
->handle
, 12);
454 cx18_vapi(cx
, CX18_CPU_SET_CAPTURE_LINE_NO
, 3,
455 s
->handle
, cx
->digitizer
, cx
->digitizer
);
458 if (cx
->v4l2_cap
& V4L2_CAP_VBI_CAPTURE
)
461 /* assign program index info.
462 Mask 7: select I/P/B, Num_req: 400 max */
463 cx18_vapi_result(cx
, data
, CX18_CPU_SET_INDEXTABLE
, 1, 0);
465 /* Setup API for Stream */
466 cx2341x_update(cx
, cx18_api_func
, NULL
, &cx
->params
);
469 if (atomic_read(&cx
->capturing
) == 0) {
470 clear_bit(CX18_F_I_EOS
, &cx
->i_flags
);
471 write_reg(7, CX18_DSP0_INTERRUPT_MASK
);
474 cx18_vapi(cx
, CX18_CPU_DE_SET_MDL_ACK
, 3, s
->handle
,
475 (void *)&cx
->scb
->cpu_mdl_ack
[s
->type
][0] - cx
->enc_mem
,
476 (void *)&cx
->scb
->cpu_mdl_ack
[s
->type
][1] - cx
->enc_mem
);
478 list_for_each(p
, &s
->q_free
.list
) {
479 struct cx18_buffer
*buf
= list_entry(p
, struct cx18_buffer
, list
);
481 writel(buf
->dma_handle
, &cx
->scb
->cpu_mdl
[buf
->id
].paddr
);
482 writel(s
->buf_size
, &cx
->scb
->cpu_mdl
[buf
->id
].length
);
483 cx18_vapi(cx
, CX18_CPU_DE_SET_MDL
, 5, s
->handle
,
484 (void *)&cx
->scb
->cpu_mdl
[buf
->id
] - cx
->enc_mem
, 1,
485 buf
->id
, s
->buf_size
);
488 if (cx18_vapi(cx
, CX18_CPU_CAPTURE_START
, 1, s
->handle
)) {
489 CX18_DEBUG_WARN("Error starting capture!\n");
490 cx18_vapi(cx
, CX18_DESTROY_TASK
, 1, s
->handle
);
494 /* you're live! sit back and await interrupts :) */
495 atomic_inc(&cx
->capturing
);
499 void cx18_stop_all_captures(struct cx18
*cx
)
503 for (i
= CX18_MAX_STREAMS
- 1; i
>= 0; i
--) {
504 struct cx18_stream
*s
= &cx
->streams
[i
];
506 if (s
->v4l2dev
== NULL
&& s
->dvb
.enabled
== 0)
508 if (test_bit(CX18_F_S_STREAMING
, &s
->s_flags
))
509 cx18_stop_v4l2_encode_stream(s
, 0);
513 int cx18_stop_v4l2_encode_stream(struct cx18_stream
*s
, int gop_end
)
515 struct cx18
*cx
= s
->cx
;
518 if (s
->v4l2dev
== NULL
&& s
->dvb
.enabled
== 0)
521 /* This function assumes that you are allowed to stop the capture
522 and that we are actually capturing */
524 CX18_DEBUG_INFO("Stop Capture\n");
526 if (atomic_read(&cx
->capturing
) == 0)
529 if (s
->type
== CX18_ENC_STREAM_TYPE_MPG
)
530 cx18_vapi(cx
, CX18_CPU_CAPTURE_STOP
, 2, s
->handle
, !gop_end
);
532 cx18_vapi(cx
, CX18_CPU_CAPTURE_STOP
, 1, s
->handle
);
536 if (s
->type
== CX18_ENC_STREAM_TYPE_MPG
&& gop_end
) {
537 CX18_INFO("ignoring gop_end: not (yet?) supported by the firmware\n");
540 atomic_dec(&cx
->capturing
);
542 /* Clear capture and no-read bits */
543 clear_bit(CX18_F_S_STREAMING
, &s
->s_flags
);
545 cx18_vapi(cx
, CX18_DESTROY_TASK
, 1, s
->handle
);
546 s
->handle
= 0xffffffff;
548 if (atomic_read(&cx
->capturing
) > 0)
551 write_reg(5, CX18_DSP0_INTERRUPT_MASK
);
557 u32
cx18_find_handle(struct cx18
*cx
)
561 /* find first available handle to be used for global settings */
562 for (i
= 0; i
< CX18_MAX_STREAMS
; i
++) {
563 struct cx18_stream
*s
= &cx
->streams
[i
];
565 if (s
->v4l2dev
&& s
->handle
)