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