1 /* 2 * cx18 file operation functions 3 * 4 * Derived from ivtv-fileops.c 5 * 6 * Copyright (C) 2007 Hans Verkuil <hverkuil@xs4all.nl> 7 * Copyright (C) 2008 Andy Walls <awalls@md.metrocast.net> 8 * 9 * This program is free software; you can redistribute it and/or modify 10 * it under the terms of the GNU General Public License as published by 11 * the Free Software Foundation; either version 2 of the License, or 12 * (at your option) any later version. 13 * 14 * This program is distributed in the hope that it will be useful, 15 * but WITHOUT ANY WARRANTY; without even the implied warranty of 16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 * GNU General Public License for more details. 18 * 19 * You should have received a copy of the GNU General Public License 20 * along with this program; if not, write to the Free Software 21 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 22 * 02111-1307 USA 23 */ 24 25 #include "cx18-driver.h" 26 #include "cx18-fileops.h" 27 #include "cx18-i2c.h" 28 #include "cx18-queue.h" 29 #include "cx18-vbi.h" 30 #include "cx18-audio.h" 31 #include "cx18-mailbox.h" 32 #include "cx18-scb.h" 33 #include "cx18-streams.h" 34 #include "cx18-controls.h" 35 #include "cx18-ioctl.h" 36 #include "cx18-cards.h" 37 #include <media/v4l2-event.h> 38 39 /* This function tries to claim the stream for a specific file descriptor. 40 If no one else is using this stream then the stream is claimed and 41 associated VBI and IDX streams are also automatically claimed. 42 Possible error returns: -EBUSY if someone else has claimed 43 the stream or 0 on success. */ 44 int cx18_claim_stream(struct cx18_open_id *id, int type) 45 { 46 struct cx18 *cx = id->cx; 47 struct cx18_stream *s = &cx->streams[type]; 48 struct cx18_stream *s_assoc; 49 50 /* Nothing should ever try to directly claim the IDX stream */ 51 if (type == CX18_ENC_STREAM_TYPE_IDX) { 52 CX18_WARN("MPEG Index stream cannot be claimed " 53 "directly, but something tried.\n"); 54 return -EINVAL; 55 } 56 57 if (test_and_set_bit(CX18_F_S_CLAIMED, &s->s_flags)) { 58 /* someone already claimed this stream */ 59 if (s->id == id->open_id) { 60 /* yes, this file descriptor did. So that's OK. */ 61 return 0; 62 } 63 if (s->id == -1 && type == CX18_ENC_STREAM_TYPE_VBI) { 64 /* VBI is handled already internally, now also assign 65 the file descriptor to this stream for external 66 reading of the stream. */ 67 s->id = id->open_id; 68 CX18_DEBUG_INFO("Start Read VBI\n"); 69 return 0; 70 } 71 /* someone else is using this stream already */ 72 CX18_DEBUG_INFO("Stream %d is busy\n", type); 73 return -EBUSY; 74 } 75 s->id = id->open_id; 76 77 /* 78 * CX18_ENC_STREAM_TYPE_MPG needs to claim: 79 * CX18_ENC_STREAM_TYPE_VBI, if VBI insertion is on for sliced VBI, or 80 * CX18_ENC_STREAM_TYPE_IDX, if VBI insertion is off for sliced VBI 81 * (We don't yet fix up MPEG Index entries for our inserted packets). 82 * 83 * For all other streams we're done. 84 */ 85 if (type != CX18_ENC_STREAM_TYPE_MPG) 86 return 0; 87 88 s_assoc = &cx->streams[CX18_ENC_STREAM_TYPE_IDX]; 89 if (cx->vbi.insert_mpeg && !cx18_raw_vbi(cx)) 90 s_assoc = &cx->streams[CX18_ENC_STREAM_TYPE_VBI]; 91 else if (!cx18_stream_enabled(s_assoc)) 92 return 0; 93 94 set_bit(CX18_F_S_CLAIMED, &s_assoc->s_flags); 95 96 /* mark that it is used internally */ 97 set_bit(CX18_F_S_INTERNAL_USE, &s_assoc->s_flags); 98 return 0; 99 } 100 EXPORT_SYMBOL(cx18_claim_stream); 101 102 /* This function releases a previously claimed stream. It will take into 103 account associated VBI streams. */ 104 void cx18_release_stream(struct cx18_stream *s) 105 { 106 struct cx18 *cx = s->cx; 107 struct cx18_stream *s_assoc; 108 109 s->id = -1; 110 if (s->type == CX18_ENC_STREAM_TYPE_IDX) { 111 /* 112 * The IDX stream is only used internally, and can 113 * only be indirectly unclaimed by unclaiming the MPG stream. 114 */ 115 return; 116 } 117 118 if (s->type == CX18_ENC_STREAM_TYPE_VBI && 119 test_bit(CX18_F_S_INTERNAL_USE, &s->s_flags)) { 120 /* this stream is still in use internally */ 121 return; 122 } 123 if (!test_and_clear_bit(CX18_F_S_CLAIMED, &s->s_flags)) { 124 CX18_DEBUG_WARN("Release stream %s not in use!\n", s->name); 125 return; 126 } 127 128 cx18_flush_queues(s); 129 130 /* 131 * CX18_ENC_STREAM_TYPE_MPG needs to release the 132 * CX18_ENC_STREAM_TYPE_VBI and/or CX18_ENC_STREAM_TYPE_IDX streams. 133 * 134 * For all other streams we're done. 135 */ 136 if (s->type != CX18_ENC_STREAM_TYPE_MPG) 137 return; 138 139 /* Unclaim the associated MPEG Index stream */ 140 s_assoc = &cx->streams[CX18_ENC_STREAM_TYPE_IDX]; 141 if (test_and_clear_bit(CX18_F_S_INTERNAL_USE, &s_assoc->s_flags)) { 142 clear_bit(CX18_F_S_CLAIMED, &s_assoc->s_flags); 143 cx18_flush_queues(s_assoc); 144 } 145 146 /* Unclaim the associated VBI stream */ 147 s_assoc = &cx->streams[CX18_ENC_STREAM_TYPE_VBI]; 148 if (test_and_clear_bit(CX18_F_S_INTERNAL_USE, &s_assoc->s_flags)) { 149 if (s_assoc->id == -1) { 150 /* 151 * The VBI stream is not still claimed by a file 152 * descriptor, so completely unclaim it. 153 */ 154 clear_bit(CX18_F_S_CLAIMED, &s_assoc->s_flags); 155 cx18_flush_queues(s_assoc); 156 } 157 } 158 } 159 EXPORT_SYMBOL(cx18_release_stream); 160 161 static void cx18_dualwatch(struct cx18 *cx) 162 { 163 struct v4l2_tuner vt; 164 u32 new_stereo_mode; 165 const u32 dual = 0x0200; 166 167 new_stereo_mode = v4l2_ctrl_g_ctrl(cx->cxhdl.audio_mode); 168 memset(&vt, 0, sizeof(vt)); 169 cx18_call_all(cx, tuner, g_tuner, &vt); 170 if (vt.audmode == V4L2_TUNER_MODE_LANG1_LANG2 && 171 (vt.rxsubchans & V4L2_TUNER_SUB_LANG2)) 172 new_stereo_mode = dual; 173 174 if (new_stereo_mode == cx->dualwatch_stereo_mode) 175 return; 176 177 CX18_DEBUG_INFO("dualwatch: change stereo flag from 0x%x to 0x%x.\n", 178 cx->dualwatch_stereo_mode, new_stereo_mode); 179 if (v4l2_ctrl_s_ctrl(cx->cxhdl.audio_mode, new_stereo_mode)) 180 CX18_DEBUG_INFO("dualwatch: changing stereo flag failed\n"); 181 } 182 183 184 static struct cx18_mdl *cx18_get_mdl(struct cx18_stream *s, int non_block, 185 int *err) 186 { 187 struct cx18 *cx = s->cx; 188 struct cx18_stream *s_vbi = &cx->streams[CX18_ENC_STREAM_TYPE_VBI]; 189 struct cx18_mdl *mdl; 190 DEFINE_WAIT(wait); 191 192 *err = 0; 193 while (1) { 194 if (s->type == CX18_ENC_STREAM_TYPE_MPG) { 195 /* Process pending program updates and VBI data */ 196 if (time_after(jiffies, cx->dualwatch_jiffies + msecs_to_jiffies(1000))) { 197 cx->dualwatch_jiffies = jiffies; 198 cx18_dualwatch(cx); 199 } 200 if (test_bit(CX18_F_S_INTERNAL_USE, &s_vbi->s_flags) && 201 !test_bit(CX18_F_S_APPL_IO, &s_vbi->s_flags)) { 202 while ((mdl = cx18_dequeue(s_vbi, 203 &s_vbi->q_full))) { 204 /* byteswap and process VBI data */ 205 cx18_process_vbi_data(cx, mdl, 206 s_vbi->type); 207 cx18_stream_put_mdl_fw(s_vbi, mdl); 208 } 209 } 210 mdl = &cx->vbi.sliced_mpeg_mdl; 211 if (mdl->readpos != mdl->bytesused) 212 return mdl; 213 } 214 215 /* do we have new data? */ 216 mdl = cx18_dequeue(s, &s->q_full); 217 if (mdl) { 218 if (!test_and_clear_bit(CX18_F_M_NEED_SWAP, 219 &mdl->m_flags)) 220 return mdl; 221 if (s->type == CX18_ENC_STREAM_TYPE_MPG) 222 /* byteswap MPG data */ 223 cx18_mdl_swap(mdl); 224 else { 225 /* byteswap and process VBI data */ 226 cx18_process_vbi_data(cx, mdl, s->type); 227 } 228 return mdl; 229 } 230 231 /* return if end of stream */ 232 if (!test_bit(CX18_F_S_STREAMING, &s->s_flags)) { 233 CX18_DEBUG_INFO("EOS %s\n", s->name); 234 return NULL; 235 } 236 237 /* return if file was opened with O_NONBLOCK */ 238 if (non_block) { 239 *err = -EAGAIN; 240 return NULL; 241 } 242 243 /* wait for more data to arrive */ 244 prepare_to_wait(&s->waitq, &wait, TASK_INTERRUPTIBLE); 245 /* New buffers might have become available before we were added 246 to the waitqueue */ 247 if (!atomic_read(&s->q_full.depth)) 248 schedule(); 249 finish_wait(&s->waitq, &wait); 250 if (signal_pending(current)) { 251 /* return if a signal was received */ 252 CX18_DEBUG_INFO("User stopped %s\n", s->name); 253 *err = -EINTR; 254 return NULL; 255 } 256 } 257 } 258 259 static void cx18_setup_sliced_vbi_mdl(struct cx18 *cx) 260 { 261 struct cx18_mdl *mdl = &cx->vbi.sliced_mpeg_mdl; 262 struct cx18_buffer *buf = &cx->vbi.sliced_mpeg_buf; 263 int idx = cx->vbi.inserted_frame % CX18_VBI_FRAMES; 264 265 buf->buf = cx->vbi.sliced_mpeg_data[idx]; 266 buf->bytesused = cx->vbi.sliced_mpeg_size[idx]; 267 buf->readpos = 0; 268 269 mdl->curr_buf = NULL; 270 mdl->bytesused = cx->vbi.sliced_mpeg_size[idx]; 271 mdl->readpos = 0; 272 } 273 274 static size_t cx18_copy_buf_to_user(struct cx18_stream *s, 275 struct cx18_buffer *buf, char __user *ubuf, size_t ucount, bool *stop) 276 { 277 struct cx18 *cx = s->cx; 278 size_t len = buf->bytesused - buf->readpos; 279 280 *stop = false; 281 if (len > ucount) 282 len = ucount; 283 if (cx->vbi.insert_mpeg && s->type == CX18_ENC_STREAM_TYPE_MPG && 284 !cx18_raw_vbi(cx) && buf != &cx->vbi.sliced_mpeg_buf) { 285 /* 286 * Try to find a good splice point in the PS, just before 287 * an MPEG-2 Program Pack start code, and provide only 288 * up to that point to the user, so it's easy to insert VBI data 289 * the next time around. 290 * 291 * This will not work for an MPEG-2 TS and has only been 292 * verified by analysis to work for an MPEG-2 PS. Helen Buus 293 * pointed out this works for the CX23416 MPEG-2 DVD compatible 294 * stream, and research indicates both the MPEG 2 SVCD and DVD 295 * stream types use an MPEG-2 PS container. 296 */ 297 /* 298 * An MPEG-2 Program Stream (PS) is a series of 299 * MPEG-2 Program Packs terminated by an 300 * MPEG Program End Code after the last Program Pack. 301 * A Program Pack may hold a PS System Header packet and any 302 * number of Program Elementary Stream (PES) Packets 303 */ 304 const char *start = buf->buf + buf->readpos; 305 const char *p = start + 1; 306 const u8 *q; 307 u8 ch = cx->search_pack_header ? 0xba : 0xe0; 308 int stuffing, i; 309 310 while (start + len > p) { 311 /* Scan for a 0 to find a potential MPEG-2 start code */ 312 q = memchr(p, 0, start + len - p); 313 if (q == NULL) 314 break; 315 p = q + 1; 316 /* 317 * Keep looking if not a 318 * MPEG-2 Pack header start code: 0x00 0x00 0x01 0xba 319 * or MPEG-2 video PES start code: 0x00 0x00 0x01 0xe0 320 */ 321 if ((char *)q + 15 >= buf->buf + buf->bytesused || 322 q[1] != 0 || q[2] != 1 || q[3] != ch) 323 continue; 324 325 /* If expecting the primary video PES */ 326 if (!cx->search_pack_header) { 327 /* Continue if it couldn't be a PES packet */ 328 if ((q[6] & 0xc0) != 0x80) 329 continue; 330 /* Check if a PTS or PTS & DTS follow */ 331 if (((q[7] & 0xc0) == 0x80 && /* PTS only */ 332 (q[9] & 0xf0) == 0x20) || /* PTS only */ 333 ((q[7] & 0xc0) == 0xc0 && /* PTS & DTS */ 334 (q[9] & 0xf0) == 0x30)) { /* DTS follows */ 335 /* Assume we found the video PES hdr */ 336 ch = 0xba; /* next want a Program Pack*/ 337 cx->search_pack_header = 1; 338 p = q + 9; /* Skip this video PES hdr */ 339 } 340 continue; 341 } 342 343 /* We may have found a Program Pack start code */ 344 345 /* Get the count of stuffing bytes & verify them */ 346 stuffing = q[13] & 7; 347 /* all stuffing bytes must be 0xff */ 348 for (i = 0; i < stuffing; i++) 349 if (q[14 + i] != 0xff) 350 break; 351 if (i == stuffing && /* right number of stuffing bytes*/ 352 (q[4] & 0xc4) == 0x44 && /* marker check */ 353 (q[12] & 3) == 3 && /* marker check */ 354 q[14 + stuffing] == 0 && /* PES Pack or Sys Hdr */ 355 q[15 + stuffing] == 0 && 356 q[16 + stuffing] == 1) { 357 /* We declare we actually found a Program Pack*/ 358 cx->search_pack_header = 0; /* expect vid PES */ 359 len = (char *)q - start; 360 cx18_setup_sliced_vbi_mdl(cx); 361 *stop = true; 362 break; 363 } 364 } 365 } 366 if (copy_to_user(ubuf, (u8 *)buf->buf + buf->readpos, len)) { 367 CX18_DEBUG_WARN("copy %zd bytes to user failed for %s\n", 368 len, s->name); 369 return -EFAULT; 370 } 371 buf->readpos += len; 372 if (s->type == CX18_ENC_STREAM_TYPE_MPG && 373 buf != &cx->vbi.sliced_mpeg_buf) 374 cx->mpg_data_received += len; 375 return len; 376 } 377 378 static size_t cx18_copy_mdl_to_user(struct cx18_stream *s, 379 struct cx18_mdl *mdl, char __user *ubuf, size_t ucount) 380 { 381 size_t tot_written = 0; 382 int rc; 383 bool stop = false; 384 385 if (mdl->curr_buf == NULL) 386 mdl->curr_buf = list_first_entry(&mdl->buf_list, 387 struct cx18_buffer, list); 388 389 if (list_entry_is_past_end(mdl->curr_buf, &mdl->buf_list, list)) { 390 /* 391 * For some reason we've exhausted the buffers, but the MDL 392 * object still said some data was unread. 393 * Fix that and bail out. 394 */ 395 mdl->readpos = mdl->bytesused; 396 return 0; 397 } 398 399 list_for_each_entry_from(mdl->curr_buf, &mdl->buf_list, list) { 400 401 if (mdl->curr_buf->readpos >= mdl->curr_buf->bytesused) 402 continue; 403 404 rc = cx18_copy_buf_to_user(s, mdl->curr_buf, ubuf + tot_written, 405 ucount - tot_written, &stop); 406 if (rc < 0) 407 return rc; 408 mdl->readpos += rc; 409 tot_written += rc; 410 411 if (stop || /* Forced stopping point for VBI insertion */ 412 tot_written >= ucount || /* Reader request statisfied */ 413 mdl->curr_buf->readpos < mdl->curr_buf->bytesused || 414 mdl->readpos >= mdl->bytesused) /* MDL buffers drained */ 415 break; 416 } 417 return tot_written; 418 } 419 420 static ssize_t cx18_read(struct cx18_stream *s, char __user *ubuf, 421 size_t tot_count, int non_block) 422 { 423 struct cx18 *cx = s->cx; 424 size_t tot_written = 0; 425 int single_frame = 0; 426 427 if (atomic_read(&cx->ana_capturing) == 0 && s->id == -1) { 428 /* shouldn't happen */ 429 CX18_DEBUG_WARN("Stream %s not initialized before read\n", 430 s->name); 431 return -EIO; 432 } 433 434 /* Each VBI buffer is one frame, the v4l2 API says that for VBI the 435 frames should arrive one-by-one, so make sure we never output more 436 than one VBI frame at a time */ 437 if (s->type == CX18_ENC_STREAM_TYPE_VBI && !cx18_raw_vbi(cx)) 438 single_frame = 1; 439 440 for (;;) { 441 struct cx18_mdl *mdl; 442 int rc; 443 444 mdl = cx18_get_mdl(s, non_block, &rc); 445 /* if there is no data available... */ 446 if (mdl == NULL) { 447 /* if we got data, then return that regardless */ 448 if (tot_written) 449 break; 450 /* EOS condition */ 451 if (rc == 0) { 452 clear_bit(CX18_F_S_STREAMOFF, &s->s_flags); 453 clear_bit(CX18_F_S_APPL_IO, &s->s_flags); 454 cx18_release_stream(s); 455 } 456 /* set errno */ 457 return rc; 458 } 459 460 rc = cx18_copy_mdl_to_user(s, mdl, ubuf + tot_written, 461 tot_count - tot_written); 462 463 if (mdl != &cx->vbi.sliced_mpeg_mdl) { 464 if (mdl->readpos == mdl->bytesused) 465 cx18_stream_put_mdl_fw(s, mdl); 466 else 467 cx18_push(s, mdl, &s->q_full); 468 } else if (mdl->readpos == mdl->bytesused) { 469 int idx = cx->vbi.inserted_frame % CX18_VBI_FRAMES; 470 471 cx->vbi.sliced_mpeg_size[idx] = 0; 472 cx->vbi.inserted_frame++; 473 cx->vbi_data_inserted += mdl->bytesused; 474 } 475 if (rc < 0) 476 return rc; 477 tot_written += rc; 478 479 if (tot_written == tot_count || single_frame) 480 break; 481 } 482 return tot_written; 483 } 484 485 static ssize_t cx18_read_pos(struct cx18_stream *s, char __user *ubuf, 486 size_t count, loff_t *pos, int non_block) 487 { 488 ssize_t rc = count ? cx18_read(s, ubuf, count, non_block) : 0; 489 struct cx18 *cx = s->cx; 490 491 CX18_DEBUG_HI_FILE("read %zd from %s, got %zd\n", count, s->name, rc); 492 if (rc > 0) 493 pos += rc; 494 return rc; 495 } 496 497 int cx18_start_capture(struct cx18_open_id *id) 498 { 499 struct cx18 *cx = id->cx; 500 struct cx18_stream *s = &cx->streams[id->type]; 501 struct cx18_stream *s_vbi; 502 struct cx18_stream *s_idx; 503 504 if (s->type == CX18_ENC_STREAM_TYPE_RAD) { 505 /* you cannot read from these stream types. */ 506 return -EPERM; 507 } 508 509 /* Try to claim this stream. */ 510 if (cx18_claim_stream(id, s->type)) 511 return -EBUSY; 512 513 /* If capture is already in progress, then we also have to 514 do nothing extra. */ 515 if (test_bit(CX18_F_S_STREAMOFF, &s->s_flags) || 516 test_and_set_bit(CX18_F_S_STREAMING, &s->s_flags)) { 517 set_bit(CX18_F_S_APPL_IO, &s->s_flags); 518 return 0; 519 } 520 521 /* Start associated VBI or IDX stream capture if required */ 522 s_vbi = &cx->streams[CX18_ENC_STREAM_TYPE_VBI]; 523 s_idx = &cx->streams[CX18_ENC_STREAM_TYPE_IDX]; 524 if (s->type == CX18_ENC_STREAM_TYPE_MPG) { 525 /* 526 * The VBI and IDX streams should have been claimed 527 * automatically, if for internal use, when the MPG stream was 528 * claimed. We only need to start these streams capturing. 529 */ 530 if (test_bit(CX18_F_S_INTERNAL_USE, &s_idx->s_flags) && 531 !test_and_set_bit(CX18_F_S_STREAMING, &s_idx->s_flags)) { 532 if (cx18_start_v4l2_encode_stream(s_idx)) { 533 CX18_DEBUG_WARN("IDX capture start failed\n"); 534 clear_bit(CX18_F_S_STREAMING, &s_idx->s_flags); 535 goto start_failed; 536 } 537 CX18_DEBUG_INFO("IDX capture started\n"); 538 } 539 if (test_bit(CX18_F_S_INTERNAL_USE, &s_vbi->s_flags) && 540 !test_and_set_bit(CX18_F_S_STREAMING, &s_vbi->s_flags)) { 541 if (cx18_start_v4l2_encode_stream(s_vbi)) { 542 CX18_DEBUG_WARN("VBI capture start failed\n"); 543 clear_bit(CX18_F_S_STREAMING, &s_vbi->s_flags); 544 goto start_failed; 545 } 546 CX18_DEBUG_INFO("VBI insertion started\n"); 547 } 548 } 549 550 /* Tell the card to start capturing */ 551 if (!cx18_start_v4l2_encode_stream(s)) { 552 /* We're done */ 553 set_bit(CX18_F_S_APPL_IO, &s->s_flags); 554 /* Resume a possibly paused encoder */ 555 if (test_and_clear_bit(CX18_F_I_ENC_PAUSED, &cx->i_flags)) 556 cx18_vapi(cx, CX18_CPU_CAPTURE_PAUSE, 1, s->handle); 557 return 0; 558 } 559 560 start_failed: 561 CX18_DEBUG_WARN("Failed to start capturing for stream %s\n", s->name); 562 563 /* 564 * The associated VBI and IDX streams for internal use are released 565 * automatically when the MPG stream is released. We only need to stop 566 * the associated stream. 567 */ 568 if (s->type == CX18_ENC_STREAM_TYPE_MPG) { 569 /* Stop the IDX stream which is always for internal use */ 570 if (test_bit(CX18_F_S_STREAMING, &s_idx->s_flags)) { 571 cx18_stop_v4l2_encode_stream(s_idx, 0); 572 clear_bit(CX18_F_S_STREAMING, &s_idx->s_flags); 573 } 574 /* Stop the VBI stream, if only running for internal use */ 575 if (test_bit(CX18_F_S_STREAMING, &s_vbi->s_flags) && 576 !test_bit(CX18_F_S_APPL_IO, &s_vbi->s_flags)) { 577 cx18_stop_v4l2_encode_stream(s_vbi, 0); 578 clear_bit(CX18_F_S_STREAMING, &s_vbi->s_flags); 579 } 580 } 581 clear_bit(CX18_F_S_STREAMING, &s->s_flags); 582 cx18_release_stream(s); /* Also releases associated streams */ 583 return -EIO; 584 } 585 586 ssize_t cx18_v4l2_read(struct file *filp, char __user *buf, size_t count, 587 loff_t *pos) 588 { 589 struct cx18_open_id *id = file2id(filp); 590 struct cx18 *cx = id->cx; 591 struct cx18_stream *s = &cx->streams[id->type]; 592 int rc; 593 594 CX18_DEBUG_HI_FILE("read %zd bytes from %s\n", count, s->name); 595 596 mutex_lock(&cx->serialize_lock); 597 rc = cx18_start_capture(id); 598 mutex_unlock(&cx->serialize_lock); 599 if (rc) 600 return rc; 601 602 if ((s->vb_type == V4L2_BUF_TYPE_VIDEO_CAPTURE) && 603 (id->type == CX18_ENC_STREAM_TYPE_YUV)) { 604 return videobuf_read_stream(&s->vbuf_q, buf, count, pos, 0, 605 filp->f_flags & O_NONBLOCK); 606 } 607 608 return cx18_read_pos(s, buf, count, pos, filp->f_flags & O_NONBLOCK); 609 } 610 611 unsigned int cx18_v4l2_enc_poll(struct file *filp, poll_table *wait) 612 { 613 unsigned long req_events = poll_requested_events(wait); 614 struct cx18_open_id *id = file2id(filp); 615 struct cx18 *cx = id->cx; 616 struct cx18_stream *s = &cx->streams[id->type]; 617 int eof = test_bit(CX18_F_S_STREAMOFF, &s->s_flags); 618 unsigned res = 0; 619 620 /* Start a capture if there is none */ 621 if (!eof && !test_bit(CX18_F_S_STREAMING, &s->s_flags) && 622 (req_events & (POLLIN | POLLRDNORM))) { 623 int rc; 624 625 mutex_lock(&cx->serialize_lock); 626 rc = cx18_start_capture(id); 627 mutex_unlock(&cx->serialize_lock); 628 if (rc) { 629 CX18_DEBUG_INFO("Could not start capture for %s (%d)\n", 630 s->name, rc); 631 return POLLERR; 632 } 633 CX18_DEBUG_FILE("Encoder poll started capture\n"); 634 } 635 636 if ((s->vb_type == V4L2_BUF_TYPE_VIDEO_CAPTURE) && 637 (id->type == CX18_ENC_STREAM_TYPE_YUV)) { 638 int videobuf_poll = videobuf_poll_stream(filp, &s->vbuf_q, wait); 639 640 if (v4l2_event_pending(&id->fh)) 641 res |= POLLPRI; 642 if (eof && videobuf_poll == POLLERR) 643 return res | POLLHUP; 644 return res | videobuf_poll; 645 } 646 647 /* add stream's waitq to the poll list */ 648 CX18_DEBUG_HI_FILE("Encoder poll\n"); 649 if (v4l2_event_pending(&id->fh)) 650 res |= POLLPRI; 651 else 652 poll_wait(filp, &s->waitq, wait); 653 654 if (atomic_read(&s->q_full.depth)) 655 return res | POLLIN | POLLRDNORM; 656 if (eof) 657 return res | POLLHUP; 658 return res; 659 } 660 661 int cx18_v4l2_mmap(struct file *file, struct vm_area_struct *vma) 662 { 663 struct cx18_open_id *id = file->private_data; 664 struct cx18 *cx = id->cx; 665 struct cx18_stream *s = &cx->streams[id->type]; 666 int eof = test_bit(CX18_F_S_STREAMOFF, &s->s_flags); 667 668 if ((s->vb_type == V4L2_BUF_TYPE_VIDEO_CAPTURE) && 669 (id->type == CX18_ENC_STREAM_TYPE_YUV)) { 670 671 /* Start a capture if there is none */ 672 if (!eof && !test_bit(CX18_F_S_STREAMING, &s->s_flags)) { 673 int rc; 674 675 mutex_lock(&cx->serialize_lock); 676 rc = cx18_start_capture(id); 677 mutex_unlock(&cx->serialize_lock); 678 if (rc) { 679 CX18_DEBUG_INFO( 680 "Could not start capture for %s (%d)\n", 681 s->name, rc); 682 return -EINVAL; 683 } 684 CX18_DEBUG_FILE("Encoder mmap started capture\n"); 685 } 686 687 return videobuf_mmap_mapper(&s->vbuf_q, vma); 688 } 689 690 return -EINVAL; 691 } 692 693 void cx18_vb_timeout(unsigned long data) 694 { 695 struct cx18_stream *s = (struct cx18_stream *)data; 696 struct cx18_videobuf_buffer *buf; 697 unsigned long flags; 698 699 /* Return all of the buffers in error state, so the vbi/vid inode 700 * can return from blocking. 701 */ 702 spin_lock_irqsave(&s->vb_lock, flags); 703 while (!list_empty(&s->vb_capture)) { 704 buf = list_entry(s->vb_capture.next, 705 struct cx18_videobuf_buffer, vb.queue); 706 list_del(&buf->vb.queue); 707 buf->vb.state = VIDEOBUF_ERROR; 708 wake_up(&buf->vb.done); 709 } 710 spin_unlock_irqrestore(&s->vb_lock, flags); 711 } 712 713 void cx18_stop_capture(struct cx18_open_id *id, int gop_end) 714 { 715 struct cx18 *cx = id->cx; 716 struct cx18_stream *s = &cx->streams[id->type]; 717 struct cx18_stream *s_vbi = &cx->streams[CX18_ENC_STREAM_TYPE_VBI]; 718 struct cx18_stream *s_idx = &cx->streams[CX18_ENC_STREAM_TYPE_IDX]; 719 720 CX18_DEBUG_IOCTL("close() of %s\n", s->name); 721 722 /* 'Unclaim' this stream */ 723 724 /* Stop capturing */ 725 if (test_bit(CX18_F_S_STREAMING, &s->s_flags)) { 726 CX18_DEBUG_INFO("close stopping capture\n"); 727 if (id->type == CX18_ENC_STREAM_TYPE_MPG) { 728 /* Stop internal use associated VBI and IDX streams */ 729 if (test_bit(CX18_F_S_STREAMING, &s_vbi->s_flags) && 730 !test_bit(CX18_F_S_APPL_IO, &s_vbi->s_flags)) { 731 CX18_DEBUG_INFO("close stopping embedded VBI " 732 "capture\n"); 733 cx18_stop_v4l2_encode_stream(s_vbi, 0); 734 } 735 if (test_bit(CX18_F_S_STREAMING, &s_idx->s_flags)) { 736 CX18_DEBUG_INFO("close stopping IDX capture\n"); 737 cx18_stop_v4l2_encode_stream(s_idx, 0); 738 } 739 } 740 if (id->type == CX18_ENC_STREAM_TYPE_VBI && 741 test_bit(CX18_F_S_INTERNAL_USE, &s->s_flags)) 742 /* Also used internally, don't stop capturing */ 743 s->id = -1; 744 else 745 cx18_stop_v4l2_encode_stream(s, gop_end); 746 } 747 if (!gop_end) { 748 clear_bit(CX18_F_S_APPL_IO, &s->s_flags); 749 clear_bit(CX18_F_S_STREAMOFF, &s->s_flags); 750 cx18_release_stream(s); 751 } 752 } 753 754 int cx18_v4l2_close(struct file *filp) 755 { 756 struct v4l2_fh *fh = filp->private_data; 757 struct cx18_open_id *id = fh2id(fh); 758 struct cx18 *cx = id->cx; 759 struct cx18_stream *s = &cx->streams[id->type]; 760 761 CX18_DEBUG_IOCTL("close() of %s\n", s->name); 762 763 mutex_lock(&cx->serialize_lock); 764 /* Stop radio */ 765 if (id->type == CX18_ENC_STREAM_TYPE_RAD && 766 v4l2_fh_is_singular_file(filp)) { 767 /* Closing radio device, return to TV mode */ 768 cx18_mute(cx); 769 /* Mark that the radio is no longer in use */ 770 clear_bit(CX18_F_I_RADIO_USER, &cx->i_flags); 771 /* Switch tuner to TV */ 772 cx18_call_all(cx, video, s_std, cx->std); 773 /* Select correct audio input (i.e. TV tuner or Line in) */ 774 cx18_audio_set_io(cx); 775 if (atomic_read(&cx->ana_capturing) > 0) { 776 /* Undo video mute */ 777 cx18_vapi(cx, CX18_CPU_SET_VIDEO_MUTE, 2, s->handle, 778 (v4l2_ctrl_g_ctrl(cx->cxhdl.video_mute) | 779 (v4l2_ctrl_g_ctrl(cx->cxhdl.video_mute_yuv) << 8))); 780 } 781 /* Done! Unmute and continue. */ 782 cx18_unmute(cx); 783 } 784 785 v4l2_fh_del(fh); 786 v4l2_fh_exit(fh); 787 788 /* 'Unclaim' this stream */ 789 if (s->id == id->open_id) 790 cx18_stop_capture(id, 0); 791 kfree(id); 792 mutex_unlock(&cx->serialize_lock); 793 return 0; 794 } 795 796 static int cx18_serialized_open(struct cx18_stream *s, struct file *filp) 797 { 798 struct cx18 *cx = s->cx; 799 struct cx18_open_id *item; 800 801 CX18_DEBUG_FILE("open %s\n", s->name); 802 803 /* Allocate memory */ 804 item = kzalloc(sizeof(struct cx18_open_id), GFP_KERNEL); 805 if (NULL == item) { 806 CX18_DEBUG_WARN("nomem on v4l2 open\n"); 807 return -ENOMEM; 808 } 809 v4l2_fh_init(&item->fh, &s->video_dev); 810 811 item->cx = cx; 812 item->type = s->type; 813 814 item->open_id = cx->open_id++; 815 filp->private_data = &item->fh; 816 v4l2_fh_add(&item->fh); 817 818 if (item->type == CX18_ENC_STREAM_TYPE_RAD && 819 v4l2_fh_is_singular_file(filp)) { 820 if (!test_bit(CX18_F_I_RADIO_USER, &cx->i_flags)) { 821 if (atomic_read(&cx->ana_capturing) > 0) { 822 /* switching to radio while capture is 823 in progress is not polite */ 824 v4l2_fh_del(&item->fh); 825 v4l2_fh_exit(&item->fh); 826 kfree(item); 827 return -EBUSY; 828 } 829 } 830 831 /* Mark that the radio is being used. */ 832 set_bit(CX18_F_I_RADIO_USER, &cx->i_flags); 833 /* We have the radio */ 834 cx18_mute(cx); 835 /* Switch tuner to radio */ 836 cx18_call_all(cx, tuner, s_radio); 837 /* Select the correct audio input (i.e. radio tuner) */ 838 cx18_audio_set_io(cx); 839 /* Done! Unmute and continue. */ 840 cx18_unmute(cx); 841 } 842 return 0; 843 } 844 845 int cx18_v4l2_open(struct file *filp) 846 { 847 int res; 848 struct video_device *video_dev = video_devdata(filp); 849 struct cx18_stream *s = video_get_drvdata(video_dev); 850 struct cx18 *cx = s->cx; 851 852 mutex_lock(&cx->serialize_lock); 853 if (cx18_init_on_first_open(cx)) { 854 CX18_ERR("Failed to initialize on %s\n", 855 video_device_node_name(video_dev)); 856 mutex_unlock(&cx->serialize_lock); 857 return -ENXIO; 858 } 859 res = cx18_serialized_open(s, filp); 860 mutex_unlock(&cx->serialize_lock); 861 return res; 862 } 863 864 void cx18_mute(struct cx18 *cx) 865 { 866 u32 h; 867 if (atomic_read(&cx->ana_capturing)) { 868 h = cx18_find_handle(cx); 869 if (h != CX18_INVALID_TASK_HANDLE) 870 cx18_vapi(cx, CX18_CPU_SET_AUDIO_MUTE, 2, h, 1); 871 else 872 CX18_ERR("Can't find valid task handle for mute\n"); 873 } 874 CX18_DEBUG_INFO("Mute\n"); 875 } 876 877 void cx18_unmute(struct cx18 *cx) 878 { 879 u32 h; 880 if (atomic_read(&cx->ana_capturing)) { 881 h = cx18_find_handle(cx); 882 if (h != CX18_INVALID_TASK_HANDLE) { 883 cx18_msleep_timeout(100, 0); 884 cx18_vapi(cx, CX18_CPU_SET_MISC_PARAMETERS, 2, h, 12); 885 cx18_vapi(cx, CX18_CPU_SET_AUDIO_MUTE, 2, h, 0); 886 } else 887 CX18_ERR("Can't find valid task handle for unmute\n"); 888 } 889 CX18_DEBUG_INFO("Unmute\n"); 890 } 891