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