1 /* 2 * cx18 ioctl system call 3 * 4 * Derived from ivtv-ioctl.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-io.h" 27 #include "cx18-version.h" 28 #include "cx18-mailbox.h" 29 #include "cx18-i2c.h" 30 #include "cx18-queue.h" 31 #include "cx18-fileops.h" 32 #include "cx18-vbi.h" 33 #include "cx18-audio.h" 34 #include "cx18-video.h" 35 #include "cx18-streams.h" 36 #include "cx18-ioctl.h" 37 #include "cx18-gpio.h" 38 #include "cx18-controls.h" 39 #include "cx18-cards.h" 40 #include "cx18-av-core.h" 41 #include <media/tveeprom.h> 42 43 u16 cx18_service2vbi(int type) 44 { 45 switch (type) { 46 case V4L2_SLICED_TELETEXT_B: 47 return CX18_SLICED_TYPE_TELETEXT_B; 48 case V4L2_SLICED_CAPTION_525: 49 return CX18_SLICED_TYPE_CAPTION_525; 50 case V4L2_SLICED_WSS_625: 51 return CX18_SLICED_TYPE_WSS_625; 52 case V4L2_SLICED_VPS: 53 return CX18_SLICED_TYPE_VPS; 54 default: 55 return 0; 56 } 57 } 58 59 /* Check if VBI services are allowed on the (field, line) for the video std */ 60 static int valid_service_line(int field, int line, int is_pal) 61 { 62 return (is_pal && line >= 6 && 63 ((field == 0 && line <= 23) || (field == 1 && line <= 22))) || 64 (!is_pal && line >= 10 && line < 22); 65 } 66 67 /* 68 * For a (field, line, std) and inbound potential set of services for that line, 69 * return the first valid service of those passed in the incoming set for that 70 * line in priority order: 71 * CC, VPS, or WSS over TELETEXT for well known lines 72 * TELETEXT, before VPS, before CC, before WSS, for other lines 73 */ 74 static u16 select_service_from_set(int field, int line, u16 set, int is_pal) 75 { 76 u16 valid_set = (is_pal ? V4L2_SLICED_VBI_625 : V4L2_SLICED_VBI_525); 77 int i; 78 79 set = set & valid_set; 80 if (set == 0 || !valid_service_line(field, line, is_pal)) 81 return 0; 82 if (!is_pal) { 83 if (line == 21 && (set & V4L2_SLICED_CAPTION_525)) 84 return V4L2_SLICED_CAPTION_525; 85 } else { 86 if (line == 16 && field == 0 && (set & V4L2_SLICED_VPS)) 87 return V4L2_SLICED_VPS; 88 if (line == 23 && field == 0 && (set & V4L2_SLICED_WSS_625)) 89 return V4L2_SLICED_WSS_625; 90 if (line == 23) 91 return 0; 92 } 93 for (i = 0; i < 32; i++) { 94 if ((1 << i) & set) 95 return 1 << i; 96 } 97 return 0; 98 } 99 100 /* 101 * Expand the service_set of *fmt into valid service_lines for the std, 102 * and clear the passed in fmt->service_set 103 */ 104 void cx18_expand_service_set(struct v4l2_sliced_vbi_format *fmt, int is_pal) 105 { 106 u16 set = fmt->service_set; 107 int f, l; 108 109 fmt->service_set = 0; 110 for (f = 0; f < 2; f++) { 111 for (l = 0; l < 24; l++) 112 fmt->service_lines[f][l] = select_service_from_set(f, l, set, is_pal); 113 } 114 } 115 116 /* 117 * Sanitize the service_lines in *fmt per the video std, and return 1 118 * if any service_line is left as valid after santization 119 */ 120 static int check_service_set(struct v4l2_sliced_vbi_format *fmt, int is_pal) 121 { 122 int f, l; 123 u16 set = 0; 124 125 for (f = 0; f < 2; f++) { 126 for (l = 0; l < 24; l++) { 127 fmt->service_lines[f][l] = select_service_from_set(f, l, fmt->service_lines[f][l], is_pal); 128 set |= fmt->service_lines[f][l]; 129 } 130 } 131 return set != 0; 132 } 133 134 /* Compute the service_set from the assumed valid service_lines of *fmt */ 135 u16 cx18_get_service_set(struct v4l2_sliced_vbi_format *fmt) 136 { 137 int f, l; 138 u16 set = 0; 139 140 for (f = 0; f < 2; f++) { 141 for (l = 0; l < 24; l++) 142 set |= fmt->service_lines[f][l]; 143 } 144 return set; 145 } 146 147 static int cx18_g_fmt_vid_cap(struct file *file, void *fh, 148 struct v4l2_format *fmt) 149 { 150 struct cx18_open_id *id = fh2id(fh); 151 struct cx18 *cx = id->cx; 152 struct cx18_stream *s = &cx->streams[id->type]; 153 struct v4l2_pix_format *pixfmt = &fmt->fmt.pix; 154 155 pixfmt->width = cx->cxhdl.width; 156 pixfmt->height = cx->cxhdl.height; 157 pixfmt->colorspace = V4L2_COLORSPACE_SMPTE170M; 158 pixfmt->field = V4L2_FIELD_INTERLACED; 159 if (id->type == CX18_ENC_STREAM_TYPE_YUV) { 160 pixfmt->pixelformat = s->pixelformat; 161 pixfmt->sizeimage = s->vb_bytes_per_frame; 162 pixfmt->bytesperline = 720; 163 } else { 164 pixfmt->pixelformat = V4L2_PIX_FMT_MPEG; 165 pixfmt->sizeimage = 128 * 1024; 166 pixfmt->bytesperline = 0; 167 } 168 return 0; 169 } 170 171 static int cx18_g_fmt_vbi_cap(struct file *file, void *fh, 172 struct v4l2_format *fmt) 173 { 174 struct cx18 *cx = fh2id(fh)->cx; 175 struct v4l2_vbi_format *vbifmt = &fmt->fmt.vbi; 176 177 vbifmt->sampling_rate = 27000000; 178 vbifmt->offset = 248; /* FIXME - slightly wrong for both 50 & 60 Hz */ 179 vbifmt->samples_per_line = vbi_active_samples - 4; 180 vbifmt->sample_format = V4L2_PIX_FMT_GREY; 181 vbifmt->start[0] = cx->vbi.start[0]; 182 vbifmt->start[1] = cx->vbi.start[1]; 183 vbifmt->count[0] = vbifmt->count[1] = cx->vbi.count; 184 vbifmt->flags = 0; 185 vbifmt->reserved[0] = 0; 186 vbifmt->reserved[1] = 0; 187 return 0; 188 } 189 190 static int cx18_g_fmt_sliced_vbi_cap(struct file *file, void *fh, 191 struct v4l2_format *fmt) 192 { 193 struct cx18 *cx = fh2id(fh)->cx; 194 struct v4l2_sliced_vbi_format *vbifmt = &fmt->fmt.sliced; 195 196 /* sane, V4L2 spec compliant, defaults */ 197 vbifmt->reserved[0] = 0; 198 vbifmt->reserved[1] = 0; 199 vbifmt->io_size = sizeof(struct v4l2_sliced_vbi_data) * 36; 200 memset(vbifmt->service_lines, 0, sizeof(vbifmt->service_lines)); 201 vbifmt->service_set = 0; 202 203 /* 204 * Fetch the configured service_lines and total service_set from the 205 * digitizer/slicer. Note, cx18_av_vbi() wipes the passed in 206 * fmt->fmt.sliced under valid calling conditions 207 */ 208 if (v4l2_subdev_call(cx->sd_av, vbi, g_sliced_fmt, &fmt->fmt.sliced)) 209 return -EINVAL; 210 211 vbifmt->service_set = cx18_get_service_set(vbifmt); 212 return 0; 213 } 214 215 static int cx18_try_fmt_vid_cap(struct file *file, void *fh, 216 struct v4l2_format *fmt) 217 { 218 struct cx18_open_id *id = fh2id(fh); 219 struct cx18 *cx = id->cx; 220 int w = fmt->fmt.pix.width; 221 int h = fmt->fmt.pix.height; 222 int min_h = 2; 223 224 w = min(w, 720); 225 w = max(w, 2); 226 if (id->type == CX18_ENC_STREAM_TYPE_YUV) { 227 /* YUV height must be a multiple of 32 */ 228 h &= ~0x1f; 229 min_h = 32; 230 } 231 h = min(h, cx->is_50hz ? 576 : 480); 232 h = max(h, min_h); 233 234 fmt->fmt.pix.width = w; 235 fmt->fmt.pix.height = h; 236 return 0; 237 } 238 239 static int cx18_try_fmt_vbi_cap(struct file *file, void *fh, 240 struct v4l2_format *fmt) 241 { 242 return cx18_g_fmt_vbi_cap(file, fh, fmt); 243 } 244 245 static int cx18_try_fmt_sliced_vbi_cap(struct file *file, void *fh, 246 struct v4l2_format *fmt) 247 { 248 struct cx18 *cx = fh2id(fh)->cx; 249 struct v4l2_sliced_vbi_format *vbifmt = &fmt->fmt.sliced; 250 251 vbifmt->io_size = sizeof(struct v4l2_sliced_vbi_data) * 36; 252 vbifmt->reserved[0] = 0; 253 vbifmt->reserved[1] = 0; 254 255 /* If given a service set, expand it validly & clear passed in set */ 256 if (vbifmt->service_set) 257 cx18_expand_service_set(vbifmt, cx->is_50hz); 258 /* Sanitize the service_lines, and compute the new set if any valid */ 259 if (check_service_set(vbifmt, cx->is_50hz)) 260 vbifmt->service_set = cx18_get_service_set(vbifmt); 261 return 0; 262 } 263 264 static int cx18_s_fmt_vid_cap(struct file *file, void *fh, 265 struct v4l2_format *fmt) 266 { 267 struct cx18_open_id *id = fh2id(fh); 268 struct cx18 *cx = id->cx; 269 struct v4l2_mbus_framefmt mbus_fmt; 270 struct cx18_stream *s = &cx->streams[id->type]; 271 int ret; 272 int w, h; 273 274 ret = cx18_try_fmt_vid_cap(file, fh, fmt); 275 if (ret) 276 return ret; 277 w = fmt->fmt.pix.width; 278 h = fmt->fmt.pix.height; 279 280 if (cx->cxhdl.width == w && cx->cxhdl.height == h && 281 s->pixelformat == fmt->fmt.pix.pixelformat) 282 return 0; 283 284 if (atomic_read(&cx->ana_capturing) > 0) 285 return -EBUSY; 286 287 s->pixelformat = fmt->fmt.pix.pixelformat; 288 /* HM12 YUV size is (Y=(h*720) + UV=(h*(720/2))) 289 UYUV YUV size is (Y=(h*720) + UV=(h*(720))) */ 290 if (s->pixelformat == V4L2_PIX_FMT_HM12) 291 s->vb_bytes_per_frame = h * 720 * 3 / 2; 292 else 293 s->vb_bytes_per_frame = h * 720 * 2; 294 295 mbus_fmt.width = cx->cxhdl.width = w; 296 mbus_fmt.height = cx->cxhdl.height = h; 297 mbus_fmt.code = MEDIA_BUS_FMT_FIXED; 298 v4l2_subdev_call(cx->sd_av, video, s_mbus_fmt, &mbus_fmt); 299 return cx18_g_fmt_vid_cap(file, fh, fmt); 300 } 301 302 static int cx18_s_fmt_vbi_cap(struct file *file, void *fh, 303 struct v4l2_format *fmt) 304 { 305 struct cx18_open_id *id = fh2id(fh); 306 struct cx18 *cx = id->cx; 307 int ret; 308 309 /* 310 * Changing the Encoder's Raw VBI parameters won't have any effect 311 * if any analog capture is ongoing 312 */ 313 if (!cx18_raw_vbi(cx) && atomic_read(&cx->ana_capturing) > 0) 314 return -EBUSY; 315 316 /* 317 * Set the digitizer registers for raw active VBI. 318 * Note cx18_av_vbi_wipes out a lot of the passed in fmt under valid 319 * calling conditions 320 */ 321 ret = v4l2_subdev_call(cx->sd_av, vbi, s_raw_fmt, &fmt->fmt.vbi); 322 if (ret) 323 return ret; 324 325 /* Store our new v4l2 (non-)sliced VBI state */ 326 cx->vbi.sliced_in->service_set = 0; 327 cx->vbi.in.type = V4L2_BUF_TYPE_VBI_CAPTURE; 328 329 return cx18_g_fmt_vbi_cap(file, fh, fmt); 330 } 331 332 static int cx18_s_fmt_sliced_vbi_cap(struct file *file, void *fh, 333 struct v4l2_format *fmt) 334 { 335 struct cx18_open_id *id = fh2id(fh); 336 struct cx18 *cx = id->cx; 337 int ret; 338 struct v4l2_sliced_vbi_format *vbifmt = &fmt->fmt.sliced; 339 340 cx18_try_fmt_sliced_vbi_cap(file, fh, fmt); 341 342 /* 343 * Changing the Encoder's Raw VBI parameters won't have any effect 344 * if any analog capture is ongoing 345 */ 346 if (cx18_raw_vbi(cx) && atomic_read(&cx->ana_capturing) > 0) 347 return -EBUSY; 348 349 /* 350 * Set the service_lines requested in the digitizer/slicer registers. 351 * Note, cx18_av_vbi() wipes some "impossible" service lines in the 352 * passed in fmt->fmt.sliced under valid calling conditions 353 */ 354 ret = v4l2_subdev_call(cx->sd_av, vbi, s_sliced_fmt, &fmt->fmt.sliced); 355 if (ret) 356 return ret; 357 /* Store our current v4l2 sliced VBI settings */ 358 cx->vbi.in.type = V4L2_BUF_TYPE_SLICED_VBI_CAPTURE; 359 memcpy(cx->vbi.sliced_in, vbifmt, sizeof(*cx->vbi.sliced_in)); 360 return 0; 361 } 362 363 #ifdef CONFIG_VIDEO_ADV_DEBUG 364 static int cx18_g_register(struct file *file, void *fh, 365 struct v4l2_dbg_register *reg) 366 { 367 struct cx18 *cx = fh2id(fh)->cx; 368 369 if (reg->reg & 0x3) 370 return -EINVAL; 371 if (reg->reg >= CX18_MEM_OFFSET + CX18_MEM_SIZE) 372 return -EINVAL; 373 reg->size = 4; 374 reg->val = cx18_read_enc(cx, reg->reg); 375 return 0; 376 } 377 378 static int cx18_s_register(struct file *file, void *fh, 379 const struct v4l2_dbg_register *reg) 380 { 381 struct cx18 *cx = fh2id(fh)->cx; 382 383 if (reg->reg & 0x3) 384 return -EINVAL; 385 if (reg->reg >= CX18_MEM_OFFSET + CX18_MEM_SIZE) 386 return -EINVAL; 387 cx18_write_enc(cx, reg->val, reg->reg); 388 return 0; 389 } 390 #endif 391 392 static int cx18_querycap(struct file *file, void *fh, 393 struct v4l2_capability *vcap) 394 { 395 struct cx18_open_id *id = fh2id(fh); 396 struct cx18_stream *s = video_drvdata(file); 397 struct cx18 *cx = id->cx; 398 399 strlcpy(vcap->driver, CX18_DRIVER_NAME, sizeof(vcap->driver)); 400 strlcpy(vcap->card, cx->card_name, sizeof(vcap->card)); 401 snprintf(vcap->bus_info, sizeof(vcap->bus_info), 402 "PCI:%s", pci_name(cx->pci_dev)); 403 vcap->capabilities = cx->v4l2_cap; /* capabilities */ 404 vcap->device_caps = s->v4l2_dev_caps; /* device capabilities */ 405 vcap->capabilities |= V4L2_CAP_DEVICE_CAPS; 406 return 0; 407 } 408 409 static int cx18_enumaudio(struct file *file, void *fh, struct v4l2_audio *vin) 410 { 411 struct cx18 *cx = fh2id(fh)->cx; 412 413 return cx18_get_audio_input(cx, vin->index, vin); 414 } 415 416 static int cx18_g_audio(struct file *file, void *fh, struct v4l2_audio *vin) 417 { 418 struct cx18 *cx = fh2id(fh)->cx; 419 420 vin->index = cx->audio_input; 421 return cx18_get_audio_input(cx, vin->index, vin); 422 } 423 424 static int cx18_s_audio(struct file *file, void *fh, const struct v4l2_audio *vout) 425 { 426 struct cx18 *cx = fh2id(fh)->cx; 427 428 if (vout->index >= cx->nof_audio_inputs) 429 return -EINVAL; 430 cx->audio_input = vout->index; 431 cx18_audio_set_io(cx); 432 return 0; 433 } 434 435 static int cx18_enum_input(struct file *file, void *fh, struct v4l2_input *vin) 436 { 437 struct cx18 *cx = fh2id(fh)->cx; 438 439 /* set it to defaults from our table */ 440 return cx18_get_input(cx, vin->index, vin); 441 } 442 443 static int cx18_cropcap(struct file *file, void *fh, 444 struct v4l2_cropcap *cropcap) 445 { 446 struct cx18 *cx = fh2id(fh)->cx; 447 448 if (cropcap->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) 449 return -EINVAL; 450 cropcap->bounds.top = cropcap->bounds.left = 0; 451 cropcap->bounds.width = 720; 452 cropcap->bounds.height = cx->is_50hz ? 576 : 480; 453 cropcap->pixelaspect.numerator = cx->is_50hz ? 59 : 10; 454 cropcap->pixelaspect.denominator = cx->is_50hz ? 54 : 11; 455 cropcap->defrect = cropcap->bounds; 456 return 0; 457 } 458 459 static int cx18_s_crop(struct file *file, void *fh, const struct v4l2_crop *crop) 460 { 461 struct cx18_open_id *id = fh2id(fh); 462 struct cx18 *cx = id->cx; 463 464 if (crop->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) 465 return -EINVAL; 466 CX18_DEBUG_WARN("VIDIOC_S_CROP not implemented\n"); 467 return -EINVAL; 468 } 469 470 static int cx18_g_crop(struct file *file, void *fh, struct v4l2_crop *crop) 471 { 472 struct cx18 *cx = fh2id(fh)->cx; 473 474 if (crop->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) 475 return -EINVAL; 476 CX18_DEBUG_WARN("VIDIOC_G_CROP not implemented\n"); 477 return -EINVAL; 478 } 479 480 static int cx18_enum_fmt_vid_cap(struct file *file, void *fh, 481 struct v4l2_fmtdesc *fmt) 482 { 483 static const struct v4l2_fmtdesc formats[] = { 484 { 0, V4L2_BUF_TYPE_VIDEO_CAPTURE, 0, 485 "HM12 (YUV 4:1:1)", V4L2_PIX_FMT_HM12, { 0, 0, 0, 0 } 486 }, 487 { 1, V4L2_BUF_TYPE_VIDEO_CAPTURE, V4L2_FMT_FLAG_COMPRESSED, 488 "MPEG", V4L2_PIX_FMT_MPEG, { 0, 0, 0, 0 } 489 }, 490 { 2, V4L2_BUF_TYPE_VIDEO_CAPTURE, 0, 491 "UYVY 4:2:2", V4L2_PIX_FMT_UYVY, { 0, 0, 0, 0 } 492 }, 493 }; 494 495 if (fmt->index > ARRAY_SIZE(formats) - 1) 496 return -EINVAL; 497 *fmt = formats[fmt->index]; 498 return 0; 499 } 500 501 static int cx18_g_input(struct file *file, void *fh, unsigned int *i) 502 { 503 struct cx18 *cx = fh2id(fh)->cx; 504 505 *i = cx->active_input; 506 return 0; 507 } 508 509 int cx18_s_input(struct file *file, void *fh, unsigned int inp) 510 { 511 struct cx18_open_id *id = fh2id(fh); 512 struct cx18 *cx = id->cx; 513 514 if (inp >= cx->nof_inputs) 515 return -EINVAL; 516 517 if (inp == cx->active_input) { 518 CX18_DEBUG_INFO("Input unchanged\n"); 519 return 0; 520 } 521 522 CX18_DEBUG_INFO("Changing input from %d to %d\n", 523 cx->active_input, inp); 524 525 cx->active_input = inp; 526 /* Set the audio input to whatever is appropriate for the input type. */ 527 cx->audio_input = cx->card->video_inputs[inp].audio_index; 528 529 /* prevent others from messing with the streams until 530 we're finished changing inputs. */ 531 cx18_mute(cx); 532 cx18_video_set_io(cx); 533 cx18_audio_set_io(cx); 534 cx18_unmute(cx); 535 return 0; 536 } 537 538 static int cx18_g_frequency(struct file *file, void *fh, 539 struct v4l2_frequency *vf) 540 { 541 struct cx18 *cx = fh2id(fh)->cx; 542 543 if (vf->tuner != 0) 544 return -EINVAL; 545 546 cx18_call_all(cx, tuner, g_frequency, vf); 547 return 0; 548 } 549 550 int cx18_s_frequency(struct file *file, void *fh, const struct v4l2_frequency *vf) 551 { 552 struct cx18_open_id *id = fh2id(fh); 553 struct cx18 *cx = id->cx; 554 555 if (vf->tuner != 0) 556 return -EINVAL; 557 558 cx18_mute(cx); 559 CX18_DEBUG_INFO("v4l2 ioctl: set frequency %d\n", vf->frequency); 560 cx18_call_all(cx, tuner, s_frequency, vf); 561 cx18_unmute(cx); 562 return 0; 563 } 564 565 static int cx18_g_std(struct file *file, void *fh, v4l2_std_id *std) 566 { 567 struct cx18 *cx = fh2id(fh)->cx; 568 569 *std = cx->std; 570 return 0; 571 } 572 573 int cx18_s_std(struct file *file, void *fh, v4l2_std_id std) 574 { 575 struct cx18_open_id *id = fh2id(fh); 576 struct cx18 *cx = id->cx; 577 578 if ((std & V4L2_STD_ALL) == 0) 579 return -EINVAL; 580 581 if (std == cx->std) 582 return 0; 583 584 if (test_bit(CX18_F_I_RADIO_USER, &cx->i_flags) || 585 atomic_read(&cx->ana_capturing) > 0) { 586 /* Switching standard would turn off the radio or mess 587 with already running streams, prevent that by 588 returning EBUSY. */ 589 return -EBUSY; 590 } 591 592 cx->std = std; 593 cx->is_60hz = (std & V4L2_STD_525_60) ? 1 : 0; 594 cx->is_50hz = !cx->is_60hz; 595 cx2341x_handler_set_50hz(&cx->cxhdl, cx->is_50hz); 596 cx->cxhdl.width = 720; 597 cx->cxhdl.height = cx->is_50hz ? 576 : 480; 598 cx->vbi.count = cx->is_50hz ? 18 : 12; 599 cx->vbi.start[0] = cx->is_50hz ? 6 : 10; 600 cx->vbi.start[1] = cx->is_50hz ? 318 : 273; 601 CX18_DEBUG_INFO("Switching standard to %llx.\n", 602 (unsigned long long) cx->std); 603 604 /* Tuner */ 605 cx18_call_all(cx, video, s_std, cx->std); 606 return 0; 607 } 608 609 static int cx18_s_tuner(struct file *file, void *fh, const struct v4l2_tuner *vt) 610 { 611 struct cx18_open_id *id = fh2id(fh); 612 struct cx18 *cx = id->cx; 613 614 if (vt->index != 0) 615 return -EINVAL; 616 617 cx18_call_all(cx, tuner, s_tuner, vt); 618 return 0; 619 } 620 621 static int cx18_g_tuner(struct file *file, void *fh, struct v4l2_tuner *vt) 622 { 623 struct cx18 *cx = fh2id(fh)->cx; 624 625 if (vt->index != 0) 626 return -EINVAL; 627 628 cx18_call_all(cx, tuner, g_tuner, vt); 629 630 if (vt->type == V4L2_TUNER_RADIO) 631 strlcpy(vt->name, "cx18 Radio Tuner", sizeof(vt->name)); 632 else 633 strlcpy(vt->name, "cx18 TV Tuner", sizeof(vt->name)); 634 return 0; 635 } 636 637 static int cx18_g_sliced_vbi_cap(struct file *file, void *fh, 638 struct v4l2_sliced_vbi_cap *cap) 639 { 640 struct cx18 *cx = fh2id(fh)->cx; 641 int set = cx->is_50hz ? V4L2_SLICED_VBI_625 : V4L2_SLICED_VBI_525; 642 int f, l; 643 644 if (cap->type != V4L2_BUF_TYPE_SLICED_VBI_CAPTURE) 645 return -EINVAL; 646 647 cap->service_set = 0; 648 for (f = 0; f < 2; f++) { 649 for (l = 0; l < 24; l++) { 650 if (valid_service_line(f, l, cx->is_50hz)) { 651 /* 652 * We can find all v4l2 supported vbi services 653 * for the standard, on a valid line for the std 654 */ 655 cap->service_lines[f][l] = set; 656 cap->service_set |= set; 657 } else 658 cap->service_lines[f][l] = 0; 659 } 660 } 661 for (f = 0; f < 3; f++) 662 cap->reserved[f] = 0; 663 return 0; 664 } 665 666 static int _cx18_process_idx_data(struct cx18_buffer *buf, 667 struct v4l2_enc_idx *idx) 668 { 669 int consumed, remaining; 670 struct v4l2_enc_idx_entry *e_idx; 671 struct cx18_enc_idx_entry *e_buf; 672 673 /* Frame type lookup: 1=I, 2=P, 4=B */ 674 const int mapping[8] = { 675 -1, V4L2_ENC_IDX_FRAME_I, V4L2_ENC_IDX_FRAME_P, 676 -1, V4L2_ENC_IDX_FRAME_B, -1, -1, -1 677 }; 678 679 /* 680 * Assumption here is that a buf holds an integral number of 681 * struct cx18_enc_idx_entry objects and is properly aligned. 682 * This is enforced by the module options on IDX buffer sizes. 683 */ 684 remaining = buf->bytesused - buf->readpos; 685 consumed = 0; 686 e_idx = &idx->entry[idx->entries]; 687 e_buf = (struct cx18_enc_idx_entry *) &buf->buf[buf->readpos]; 688 689 while (remaining >= sizeof(struct cx18_enc_idx_entry) && 690 idx->entries < V4L2_ENC_IDX_ENTRIES) { 691 692 e_idx->offset = (((u64) le32_to_cpu(e_buf->offset_high)) << 32) 693 | le32_to_cpu(e_buf->offset_low); 694 695 e_idx->pts = (((u64) (le32_to_cpu(e_buf->pts_high) & 1)) << 32) 696 | le32_to_cpu(e_buf->pts_low); 697 698 e_idx->length = le32_to_cpu(e_buf->length); 699 700 e_idx->flags = mapping[le32_to_cpu(e_buf->flags) & 0x7]; 701 702 e_idx->reserved[0] = 0; 703 e_idx->reserved[1] = 0; 704 705 idx->entries++; 706 e_idx = &idx->entry[idx->entries]; 707 e_buf++; 708 709 remaining -= sizeof(struct cx18_enc_idx_entry); 710 consumed += sizeof(struct cx18_enc_idx_entry); 711 } 712 713 /* Swallow any partial entries at the end, if there are any */ 714 if (remaining > 0 && remaining < sizeof(struct cx18_enc_idx_entry)) 715 consumed += remaining; 716 717 buf->readpos += consumed; 718 return consumed; 719 } 720 721 static int cx18_process_idx_data(struct cx18_stream *s, struct cx18_mdl *mdl, 722 struct v4l2_enc_idx *idx) 723 { 724 if (s->type != CX18_ENC_STREAM_TYPE_IDX) 725 return -EINVAL; 726 727 if (mdl->curr_buf == NULL) 728 mdl->curr_buf = list_first_entry(&mdl->buf_list, 729 struct cx18_buffer, list); 730 731 if (list_entry_is_past_end(mdl->curr_buf, &mdl->buf_list, list)) { 732 /* 733 * For some reason we've exhausted the buffers, but the MDL 734 * object still said some data was unread. 735 * Fix that and bail out. 736 */ 737 mdl->readpos = mdl->bytesused; 738 return 0; 739 } 740 741 list_for_each_entry_from(mdl->curr_buf, &mdl->buf_list, list) { 742 743 /* Skip any empty buffers in the MDL */ 744 if (mdl->curr_buf->readpos >= mdl->curr_buf->bytesused) 745 continue; 746 747 mdl->readpos += _cx18_process_idx_data(mdl->curr_buf, idx); 748 749 /* exit when MDL drained or request satisfied */ 750 if (idx->entries >= V4L2_ENC_IDX_ENTRIES || 751 mdl->curr_buf->readpos < mdl->curr_buf->bytesused || 752 mdl->readpos >= mdl->bytesused) 753 break; 754 } 755 return 0; 756 } 757 758 static int cx18_g_enc_index(struct file *file, void *fh, 759 struct v4l2_enc_idx *idx) 760 { 761 struct cx18 *cx = fh2id(fh)->cx; 762 struct cx18_stream *s = &cx->streams[CX18_ENC_STREAM_TYPE_IDX]; 763 s32 tmp; 764 struct cx18_mdl *mdl; 765 766 if (!cx18_stream_enabled(s)) /* Module options inhibited IDX stream */ 767 return -EINVAL; 768 769 /* Compute the best case number of entries we can buffer */ 770 tmp = s->buffers - 771 s->bufs_per_mdl * CX18_ENC_STREAM_TYPE_IDX_FW_MDL_MIN; 772 if (tmp <= 0) 773 tmp = 1; 774 tmp = tmp * s->buf_size / sizeof(struct cx18_enc_idx_entry); 775 776 /* Fill out the header of the return structure */ 777 idx->entries = 0; 778 idx->entries_cap = tmp; 779 memset(idx->reserved, 0, sizeof(idx->reserved)); 780 781 /* Pull IDX MDLs and buffers from q_full and populate the entries */ 782 do { 783 mdl = cx18_dequeue(s, &s->q_full); 784 if (mdl == NULL) /* No more IDX data right now */ 785 break; 786 787 /* Extract the Index entry data from the MDL and buffers */ 788 cx18_process_idx_data(s, mdl, idx); 789 if (mdl->readpos < mdl->bytesused) { 790 /* We finished with data remaining, push the MDL back */ 791 cx18_push(s, mdl, &s->q_full); 792 break; 793 } 794 795 /* We drained this MDL, schedule it to go to the firmware */ 796 cx18_enqueue(s, mdl, &s->q_free); 797 798 } while (idx->entries < V4L2_ENC_IDX_ENTRIES); 799 800 /* Tell the work handler to send free IDX MDLs to the firmware */ 801 cx18_stream_load_fw_queue(s); 802 return 0; 803 } 804 805 static struct videobuf_queue *cx18_vb_queue(struct cx18_open_id *id) 806 { 807 struct videobuf_queue *q = NULL; 808 struct cx18 *cx = id->cx; 809 struct cx18_stream *s = &cx->streams[id->type]; 810 811 switch (s->vb_type) { 812 case V4L2_BUF_TYPE_VIDEO_CAPTURE: 813 q = &s->vbuf_q; 814 break; 815 case V4L2_BUF_TYPE_VBI_CAPTURE: 816 break; 817 default: 818 break; 819 } 820 return q; 821 } 822 823 static int cx18_streamon(struct file *file, void *priv, 824 enum v4l2_buf_type type) 825 { 826 struct cx18_open_id *id = file->private_data; 827 struct cx18 *cx = id->cx; 828 struct cx18_stream *s = &cx->streams[id->type]; 829 830 /* Start the hardware only if we're the video device */ 831 if ((s->vb_type != V4L2_BUF_TYPE_VIDEO_CAPTURE) && 832 (s->vb_type != V4L2_BUF_TYPE_VBI_CAPTURE)) 833 return -EINVAL; 834 835 if (id->type != CX18_ENC_STREAM_TYPE_YUV) 836 return -EINVAL; 837 838 /* Establish a buffer timeout */ 839 mod_timer(&s->vb_timeout, msecs_to_jiffies(2000) + jiffies); 840 841 return videobuf_streamon(cx18_vb_queue(id)); 842 } 843 844 static int cx18_streamoff(struct file *file, void *priv, 845 enum v4l2_buf_type type) 846 { 847 struct cx18_open_id *id = file->private_data; 848 struct cx18 *cx = id->cx; 849 struct cx18_stream *s = &cx->streams[id->type]; 850 851 /* Start the hardware only if we're the video device */ 852 if ((s->vb_type != V4L2_BUF_TYPE_VIDEO_CAPTURE) && 853 (s->vb_type != V4L2_BUF_TYPE_VBI_CAPTURE)) 854 return -EINVAL; 855 856 if (id->type != CX18_ENC_STREAM_TYPE_YUV) 857 return -EINVAL; 858 859 return videobuf_streamoff(cx18_vb_queue(id)); 860 } 861 862 static int cx18_reqbufs(struct file *file, void *priv, 863 struct v4l2_requestbuffers *rb) 864 { 865 struct cx18_open_id *id = file->private_data; 866 struct cx18 *cx = id->cx; 867 struct cx18_stream *s = &cx->streams[id->type]; 868 869 if ((s->vb_type != V4L2_BUF_TYPE_VIDEO_CAPTURE) && 870 (s->vb_type != V4L2_BUF_TYPE_VBI_CAPTURE)) 871 return -EINVAL; 872 873 return videobuf_reqbufs(cx18_vb_queue(id), rb); 874 } 875 876 static int cx18_querybuf(struct file *file, void *priv, 877 struct v4l2_buffer *b) 878 { 879 struct cx18_open_id *id = file->private_data; 880 struct cx18 *cx = id->cx; 881 struct cx18_stream *s = &cx->streams[id->type]; 882 883 if ((s->vb_type != V4L2_BUF_TYPE_VIDEO_CAPTURE) && 884 (s->vb_type != V4L2_BUF_TYPE_VBI_CAPTURE)) 885 return -EINVAL; 886 887 return videobuf_querybuf(cx18_vb_queue(id), b); 888 } 889 890 static int cx18_qbuf(struct file *file, void *priv, struct v4l2_buffer *b) 891 { 892 struct cx18_open_id *id = file->private_data; 893 struct cx18 *cx = id->cx; 894 struct cx18_stream *s = &cx->streams[id->type]; 895 896 if ((s->vb_type != V4L2_BUF_TYPE_VIDEO_CAPTURE) && 897 (s->vb_type != V4L2_BUF_TYPE_VBI_CAPTURE)) 898 return -EINVAL; 899 900 return videobuf_qbuf(cx18_vb_queue(id), b); 901 } 902 903 static int cx18_dqbuf(struct file *file, void *priv, struct v4l2_buffer *b) 904 { 905 struct cx18_open_id *id = file->private_data; 906 struct cx18 *cx = id->cx; 907 struct cx18_stream *s = &cx->streams[id->type]; 908 909 if ((s->vb_type != V4L2_BUF_TYPE_VIDEO_CAPTURE) && 910 (s->vb_type != V4L2_BUF_TYPE_VBI_CAPTURE)) 911 return -EINVAL; 912 913 return videobuf_dqbuf(cx18_vb_queue(id), b, file->f_flags & O_NONBLOCK); 914 } 915 916 static int cx18_encoder_cmd(struct file *file, void *fh, 917 struct v4l2_encoder_cmd *enc) 918 { 919 struct cx18_open_id *id = fh2id(fh); 920 struct cx18 *cx = id->cx; 921 u32 h; 922 923 switch (enc->cmd) { 924 case V4L2_ENC_CMD_START: 925 CX18_DEBUG_IOCTL("V4L2_ENC_CMD_START\n"); 926 enc->flags = 0; 927 return cx18_start_capture(id); 928 929 case V4L2_ENC_CMD_STOP: 930 CX18_DEBUG_IOCTL("V4L2_ENC_CMD_STOP\n"); 931 enc->flags &= V4L2_ENC_CMD_STOP_AT_GOP_END; 932 cx18_stop_capture(id, 933 enc->flags & V4L2_ENC_CMD_STOP_AT_GOP_END); 934 break; 935 936 case V4L2_ENC_CMD_PAUSE: 937 CX18_DEBUG_IOCTL("V4L2_ENC_CMD_PAUSE\n"); 938 enc->flags = 0; 939 if (!atomic_read(&cx->ana_capturing)) 940 return -EPERM; 941 if (test_and_set_bit(CX18_F_I_ENC_PAUSED, &cx->i_flags)) 942 return 0; 943 h = cx18_find_handle(cx); 944 if (h == CX18_INVALID_TASK_HANDLE) { 945 CX18_ERR("Can't find valid task handle for " 946 "V4L2_ENC_CMD_PAUSE\n"); 947 return -EBADFD; 948 } 949 cx18_mute(cx); 950 cx18_vapi(cx, CX18_CPU_CAPTURE_PAUSE, 1, h); 951 break; 952 953 case V4L2_ENC_CMD_RESUME: 954 CX18_DEBUG_IOCTL("V4L2_ENC_CMD_RESUME\n"); 955 enc->flags = 0; 956 if (!atomic_read(&cx->ana_capturing)) 957 return -EPERM; 958 if (!test_and_clear_bit(CX18_F_I_ENC_PAUSED, &cx->i_flags)) 959 return 0; 960 h = cx18_find_handle(cx); 961 if (h == CX18_INVALID_TASK_HANDLE) { 962 CX18_ERR("Can't find valid task handle for " 963 "V4L2_ENC_CMD_RESUME\n"); 964 return -EBADFD; 965 } 966 cx18_vapi(cx, CX18_CPU_CAPTURE_RESUME, 1, h); 967 cx18_unmute(cx); 968 break; 969 970 default: 971 CX18_DEBUG_IOCTL("Unknown cmd %d\n", enc->cmd); 972 return -EINVAL; 973 } 974 return 0; 975 } 976 977 static int cx18_try_encoder_cmd(struct file *file, void *fh, 978 struct v4l2_encoder_cmd *enc) 979 { 980 struct cx18 *cx = fh2id(fh)->cx; 981 982 switch (enc->cmd) { 983 case V4L2_ENC_CMD_START: 984 CX18_DEBUG_IOCTL("V4L2_ENC_CMD_START\n"); 985 enc->flags = 0; 986 break; 987 988 case V4L2_ENC_CMD_STOP: 989 CX18_DEBUG_IOCTL("V4L2_ENC_CMD_STOP\n"); 990 enc->flags &= V4L2_ENC_CMD_STOP_AT_GOP_END; 991 break; 992 993 case V4L2_ENC_CMD_PAUSE: 994 CX18_DEBUG_IOCTL("V4L2_ENC_CMD_PAUSE\n"); 995 enc->flags = 0; 996 break; 997 998 case V4L2_ENC_CMD_RESUME: 999 CX18_DEBUG_IOCTL("V4L2_ENC_CMD_RESUME\n"); 1000 enc->flags = 0; 1001 break; 1002 1003 default: 1004 CX18_DEBUG_IOCTL("Unknown cmd %d\n", enc->cmd); 1005 return -EINVAL; 1006 } 1007 return 0; 1008 } 1009 1010 static int cx18_log_status(struct file *file, void *fh) 1011 { 1012 struct cx18 *cx = fh2id(fh)->cx; 1013 struct v4l2_input vidin; 1014 struct v4l2_audio audin; 1015 int i; 1016 1017 CX18_INFO("Version: %s Card: %s\n", CX18_VERSION, cx->card_name); 1018 if (cx->hw_flags & CX18_HW_TVEEPROM) { 1019 struct tveeprom tv; 1020 1021 cx18_read_eeprom(cx, &tv); 1022 } 1023 cx18_call_all(cx, core, log_status); 1024 cx18_get_input(cx, cx->active_input, &vidin); 1025 cx18_get_audio_input(cx, cx->audio_input, &audin); 1026 CX18_INFO("Video Input: %s\n", vidin.name); 1027 CX18_INFO("Audio Input: %s\n", audin.name); 1028 mutex_lock(&cx->gpio_lock); 1029 CX18_INFO("GPIO: direction 0x%08x, value 0x%08x\n", 1030 cx->gpio_dir, cx->gpio_val); 1031 mutex_unlock(&cx->gpio_lock); 1032 CX18_INFO("Tuner: %s\n", 1033 test_bit(CX18_F_I_RADIO_USER, &cx->i_flags) ? "Radio" : "TV"); 1034 v4l2_ctrl_handler_log_status(&cx->cxhdl.hdl, cx->v4l2_dev.name); 1035 CX18_INFO("Status flags: 0x%08lx\n", cx->i_flags); 1036 for (i = 0; i < CX18_MAX_STREAMS; i++) { 1037 struct cx18_stream *s = &cx->streams[i]; 1038 1039 if (s->video_dev == NULL || s->buffers == 0) 1040 continue; 1041 CX18_INFO("Stream %s: status 0x%04lx, %d%% of %d KiB (%d buffers) in use\n", 1042 s->name, s->s_flags, 1043 atomic_read(&s->q_full.depth) * s->bufs_per_mdl * 100 1044 / s->buffers, 1045 (s->buffers * s->buf_size) / 1024, s->buffers); 1046 } 1047 CX18_INFO("Read MPEG/VBI: %lld/%lld bytes\n", 1048 (long long)cx->mpg_data_received, 1049 (long long)cx->vbi_data_inserted); 1050 return 0; 1051 } 1052 1053 static long cx18_default(struct file *file, void *fh, bool valid_prio, 1054 unsigned int cmd, void *arg) 1055 { 1056 struct cx18 *cx = fh2id(fh)->cx; 1057 1058 switch (cmd) { 1059 case VIDIOC_INT_RESET: { 1060 u32 val = *(u32 *)arg; 1061 1062 if ((val == 0) || (val & 0x01)) 1063 cx18_call_hw(cx, CX18_HW_GPIO_RESET_CTRL, core, reset, 1064 (u32) CX18_GPIO_RESET_Z8F0811); 1065 break; 1066 } 1067 1068 default: 1069 return -ENOTTY; 1070 } 1071 return 0; 1072 } 1073 1074 static const struct v4l2_ioctl_ops cx18_ioctl_ops = { 1075 .vidioc_querycap = cx18_querycap, 1076 .vidioc_s_audio = cx18_s_audio, 1077 .vidioc_g_audio = cx18_g_audio, 1078 .vidioc_enumaudio = cx18_enumaudio, 1079 .vidioc_enum_input = cx18_enum_input, 1080 .vidioc_cropcap = cx18_cropcap, 1081 .vidioc_s_crop = cx18_s_crop, 1082 .vidioc_g_crop = cx18_g_crop, 1083 .vidioc_g_input = cx18_g_input, 1084 .vidioc_s_input = cx18_s_input, 1085 .vidioc_g_frequency = cx18_g_frequency, 1086 .vidioc_s_frequency = cx18_s_frequency, 1087 .vidioc_s_tuner = cx18_s_tuner, 1088 .vidioc_g_tuner = cx18_g_tuner, 1089 .vidioc_g_enc_index = cx18_g_enc_index, 1090 .vidioc_g_std = cx18_g_std, 1091 .vidioc_s_std = cx18_s_std, 1092 .vidioc_log_status = cx18_log_status, 1093 .vidioc_enum_fmt_vid_cap = cx18_enum_fmt_vid_cap, 1094 .vidioc_encoder_cmd = cx18_encoder_cmd, 1095 .vidioc_try_encoder_cmd = cx18_try_encoder_cmd, 1096 .vidioc_g_fmt_vid_cap = cx18_g_fmt_vid_cap, 1097 .vidioc_g_fmt_vbi_cap = cx18_g_fmt_vbi_cap, 1098 .vidioc_g_fmt_sliced_vbi_cap = cx18_g_fmt_sliced_vbi_cap, 1099 .vidioc_s_fmt_vid_cap = cx18_s_fmt_vid_cap, 1100 .vidioc_s_fmt_vbi_cap = cx18_s_fmt_vbi_cap, 1101 .vidioc_s_fmt_sliced_vbi_cap = cx18_s_fmt_sliced_vbi_cap, 1102 .vidioc_try_fmt_vid_cap = cx18_try_fmt_vid_cap, 1103 .vidioc_try_fmt_vbi_cap = cx18_try_fmt_vbi_cap, 1104 .vidioc_try_fmt_sliced_vbi_cap = cx18_try_fmt_sliced_vbi_cap, 1105 .vidioc_g_sliced_vbi_cap = cx18_g_sliced_vbi_cap, 1106 #ifdef CONFIG_VIDEO_ADV_DEBUG 1107 .vidioc_g_register = cx18_g_register, 1108 .vidioc_s_register = cx18_s_register, 1109 #endif 1110 .vidioc_default = cx18_default, 1111 .vidioc_streamon = cx18_streamon, 1112 .vidioc_streamoff = cx18_streamoff, 1113 .vidioc_reqbufs = cx18_reqbufs, 1114 .vidioc_querybuf = cx18_querybuf, 1115 .vidioc_qbuf = cx18_qbuf, 1116 .vidioc_dqbuf = cx18_dqbuf, 1117 }; 1118 1119 void cx18_set_funcs(struct video_device *vdev) 1120 { 1121 vdev->ioctl_ops = &cx18_ioctl_ops; 1122 } 1123