ivtv-streams.c revision d526afe06b285006c63ed8f2eba9589f04e3283a
1/* 2 init/start/stop/exit stream functions 3 Copyright (C) 2003-2004 Kevin Thayer <nufan_wfk at yahoo.com> 4 Copyright (C) 2004 Chris Kennedy <c@groovy.org> 5 Copyright (C) 2005-2007 Hans Verkuil <hverkuil@xs4all.nl> 6 7 This program is free software; you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation; either version 2 of the License, or 10 (at your option) any later version. 11 12 This program is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 GNU General Public License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with this program; if not, write to the Free Software 19 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 20 */ 21 22/* License: GPL 23 * Author: Kevin Thayer <nufan_wfk at yahoo dot com> 24 * 25 * This file will hold API related functions, both internal (firmware api) 26 * and external (v4l2, etc) 27 * 28 * ----- 29 * MPG600/MPG160 support by T.Adachi <tadachi@tadachi-net.com> 30 * and Takeru KOMORIYA<komoriya@paken.org> 31 * 32 * AVerMedia M179 GPIO info by Chris Pinkham <cpinkham@bc2va.org> 33 * using information provided by Jiun-Kuei Jung @ AVerMedia. 34 */ 35 36#include "ivtv-driver.h" 37#include "ivtv-fileops.h" 38#include "ivtv-queue.h" 39#include "ivtv-mailbox.h" 40#include "ivtv-ioctl.h" 41#include "ivtv-irq.h" 42#include "ivtv-yuv.h" 43#include "ivtv-cards.h" 44#include "ivtv-streams.h" 45 46static const struct file_operations ivtv_v4l2_enc_fops = { 47 .owner = THIS_MODULE, 48 .read = ivtv_v4l2_read, 49 .write = ivtv_v4l2_write, 50 .open = ivtv_v4l2_open, 51 .ioctl = ivtv_v4l2_ioctl, 52 .compat_ioctl = v4l_compat_ioctl32, 53 .release = ivtv_v4l2_close, 54 .poll = ivtv_v4l2_enc_poll, 55}; 56 57static const struct file_operations ivtv_v4l2_dec_fops = { 58 .owner = THIS_MODULE, 59 .read = ivtv_v4l2_read, 60 .write = ivtv_v4l2_write, 61 .open = ivtv_v4l2_open, 62 .ioctl = ivtv_v4l2_ioctl, 63 .compat_ioctl = v4l_compat_ioctl32, 64 .release = ivtv_v4l2_close, 65 .poll = ivtv_v4l2_dec_poll, 66}; 67 68#define IVTV_V4L2_DEC_MPG_OFFSET 16 /* offset from 0 to register decoder mpg v4l2 minors on */ 69#define IVTV_V4L2_ENC_PCM_OFFSET 24 /* offset from 0 to register pcm v4l2 minors on */ 70#define IVTV_V4L2_ENC_YUV_OFFSET 32 /* offset from 0 to register yuv v4l2 minors on */ 71#define IVTV_V4L2_DEC_YUV_OFFSET 48 /* offset from 0 to register decoder yuv v4l2 minors on */ 72#define IVTV_V4L2_DEC_VBI_OFFSET 8 /* offset from 0 to register decoder vbi input v4l2 minors on */ 73#define IVTV_V4L2_DEC_VOUT_OFFSET 16 /* offset from 0 to register vbi output v4l2 minors on */ 74 75static struct { 76 const char *name; 77 int vfl_type; 78 int minor_offset; 79 int dma, pio; 80 enum v4l2_buf_type buf_type; 81 const struct file_operations *fops; 82} ivtv_stream_info[] = { 83 { /* IVTV_ENC_STREAM_TYPE_MPG */ 84 "encoder MPG", 85 VFL_TYPE_GRABBER, 0, 86 PCI_DMA_FROMDEVICE, 0, V4L2_BUF_TYPE_VIDEO_CAPTURE, 87 &ivtv_v4l2_enc_fops 88 }, 89 { /* IVTV_ENC_STREAM_TYPE_YUV */ 90 "encoder YUV", 91 VFL_TYPE_GRABBER, IVTV_V4L2_ENC_YUV_OFFSET, 92 PCI_DMA_FROMDEVICE, 0, V4L2_BUF_TYPE_VIDEO_CAPTURE, 93 &ivtv_v4l2_enc_fops 94 }, 95 { /* IVTV_ENC_STREAM_TYPE_VBI */ 96 "encoder VBI", 97 VFL_TYPE_VBI, 0, 98 PCI_DMA_FROMDEVICE, 0, V4L2_BUF_TYPE_VBI_CAPTURE, 99 &ivtv_v4l2_enc_fops 100 }, 101 { /* IVTV_ENC_STREAM_TYPE_PCM */ 102 "encoder PCM", 103 VFL_TYPE_GRABBER, IVTV_V4L2_ENC_PCM_OFFSET, 104 PCI_DMA_FROMDEVICE, 0, V4L2_BUF_TYPE_PRIVATE, 105 &ivtv_v4l2_enc_fops 106 }, 107 { /* IVTV_ENC_STREAM_TYPE_RAD */ 108 "encoder radio", 109 VFL_TYPE_RADIO, 0, 110 PCI_DMA_NONE, 1, V4L2_BUF_TYPE_PRIVATE, 111 &ivtv_v4l2_enc_fops 112 }, 113 { /* IVTV_DEC_STREAM_TYPE_MPG */ 114 "decoder MPG", 115 VFL_TYPE_GRABBER, IVTV_V4L2_DEC_MPG_OFFSET, 116 PCI_DMA_TODEVICE, 0, V4L2_BUF_TYPE_VIDEO_OUTPUT, 117 &ivtv_v4l2_dec_fops 118 }, 119 { /* IVTV_DEC_STREAM_TYPE_VBI */ 120 "decoder VBI", 121 VFL_TYPE_VBI, IVTV_V4L2_DEC_VBI_OFFSET, 122 PCI_DMA_NONE, 1, V4L2_BUF_TYPE_VBI_CAPTURE, 123 &ivtv_v4l2_enc_fops 124 }, 125 { /* IVTV_DEC_STREAM_TYPE_VOUT */ 126 "decoder VOUT", 127 VFL_TYPE_VBI, IVTV_V4L2_DEC_VOUT_OFFSET, 128 PCI_DMA_NONE, 1, V4L2_BUF_TYPE_VBI_OUTPUT, 129 &ivtv_v4l2_dec_fops 130 }, 131 { /* IVTV_DEC_STREAM_TYPE_YUV */ 132 "decoder YUV", 133 VFL_TYPE_GRABBER, IVTV_V4L2_DEC_YUV_OFFSET, 134 PCI_DMA_TODEVICE, 0, V4L2_BUF_TYPE_VIDEO_OUTPUT, 135 &ivtv_v4l2_dec_fops 136 } 137}; 138 139static void ivtv_stream_init(struct ivtv *itv, int type) 140{ 141 struct ivtv_stream *s = &itv->streams[type]; 142 struct video_device *dev = s->v4l2dev; 143 144 /* we need to keep v4l2dev, so restore it afterwards */ 145 memset(s, 0, sizeof(*s)); 146 s->v4l2dev = dev; 147 148 /* initialize ivtv_stream fields */ 149 s->itv = itv; 150 s->type = type; 151 s->name = ivtv_stream_info[type].name; 152 153 if (ivtv_stream_info[type].pio) 154 s->dma = PCI_DMA_NONE; 155 else 156 s->dma = ivtv_stream_info[type].dma; 157 s->buf_size = itv->stream_buf_size[type]; 158 if (s->buf_size) 159 s->buffers = (itv->options.kilobytes[type] * 1024 + s->buf_size - 1) / s->buf_size; 160 spin_lock_init(&s->qlock); 161 init_waitqueue_head(&s->waitq); 162 s->id = -1; 163 s->sg_handle = IVTV_DMA_UNMAPPED; 164 ivtv_queue_init(&s->q_free); 165 ivtv_queue_init(&s->q_full); 166 ivtv_queue_init(&s->q_dma); 167 ivtv_queue_init(&s->q_predma); 168 ivtv_queue_init(&s->q_io); 169} 170 171static int ivtv_prep_dev(struct ivtv *itv, int type) 172{ 173 struct ivtv_stream *s = &itv->streams[type]; 174 int minor_offset = ivtv_stream_info[type].minor_offset; 175 int minor; 176 177 /* These four fields are always initialized. If v4l2dev == NULL, then 178 this stream is not in use. In that case no other fields but these 179 four can be used. */ 180 s->v4l2dev = NULL; 181 s->itv = itv; 182 s->type = type; 183 s->name = ivtv_stream_info[type].name; 184 185 /* Check whether the radio is supported */ 186 if (type == IVTV_ENC_STREAM_TYPE_RAD && !(itv->v4l2_cap & V4L2_CAP_RADIO)) 187 return 0; 188 if (type >= IVTV_DEC_STREAM_TYPE_MPG && !(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT)) 189 return 0; 190 191 /* card number + user defined offset + device offset */ 192 minor = itv->num + ivtv_first_minor + minor_offset; 193 194 /* User explicitly selected 0 buffers for these streams, so don't 195 create them. */ 196 if (ivtv_stream_info[type].dma != PCI_DMA_NONE && 197 itv->options.kilobytes[type] == 0) { 198 IVTV_INFO("Disabled %s device\n", ivtv_stream_info[type].name); 199 return 0; 200 } 201 202 ivtv_stream_init(itv, type); 203 204 /* allocate and initialize the v4l2 video device structure */ 205 s->v4l2dev = video_device_alloc(); 206 if (s->v4l2dev == NULL) { 207 IVTV_ERR("Couldn't allocate v4l2 video_device for %s\n", s->name); 208 return -ENOMEM; 209 } 210 211 snprintf(s->v4l2dev->name, sizeof(s->v4l2dev->name), "ivtv%d %s", 212 itv->num, s->name); 213 214 s->v4l2dev->minor = minor; 215 s->v4l2dev->parent = &itv->dev->dev; 216 s->v4l2dev->fops = ivtv_stream_info[type].fops; 217 s->v4l2dev->release = video_device_release; 218 s->v4l2dev->tvnorms = V4L2_STD_ALL; 219 ivtv_set_funcs(s->v4l2dev); 220 return 0; 221} 222 223/* Initialize v4l2 variables and prepare v4l2 devices */ 224int ivtv_streams_setup(struct ivtv *itv) 225{ 226 int type; 227 228 /* Setup V4L2 Devices */ 229 for (type = 0; type < IVTV_MAX_STREAMS; type++) { 230 /* Prepare device */ 231 if (ivtv_prep_dev(itv, type)) 232 break; 233 234 if (itv->streams[type].v4l2dev == NULL) 235 continue; 236 237 /* Allocate Stream */ 238 if (ivtv_stream_alloc(&itv->streams[type])) 239 break; 240 } 241 if (type == IVTV_MAX_STREAMS) 242 return 0; 243 244 /* One or more streams could not be initialized. Clean 'em all up. */ 245 ivtv_streams_cleanup(itv, 0); 246 return -ENOMEM; 247} 248 249static int ivtv_reg_dev(struct ivtv *itv, int type) 250{ 251 struct ivtv_stream *s = &itv->streams[type]; 252 int vfl_type = ivtv_stream_info[type].vfl_type; 253 int minor; 254 255 if (s->v4l2dev == NULL) 256 return 0; 257 258 minor = s->v4l2dev->minor; 259 /* Register device. First try the desired minor, then any free one. */ 260 if (video_register_device(s->v4l2dev, vfl_type, minor) && 261 video_register_device(s->v4l2dev, vfl_type, -1)) { 262 IVTV_ERR("Couldn't register v4l2 device for %s minor %d\n", 263 s->name, minor); 264 video_device_release(s->v4l2dev); 265 s->v4l2dev = NULL; 266 return -ENOMEM; 267 } 268 269 switch (vfl_type) { 270 case VFL_TYPE_GRABBER: 271 IVTV_INFO("Registered device video%d for %s (%d kB)\n", 272 s->v4l2dev->minor, s->name, itv->options.kilobytes[type]); 273 break; 274 case VFL_TYPE_RADIO: 275 IVTV_INFO("Registered device radio%d for %s\n", 276 s->v4l2dev->minor - MINOR_VFL_TYPE_RADIO_MIN, s->name); 277 break; 278 case VFL_TYPE_VBI: 279 if (itv->options.kilobytes[type]) 280 IVTV_INFO("Registered device vbi%d for %s (%d kB)\n", 281 s->v4l2dev->minor - MINOR_VFL_TYPE_VBI_MIN, 282 s->name, itv->options.kilobytes[type]); 283 else 284 IVTV_INFO("Registered device vbi%d for %s\n", 285 s->v4l2dev->minor - MINOR_VFL_TYPE_VBI_MIN, s->name); 286 break; 287 } 288 return 0; 289} 290 291/* Register v4l2 devices */ 292int ivtv_streams_register(struct ivtv *itv) 293{ 294 int type; 295 int err = 0; 296 297 /* Register V4L2 devices */ 298 for (type = 0; type < IVTV_MAX_STREAMS; type++) 299 err |= ivtv_reg_dev(itv, type); 300 301 if (err == 0) 302 return 0; 303 304 /* One or more streams could not be initialized. Clean 'em all up. */ 305 ivtv_streams_cleanup(itv, 1); 306 return -ENOMEM; 307} 308 309/* Unregister v4l2 devices */ 310void ivtv_streams_cleanup(struct ivtv *itv, int unregister) 311{ 312 int type; 313 314 /* Teardown all streams */ 315 for (type = 0; type < IVTV_MAX_STREAMS; type++) { 316 struct video_device *vdev = itv->streams[type].v4l2dev; 317 318 itv->streams[type].v4l2dev = NULL; 319 if (vdev == NULL) 320 continue; 321 322 ivtv_stream_free(&itv->streams[type]); 323 /* Unregister or release device */ 324 if (unregister) 325 video_unregister_device(vdev); 326 else 327 video_device_release(vdev); 328 } 329} 330 331static void ivtv_vbi_setup(struct ivtv *itv) 332{ 333 int raw = itv->vbi.sliced_in->service_set == 0; 334 u32 data[CX2341X_MBOX_MAX_DATA]; 335 int lines; 336 int i; 337 338 /* Reset VBI */ 339 ivtv_vapi(itv, CX2341X_ENC_SET_VBI_LINE, 5, 0xffff , 0, 0, 0, 0); 340 341 /* setup VBI registers */ 342 itv->video_dec_func(itv, VIDIOC_S_FMT, &itv->vbi.in); 343 344 /* determine number of lines and total number of VBI bytes. 345 A raw line takes 1443 bytes: 2 * 720 + 4 byte frame header - 1 346 The '- 1' byte is probably an unused U or V byte. Or something... 347 A sliced line takes 51 bytes: 4 byte frame header, 4 byte internal 348 header, 42 data bytes + checksum (to be confirmed) */ 349 if (raw) { 350 lines = itv->vbi.count * 2; 351 } else { 352 lines = itv->is_60hz ? 24 : 38; 353 if (itv->is_60hz && (itv->hw_flags & IVTV_HW_CX25840)) 354 lines += 2; 355 } 356 357 itv->vbi.enc_size = lines * (raw ? itv->vbi.raw_size : itv->vbi.sliced_size); 358 359 /* Note: sliced vs raw flag doesn't seem to have any effect 360 TODO: check mode (0x02) value with older ivtv versions. */ 361 data[0] = raw | 0x02 | (0xbd << 8); 362 363 /* Every X number of frames a VBI interrupt arrives (frames as in 25 or 30 fps) */ 364 data[1] = 1; 365 /* The VBI frames are stored in a ringbuffer with this size (with a VBI frame as unit) */ 366 data[2] = raw ? 4 : 4 * (itv->vbi.raw_size / itv->vbi.enc_size); 367 /* The start/stop codes determine which VBI lines end up in the raw VBI data area. 368 The codes are from table 24 in the saa7115 datasheet. Each raw/sliced/video line 369 is framed with codes FF0000XX where XX is the SAV/EAV (Start/End of Active Video) 370 code. These values for raw VBI are obtained from a driver disassembly. The sliced 371 start/stop codes was deduced from this, but they do not appear in the driver. 372 Other code pairs that I found are: 0x250E6249/0x13545454 and 0x25256262/0x38137F54. 373 However, I have no idea what these values are for. */ 374 if (itv->hw_flags & IVTV_HW_CX25840) { 375 /* Setup VBI for the cx25840 digitizer */ 376 if (raw) { 377 data[3] = 0x20602060; 378 data[4] = 0x30703070; 379 } else { 380 data[3] = 0xB0F0B0F0; 381 data[4] = 0xA0E0A0E0; 382 } 383 /* Lines per frame */ 384 data[5] = lines; 385 /* bytes per line */ 386 data[6] = (raw ? itv->vbi.raw_size : itv->vbi.sliced_size); 387 } else { 388 /* Setup VBI for the saa7115 digitizer */ 389 if (raw) { 390 data[3] = 0x25256262; 391 data[4] = 0x387F7F7F; 392 } else { 393 data[3] = 0xABABECEC; 394 data[4] = 0xB6F1F1F1; 395 } 396 /* Lines per frame */ 397 data[5] = lines; 398 /* bytes per line */ 399 data[6] = itv->vbi.enc_size / lines; 400 } 401 402 IVTV_DEBUG_INFO( 403 "Setup VBI API header 0x%08x pkts %d buffs %d ln %d sz %d\n", 404 data[0], data[1], data[2], data[5], data[6]); 405 406 ivtv_api(itv, CX2341X_ENC_SET_VBI_CONFIG, 7, data); 407 408 /* returns the VBI encoder memory area. */ 409 itv->vbi.enc_start = data[2]; 410 itv->vbi.fpi = data[0]; 411 if (!itv->vbi.fpi) 412 itv->vbi.fpi = 1; 413 414 IVTV_DEBUG_INFO("Setup VBI start 0x%08x frames %d fpi %d\n", 415 itv->vbi.enc_start, data[1], itv->vbi.fpi); 416 417 /* select VBI lines. 418 Note that the sliced argument seems to have no effect. */ 419 for (i = 2; i <= 24; i++) { 420 int valid; 421 422 if (itv->is_60hz) { 423 valid = i >= 10 && i < 22; 424 } else { 425 valid = i >= 6 && i < 24; 426 } 427 ivtv_vapi(itv, CX2341X_ENC_SET_VBI_LINE, 5, i - 1, 428 valid, 0 , 0, 0); 429 ivtv_vapi(itv, CX2341X_ENC_SET_VBI_LINE, 5, (i - 1) | 0x80000000, 430 valid, 0, 0, 0); 431 } 432 433 /* Remaining VBI questions: 434 - Is it possible to select particular VBI lines only for inclusion in the MPEG 435 stream? Currently you can only get the first X lines. 436 - Is mixed raw and sliced VBI possible? 437 - What's the meaning of the raw/sliced flag? 438 - What's the meaning of params 2, 3 & 4 of the Select VBI command? */ 439} 440 441int ivtv_start_v4l2_encode_stream(struct ivtv_stream *s) 442{ 443 u32 data[CX2341X_MBOX_MAX_DATA]; 444 struct ivtv *itv = s->itv; 445 struct cx2341x_mpeg_params *p = &itv->params; 446 int captype = 0, subtype = 0; 447 int enable_passthrough = 0; 448 449 if (s->v4l2dev == NULL) 450 return -EINVAL; 451 452 IVTV_DEBUG_INFO("Start encoder stream %s\n", s->name); 453 454 switch (s->type) { 455 case IVTV_ENC_STREAM_TYPE_MPG: 456 captype = 0; 457 subtype = 3; 458 459 /* Stop Passthrough */ 460 if (itv->output_mode == OUT_PASSTHROUGH) { 461 ivtv_passthrough_mode(itv, 0); 462 enable_passthrough = 1; 463 } 464 itv->mpg_data_received = itv->vbi_data_inserted = 0; 465 itv->dualwatch_jiffies = jiffies; 466 itv->dualwatch_stereo_mode = p->audio_properties & 0x0300; 467 itv->search_pack_header = 0; 468 break; 469 470 case IVTV_ENC_STREAM_TYPE_YUV: 471 if (itv->output_mode == OUT_PASSTHROUGH) { 472 captype = 2; 473 subtype = 11; /* video+audio+decoder */ 474 break; 475 } 476 captype = 1; 477 subtype = 1; 478 break; 479 case IVTV_ENC_STREAM_TYPE_PCM: 480 captype = 1; 481 subtype = 2; 482 break; 483 case IVTV_ENC_STREAM_TYPE_VBI: 484 captype = 1; 485 subtype = 4; 486 487 itv->vbi.frame = 0; 488 itv->vbi.inserted_frame = 0; 489 memset(itv->vbi.sliced_mpeg_size, 490 0, sizeof(itv->vbi.sliced_mpeg_size)); 491 break; 492 default: 493 return -EINVAL; 494 } 495 s->subtype = subtype; 496 s->buffers_stolen = 0; 497 498 /* Clear Streamoff flags in case left from last capture */ 499 clear_bit(IVTV_F_S_STREAMOFF, &s->s_flags); 500 501 if (atomic_read(&itv->capturing) == 0) { 502 int digitizer; 503 504 /* Always use frame based mode. Experiments have demonstrated that byte 505 stream based mode results in dropped frames and corruption. Not often, 506 but occasionally. Many thanks go to Leonard Orb who spent a lot of 507 effort and time trying to trace the cause of the drop outs. */ 508 /* 1 frame per DMA */ 509 /*ivtv_vapi(itv, CX2341X_ENC_SET_DMA_BLOCK_SIZE, 2, 128, 0); */ 510 ivtv_vapi(itv, CX2341X_ENC_SET_DMA_BLOCK_SIZE, 2, 1, 1); 511 512 /* Stuff from Windows, we don't know what it is */ 513 ivtv_vapi(itv, CX2341X_ENC_SET_VERT_CROP_LINE, 1, 0); 514 /* According to the docs, this should be correct. However, this is 515 untested. I don't dare enable this without having tested it. 516 Only very few old cards actually have this hardware combination. 517 ivtv_vapi(itv, CX2341X_ENC_SET_VERT_CROP_LINE, 1, 518 ((itv->hw_flags & IVTV_HW_SAA7114) && itv->is_60hz) ? 10001 : 0); 519 */ 520 ivtv_vapi(itv, CX2341X_ENC_MISC, 2, 3, !itv->has_cx23415); 521 ivtv_vapi(itv, CX2341X_ENC_MISC, 2, 8, 0); 522 ivtv_vapi(itv, CX2341X_ENC_MISC, 2, 4, 1); 523 ivtv_vapi(itv, CX2341X_ENC_MISC, 1, 12); 524 525 /* assign placeholder */ 526 ivtv_vapi(itv, CX2341X_ENC_SET_PLACEHOLDER, 12, 527 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0); 528 529 if (itv->card->hw_all & (IVTV_HW_SAA7115 | IVTV_HW_SAA717X)) 530 digitizer = 0xF1; 531 else if (itv->card->hw_all & IVTV_HW_SAA7114) 532 digitizer = 0xEF; 533 else /* cx25840 */ 534 digitizer = 0x140; 535 536 ivtv_vapi(itv, CX2341X_ENC_SET_NUM_VSYNC_LINES, 2, digitizer, digitizer); 537 538 /* Setup VBI */ 539 if (itv->v4l2_cap & V4L2_CAP_VBI_CAPTURE) { 540 ivtv_vbi_setup(itv); 541 } 542 543 /* assign program index info. Mask 7: select I/P/B, Num_req: 400 max */ 544 ivtv_vapi_result(itv, data, CX2341X_ENC_SET_PGM_INDEX_INFO, 2, 7, 400); 545 itv->pgm_info_offset = data[0]; 546 itv->pgm_info_num = data[1]; 547 itv->pgm_info_write_idx = 0; 548 itv->pgm_info_read_idx = 0; 549 550 IVTV_DEBUG_INFO("PGM Index at 0x%08x with %d elements\n", 551 itv->pgm_info_offset, itv->pgm_info_num); 552 553 /* Setup API for Stream */ 554 cx2341x_update(itv, ivtv_api_func, NULL, p); 555 556 /* mute if capturing radio */ 557 if (test_bit(IVTV_F_I_RADIO_USER, &itv->i_flags)) 558 ivtv_vapi(itv, CX2341X_ENC_MUTE_VIDEO, 1, 559 1 | (p->video_mute_yuv << 8)); 560 } 561 562 /* Vsync Setup */ 563 if (itv->has_cx23415 && !test_and_set_bit(IVTV_F_I_DIG_RST, &itv->i_flags)) { 564 /* event notification (on) */ 565 ivtv_vapi(itv, CX2341X_ENC_SET_EVENT_NOTIFICATION, 4, 0, 1, IVTV_IRQ_ENC_VIM_RST, -1); 566 ivtv_clear_irq_mask(itv, IVTV_IRQ_ENC_VIM_RST); 567 } 568 569 if (atomic_read(&itv->capturing) == 0) { 570 /* Clear all Pending Interrupts */ 571 ivtv_set_irq_mask(itv, IVTV_IRQ_MASK_CAPTURE); 572 573 clear_bit(IVTV_F_I_EOS, &itv->i_flags); 574 575 /* Initialize Digitizer for Capture */ 576 itv->video_dec_func(itv, VIDIOC_STREAMOFF, NULL); 577 ivtv_msleep_timeout(300, 1); 578 ivtv_vapi(itv, CX2341X_ENC_INITIALIZE_INPUT, 0); 579 itv->video_dec_func(itv, VIDIOC_STREAMON, NULL); 580 } 581 582 /* begin_capture */ 583 if (ivtv_vapi(itv, CX2341X_ENC_START_CAPTURE, 2, captype, subtype)) 584 { 585 IVTV_DEBUG_WARN( "Error starting capture!\n"); 586 return -EINVAL; 587 } 588 589 /* Start Passthrough */ 590 if (enable_passthrough) { 591 ivtv_passthrough_mode(itv, 1); 592 } 593 594 if (s->type == IVTV_ENC_STREAM_TYPE_VBI) 595 ivtv_clear_irq_mask(itv, IVTV_IRQ_ENC_VBI_CAP); 596 else 597 ivtv_clear_irq_mask(itv, IVTV_IRQ_MASK_CAPTURE); 598 599 /* you're live! sit back and await interrupts :) */ 600 atomic_inc(&itv->capturing); 601 return 0; 602} 603 604static int ivtv_setup_v4l2_decode_stream(struct ivtv_stream *s) 605{ 606 u32 data[CX2341X_MBOX_MAX_DATA]; 607 struct ivtv *itv = s->itv; 608 struct cx2341x_mpeg_params *p = &itv->params; 609 int datatype; 610 611 if (s->v4l2dev == NULL) 612 return -EINVAL; 613 614 IVTV_DEBUG_INFO("Setting some initial decoder settings\n"); 615 616 /* set audio mode to left/stereo for dual/stereo mode. */ 617 ivtv_vapi(itv, CX2341X_DEC_SET_AUDIO_MODE, 2, itv->audio_bilingual_mode, itv->audio_stereo_mode); 618 619 /* set number of internal decoder buffers */ 620 ivtv_vapi(itv, CX2341X_DEC_SET_DISPLAY_BUFFERS, 1, 0); 621 622 /* prebuffering */ 623 ivtv_vapi(itv, CX2341X_DEC_SET_PREBUFFERING, 1, 1); 624 625 /* extract from user packets */ 626 ivtv_vapi_result(itv, data, CX2341X_DEC_EXTRACT_VBI, 1, 1); 627 itv->vbi.dec_start = data[0]; 628 629 IVTV_DEBUG_INFO("Decoder VBI RE-Insert start 0x%08x size 0x%08x\n", 630 itv->vbi.dec_start, data[1]); 631 632 /* set decoder source settings */ 633 /* Data type: 0 = mpeg from host, 634 1 = yuv from encoder, 635 2 = yuv_from_host */ 636 switch (s->type) { 637 case IVTV_DEC_STREAM_TYPE_YUV: 638 datatype = itv->output_mode == OUT_PASSTHROUGH ? 1 : 2; 639 IVTV_DEBUG_INFO("Setup DEC YUV Stream data[0] = %d\n", datatype); 640 break; 641 case IVTV_DEC_STREAM_TYPE_MPG: 642 default: 643 datatype = 0; 644 break; 645 } 646 if (ivtv_vapi(itv, CX2341X_DEC_SET_DECODER_SOURCE, 4, datatype, 647 p->width, p->height, p->audio_properties)) { 648 IVTV_DEBUG_WARN("Couldn't initialize decoder source\n"); 649 } 650 return 0; 651} 652 653int ivtv_start_v4l2_decode_stream(struct ivtv_stream *s, int gop_offset) 654{ 655 struct ivtv *itv = s->itv; 656 657 if (s->v4l2dev == NULL) 658 return -EINVAL; 659 660 if (test_and_set_bit(IVTV_F_S_STREAMING, &s->s_flags)) 661 return 0; /* already started */ 662 663 IVTV_DEBUG_INFO("Starting decode stream %s (gop_offset %d)\n", s->name, gop_offset); 664 665 ivtv_setup_v4l2_decode_stream(s); 666 667 /* set dma size to 65536 bytes */ 668 ivtv_vapi(itv, CX2341X_DEC_SET_DMA_BLOCK_SIZE, 1, 65536); 669 670 /* Clear Streamoff */ 671 clear_bit(IVTV_F_S_STREAMOFF, &s->s_flags); 672 673 /* Zero out decoder counters */ 674 writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA_END].data[0]); 675 writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA_END].data[1]); 676 writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA_END].data[2]); 677 writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA_END].data[3]); 678 writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA].data[0]); 679 writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA].data[1]); 680 writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA].data[2]); 681 writel(0, &itv->dec_mbox.mbox[IVTV_MBOX_DMA].data[3]); 682 683 /* turn on notification of dual/stereo mode change */ 684 ivtv_vapi(itv, CX2341X_DEC_SET_EVENT_NOTIFICATION, 4, 0, 1, IVTV_IRQ_DEC_AUD_MODE_CHG, -1); 685 686 /* start playback */ 687 ivtv_vapi(itv, CX2341X_DEC_START_PLAYBACK, 2, gop_offset, 0); 688 689 /* Clear the following Interrupt mask bits for decoding */ 690 ivtv_clear_irq_mask(itv, IVTV_IRQ_MASK_DECODE); 691 IVTV_DEBUG_IRQ("IRQ Mask is now: 0x%08x\n", itv->irqmask); 692 693 /* you're live! sit back and await interrupts :) */ 694 atomic_inc(&itv->decoding); 695 return 0; 696} 697 698void ivtv_stop_all_captures(struct ivtv *itv) 699{ 700 int i; 701 702 for (i = IVTV_MAX_STREAMS - 1; i >= 0; i--) { 703 struct ivtv_stream *s = &itv->streams[i]; 704 705 if (s->v4l2dev == NULL) 706 continue; 707 if (test_bit(IVTV_F_S_STREAMING, &s->s_flags)) { 708 ivtv_stop_v4l2_encode_stream(s, 0); 709 } 710 } 711} 712 713int ivtv_stop_v4l2_encode_stream(struct ivtv_stream *s, int gop_end) 714{ 715 struct ivtv *itv = s->itv; 716 DECLARE_WAITQUEUE(wait, current); 717 int cap_type; 718 int stopmode; 719 720 if (s->v4l2dev == NULL) 721 return -EINVAL; 722 723 /* This function assumes that you are allowed to stop the capture 724 and that we are actually capturing */ 725 726 IVTV_DEBUG_INFO("Stop Capture\n"); 727 728 if (s->type == IVTV_DEC_STREAM_TYPE_VOUT) 729 return 0; 730 if (atomic_read(&itv->capturing) == 0) 731 return 0; 732 733 switch (s->type) { 734 case IVTV_ENC_STREAM_TYPE_YUV: 735 cap_type = 1; 736 break; 737 case IVTV_ENC_STREAM_TYPE_PCM: 738 cap_type = 1; 739 break; 740 case IVTV_ENC_STREAM_TYPE_VBI: 741 cap_type = 1; 742 break; 743 case IVTV_ENC_STREAM_TYPE_MPG: 744 default: 745 cap_type = 0; 746 break; 747 } 748 749 /* Stop Capture Mode */ 750 if (s->type == IVTV_ENC_STREAM_TYPE_MPG && gop_end) { 751 stopmode = 0; 752 } else { 753 stopmode = 1; 754 } 755 756 /* end_capture */ 757 /* when: 0 = end of GOP 1 = NOW!, type: 0 = mpeg, subtype: 3 = video+audio */ 758 ivtv_vapi(itv, CX2341X_ENC_STOP_CAPTURE, 3, stopmode, cap_type, s->subtype); 759 760 if (!test_bit(IVTV_F_S_PASSTHROUGH, &s->s_flags)) { 761 if (s->type == IVTV_ENC_STREAM_TYPE_MPG && gop_end) { 762 /* only run these if we're shutting down the last cap */ 763 unsigned long duration; 764 unsigned long then = jiffies; 765 766 add_wait_queue(&itv->eos_waitq, &wait); 767 768 set_current_state(TASK_INTERRUPTIBLE); 769 770 /* wait 2s for EOS interrupt */ 771 while (!test_bit(IVTV_F_I_EOS, &itv->i_flags) && 772 time_before(jiffies, 773 then + msecs_to_jiffies(2000))) { 774 schedule_timeout(msecs_to_jiffies(10)); 775 } 776 777 /* To convert jiffies to ms, we must multiply by 1000 778 * and divide by HZ. To avoid runtime division, we 779 * convert this to multiplication by 1000/HZ. 780 * Since integer division truncates, we get the best 781 * accuracy if we do a rounding calculation of the constant. 782 * Think of the case where HZ is 1024. 783 */ 784 duration = ((1000 + HZ / 2) / HZ) * (jiffies - then); 785 786 if (!test_bit(IVTV_F_I_EOS, &itv->i_flags)) { 787 IVTV_DEBUG_WARN("%s: EOS interrupt not received! stopping anyway.\n", s->name); 788 IVTV_DEBUG_WARN("%s: waited %lu ms.\n", s->name, duration); 789 } else { 790 IVTV_DEBUG_INFO("%s: EOS took %lu ms to occur.\n", s->name, duration); 791 } 792 set_current_state(TASK_RUNNING); 793 remove_wait_queue(&itv->eos_waitq, &wait); 794 set_bit(IVTV_F_S_STREAMOFF, &s->s_flags); 795 } 796 797 /* Handle any pending interrupts */ 798 ivtv_msleep_timeout(100, 1); 799 } 800 801 atomic_dec(&itv->capturing); 802 803 /* Clear capture and no-read bits */ 804 clear_bit(IVTV_F_S_STREAMING, &s->s_flags); 805 806 if (s->type == IVTV_ENC_STREAM_TYPE_VBI) 807 ivtv_set_irq_mask(itv, IVTV_IRQ_ENC_VBI_CAP); 808 809 if (atomic_read(&itv->capturing) > 0) { 810 return 0; 811 } 812 813 /* Set the following Interrupt mask bits for capture */ 814 ivtv_set_irq_mask(itv, IVTV_IRQ_MASK_CAPTURE); 815 del_timer(&itv->dma_timer); 816 817 /* event notification (off) */ 818 if (test_and_clear_bit(IVTV_F_I_DIG_RST, &itv->i_flags)) { 819 /* type: 0 = refresh */ 820 /* on/off: 0 = off, intr: 0x10000000, mbox_id: -1: none */ 821 ivtv_vapi(itv, CX2341X_ENC_SET_EVENT_NOTIFICATION, 4, 0, 0, IVTV_IRQ_ENC_VIM_RST, -1); 822 ivtv_set_irq_mask(itv, IVTV_IRQ_ENC_VIM_RST); 823 } 824 825 wake_up(&s->waitq); 826 827 return 0; 828} 829 830int ivtv_stop_v4l2_decode_stream(struct ivtv_stream *s, int flags, u64 pts) 831{ 832 struct ivtv *itv = s->itv; 833 834 if (s->v4l2dev == NULL) 835 return -EINVAL; 836 837 if (s->type != IVTV_DEC_STREAM_TYPE_YUV && s->type != IVTV_DEC_STREAM_TYPE_MPG) 838 return -EINVAL; 839 840 if (!test_bit(IVTV_F_S_STREAMING, &s->s_flags)) 841 return 0; 842 843 IVTV_DEBUG_INFO("Stop Decode at %llu, flags: %x\n", (unsigned long long)pts, flags); 844 845 /* Stop Decoder */ 846 if (!(flags & VIDEO_CMD_STOP_IMMEDIATELY) || pts) { 847 u32 tmp = 0; 848 849 /* Wait until the decoder is no longer running */ 850 if (pts) { 851 ivtv_vapi(itv, CX2341X_DEC_STOP_PLAYBACK, 3, 852 0, (u32)(pts & 0xffffffff), (u32)(pts >> 32)); 853 } 854 while (1) { 855 u32 data[CX2341X_MBOX_MAX_DATA]; 856 ivtv_vapi_result(itv, data, CX2341X_DEC_GET_XFER_INFO, 0); 857 if (s->q_full.buffers + s->q_dma.buffers == 0) { 858 if (tmp == data[3]) 859 break; 860 tmp = data[3]; 861 } 862 if (ivtv_msleep_timeout(100, 1)) 863 break; 864 } 865 } 866 ivtv_vapi(itv, CX2341X_DEC_STOP_PLAYBACK, 3, flags & VIDEO_CMD_STOP_TO_BLACK, 0, 0); 867 868 /* turn off notification of dual/stereo mode change */ 869 ivtv_vapi(itv, CX2341X_DEC_SET_EVENT_NOTIFICATION, 4, 0, 0, IVTV_IRQ_DEC_AUD_MODE_CHG, -1); 870 871 ivtv_set_irq_mask(itv, IVTV_IRQ_MASK_DECODE); 872 del_timer(&itv->dma_timer); 873 874 clear_bit(IVTV_F_S_NEEDS_DATA, &s->s_flags); 875 clear_bit(IVTV_F_S_STREAMING, &s->s_flags); 876 ivtv_flush_queues(s); 877 878 /* decrement decoding */ 879 atomic_dec(&itv->decoding); 880 881 set_bit(IVTV_F_I_EV_DEC_STOPPED, &itv->i_flags); 882 wake_up(&itv->event_waitq); 883 884 /* wake up wait queues */ 885 wake_up(&s->waitq); 886 887 return 0; 888} 889 890int ivtv_passthrough_mode(struct ivtv *itv, int enable) 891{ 892 struct ivtv_stream *yuv_stream = &itv->streams[IVTV_ENC_STREAM_TYPE_YUV]; 893 struct ivtv_stream *dec_stream = &itv->streams[IVTV_DEC_STREAM_TYPE_YUV]; 894 895 if (yuv_stream->v4l2dev == NULL || dec_stream->v4l2dev == NULL) 896 return -EINVAL; 897 898 IVTV_DEBUG_INFO("ivtv ioctl: Select passthrough mode\n"); 899 900 /* Prevent others from starting/stopping streams while we 901 initiate/terminate passthrough mode */ 902 if (enable) { 903 if (itv->output_mode == OUT_PASSTHROUGH) { 904 return 0; 905 } 906 if (ivtv_set_output_mode(itv, OUT_PASSTHROUGH) != OUT_PASSTHROUGH) 907 return -EBUSY; 908 909 /* Fully initialize stream, and then unflag init */ 910 set_bit(IVTV_F_S_PASSTHROUGH, &dec_stream->s_flags); 911 set_bit(IVTV_F_S_STREAMING, &dec_stream->s_flags); 912 913 /* Setup YUV Decoder */ 914 ivtv_setup_v4l2_decode_stream(dec_stream); 915 916 /* Start Decoder */ 917 ivtv_vapi(itv, CX2341X_DEC_START_PLAYBACK, 2, 0, 1); 918 atomic_inc(&itv->decoding); 919 920 /* Setup capture if not already done */ 921 if (atomic_read(&itv->capturing) == 0) { 922 cx2341x_update(itv, ivtv_api_func, NULL, &itv->params); 923 } 924 925 /* Start Passthrough Mode */ 926 ivtv_vapi(itv, CX2341X_ENC_START_CAPTURE, 2, 2, 11); 927 atomic_inc(&itv->capturing); 928 return 0; 929 } 930 931 if (itv->output_mode != OUT_PASSTHROUGH) 932 return 0; 933 934 /* Stop Passthrough Mode */ 935 ivtv_vapi(itv, CX2341X_ENC_STOP_CAPTURE, 3, 1, 2, 11); 936 ivtv_vapi(itv, CX2341X_DEC_STOP_PLAYBACK, 3, 1, 0, 0); 937 938 atomic_dec(&itv->capturing); 939 atomic_dec(&itv->decoding); 940 clear_bit(IVTV_F_S_PASSTHROUGH, &dec_stream->s_flags); 941 clear_bit(IVTV_F_S_STREAMING, &dec_stream->s_flags); 942 itv->output_mode = OUT_NONE; 943 944 return 0; 945} 946