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