1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * vivid-vid-out.c - video output support functions. 4 * 5 * Copyright 2014 Cisco Systems, Inc. and/or its affiliates. All rights reserved. 6 */ 7 8 #include <linux/errno.h> 9 #include <linux/kernel.h> 10 #include <linux/sched.h> 11 #include <linux/videodev2.h> 12 #include <linux/v4l2-dv-timings.h> 13 #include <media/v4l2-common.h> 14 #include <media/v4l2-event.h> 15 #include <media/v4l2-dv-timings.h> 16 #include <media/v4l2-rect.h> 17 18 #include "vivid-core.h" 19 #include "vivid-vid-common.h" 20 #include "vivid-kthread-out.h" 21 #include "vivid-vid-out.h" 22 23 static int vid_out_queue_setup(struct vb2_queue *vq, 24 unsigned *nbuffers, unsigned *nplanes, 25 unsigned sizes[], struct device *alloc_devs[]) 26 { 27 struct vivid_dev *dev = vb2_get_drv_priv(vq); 28 const struct vivid_fmt *vfmt = dev->fmt_out; 29 unsigned planes = vfmt->buffers; 30 unsigned h = dev->fmt_out_rect.height; 31 unsigned int size = dev->bytesperline_out[0] * h + vfmt->data_offset[0]; 32 unsigned p; 33 34 for (p = vfmt->buffers; p < vfmt->planes; p++) 35 size += dev->bytesperline_out[p] * h / vfmt->vdownsampling[p] + 36 vfmt->data_offset[p]; 37 38 if (dev->field_out == V4L2_FIELD_ALTERNATE) { 39 /* 40 * You cannot use write() with FIELD_ALTERNATE since the field 41 * information (TOP/BOTTOM) cannot be passed to the kernel. 42 */ 43 if (vb2_fileio_is_active(vq)) 44 return -EINVAL; 45 } 46 47 if (dev->queue_setup_error) { 48 /* 49 * Error injection: test what happens if queue_setup() returns 50 * an error. 51 */ 52 dev->queue_setup_error = false; 53 return -EINVAL; 54 } 55 56 if (*nplanes) { 57 /* 58 * Check if the number of requested planes match 59 * the number of planes in the current format. You can't mix that. 60 */ 61 if (*nplanes != planes) 62 return -EINVAL; 63 if (sizes[0] < size) 64 return -EINVAL; 65 for (p = 1; p < planes; p++) { 66 if (sizes[p] < dev->bytesperline_out[p] * h + 67 vfmt->data_offset[p]) 68 return -EINVAL; 69 } 70 } else { 71 for (p = 0; p < planes; p++) 72 sizes[p] = p ? dev->bytesperline_out[p] * h + 73 vfmt->data_offset[p] : size; 74 } 75 76 if (vq->num_buffers + *nbuffers < 2) 77 *nbuffers = 2 - vq->num_buffers; 78 79 *nplanes = planes; 80 81 dprintk(dev, 1, "%s: count=%d\n", __func__, *nbuffers); 82 for (p = 0; p < planes; p++) 83 dprintk(dev, 1, "%s: size[%u]=%u\n", __func__, p, sizes[p]); 84 return 0; 85 } 86 87 static int vid_out_buf_out_validate(struct vb2_buffer *vb) 88 { 89 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb); 90 struct vivid_dev *dev = vb2_get_drv_priv(vb->vb2_queue); 91 92 dprintk(dev, 1, "%s\n", __func__); 93 94 if (dev->field_out != V4L2_FIELD_ALTERNATE) 95 vbuf->field = dev->field_out; 96 else if (vbuf->field != V4L2_FIELD_TOP && 97 vbuf->field != V4L2_FIELD_BOTTOM) 98 return -EINVAL; 99 return 0; 100 } 101 102 static int vid_out_buf_prepare(struct vb2_buffer *vb) 103 { 104 struct vivid_dev *dev = vb2_get_drv_priv(vb->vb2_queue); 105 const struct vivid_fmt *vfmt = dev->fmt_out; 106 unsigned int planes = vfmt->buffers; 107 unsigned int h = dev->fmt_out_rect.height; 108 unsigned int size = dev->bytesperline_out[0] * h; 109 unsigned p; 110 111 for (p = vfmt->buffers; p < vfmt->planes; p++) 112 size += dev->bytesperline_out[p] * h / vfmt->vdownsampling[p]; 113 114 dprintk(dev, 1, "%s\n", __func__); 115 116 if (WARN_ON(NULL == dev->fmt_out)) 117 return -EINVAL; 118 119 if (dev->buf_prepare_error) { 120 /* 121 * Error injection: test what happens if buf_prepare() returns 122 * an error. 123 */ 124 dev->buf_prepare_error = false; 125 return -EINVAL; 126 } 127 128 for (p = 0; p < planes; p++) { 129 if (p) 130 size = dev->bytesperline_out[p] * h; 131 size += vb->planes[p].data_offset; 132 133 if (vb2_get_plane_payload(vb, p) < size) { 134 dprintk(dev, 1, "%s the payload is too small for plane %u (%lu < %u)\n", 135 __func__, p, vb2_get_plane_payload(vb, p), size); 136 return -EINVAL; 137 } 138 } 139 140 return 0; 141 } 142 143 static void vid_out_buf_queue(struct vb2_buffer *vb) 144 { 145 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb); 146 struct vivid_dev *dev = vb2_get_drv_priv(vb->vb2_queue); 147 struct vivid_buffer *buf = container_of(vbuf, struct vivid_buffer, vb); 148 149 dprintk(dev, 1, "%s\n", __func__); 150 151 spin_lock(&dev->slock); 152 list_add_tail(&buf->list, &dev->vid_out_active); 153 spin_unlock(&dev->slock); 154 } 155 156 static int vid_out_start_streaming(struct vb2_queue *vq, unsigned count) 157 { 158 struct vivid_dev *dev = vb2_get_drv_priv(vq); 159 int err; 160 161 if (vb2_is_streaming(&dev->vb_vid_cap_q)) 162 dev->can_loop_video = vivid_vid_can_loop(dev); 163 164 dev->vid_out_seq_count = 0; 165 dprintk(dev, 1, "%s\n", __func__); 166 if (dev->start_streaming_error) { 167 dev->start_streaming_error = false; 168 err = -EINVAL; 169 } else { 170 err = vivid_start_generating_vid_out(dev, &dev->vid_out_streaming); 171 } 172 if (err) { 173 struct vivid_buffer *buf, *tmp; 174 175 list_for_each_entry_safe(buf, tmp, &dev->vid_out_active, list) { 176 list_del(&buf->list); 177 vb2_buffer_done(&buf->vb.vb2_buf, 178 VB2_BUF_STATE_QUEUED); 179 } 180 } 181 return err; 182 } 183 184 /* abort streaming and wait for last buffer */ 185 static void vid_out_stop_streaming(struct vb2_queue *vq) 186 { 187 struct vivid_dev *dev = vb2_get_drv_priv(vq); 188 189 dprintk(dev, 1, "%s\n", __func__); 190 vivid_stop_generating_vid_out(dev, &dev->vid_out_streaming); 191 dev->can_loop_video = false; 192 } 193 194 static void vid_out_buf_request_complete(struct vb2_buffer *vb) 195 { 196 struct vivid_dev *dev = vb2_get_drv_priv(vb->vb2_queue); 197 198 v4l2_ctrl_request_complete(vb->req_obj.req, &dev->ctrl_hdl_vid_out); 199 } 200 201 const struct vb2_ops vivid_vid_out_qops = { 202 .queue_setup = vid_out_queue_setup, 203 .buf_out_validate = vid_out_buf_out_validate, 204 .buf_prepare = vid_out_buf_prepare, 205 .buf_queue = vid_out_buf_queue, 206 .start_streaming = vid_out_start_streaming, 207 .stop_streaming = vid_out_stop_streaming, 208 .buf_request_complete = vid_out_buf_request_complete, 209 .wait_prepare = vb2_ops_wait_prepare, 210 .wait_finish = vb2_ops_wait_finish, 211 }; 212 213 /* 214 * Called whenever the format has to be reset which can occur when 215 * changing outputs, standard, timings, etc. 216 */ 217 void vivid_update_format_out(struct vivid_dev *dev) 218 { 219 struct v4l2_bt_timings *bt = &dev->dv_timings_out.bt; 220 unsigned size, p; 221 u64 pixelclock; 222 223 switch (dev->output_type[dev->output]) { 224 case SVID: 225 default: 226 dev->field_out = dev->tv_field_out; 227 dev->sink_rect.width = 720; 228 if (dev->std_out & V4L2_STD_525_60) { 229 dev->sink_rect.height = 480; 230 dev->timeperframe_vid_out = (struct v4l2_fract) { 1001, 30000 }; 231 dev->service_set_out = V4L2_SLICED_CAPTION_525; 232 } else { 233 dev->sink_rect.height = 576; 234 dev->timeperframe_vid_out = (struct v4l2_fract) { 1000, 25000 }; 235 dev->service_set_out = V4L2_SLICED_WSS_625 | V4L2_SLICED_TELETEXT_B; 236 } 237 dev->colorspace_out = V4L2_COLORSPACE_SMPTE170M; 238 break; 239 case HDMI: 240 dev->sink_rect.width = bt->width; 241 dev->sink_rect.height = bt->height; 242 size = V4L2_DV_BT_FRAME_WIDTH(bt) * V4L2_DV_BT_FRAME_HEIGHT(bt); 243 244 if (can_reduce_fps(bt) && (bt->flags & V4L2_DV_FL_REDUCED_FPS)) 245 pixelclock = div_u64(bt->pixelclock * 1000, 1001); 246 else 247 pixelclock = bt->pixelclock; 248 249 dev->timeperframe_vid_out = (struct v4l2_fract) { 250 size / 100, (u32)pixelclock / 100 251 }; 252 if (bt->interlaced) 253 dev->field_out = V4L2_FIELD_ALTERNATE; 254 else 255 dev->field_out = V4L2_FIELD_NONE; 256 if (!dev->dvi_d_out && (bt->flags & V4L2_DV_FL_IS_CE_VIDEO)) { 257 if (bt->width == 720 && bt->height <= 576) 258 dev->colorspace_out = V4L2_COLORSPACE_SMPTE170M; 259 else 260 dev->colorspace_out = V4L2_COLORSPACE_REC709; 261 } else { 262 dev->colorspace_out = V4L2_COLORSPACE_SRGB; 263 } 264 break; 265 } 266 dev->xfer_func_out = V4L2_XFER_FUNC_DEFAULT; 267 dev->ycbcr_enc_out = V4L2_YCBCR_ENC_DEFAULT; 268 dev->hsv_enc_out = V4L2_HSV_ENC_180; 269 dev->quantization_out = V4L2_QUANTIZATION_DEFAULT; 270 dev->compose_out = dev->sink_rect; 271 dev->compose_bounds_out = dev->sink_rect; 272 dev->crop_out = dev->compose_out; 273 if (V4L2_FIELD_HAS_T_OR_B(dev->field_out)) 274 dev->crop_out.height /= 2; 275 dev->fmt_out_rect = dev->crop_out; 276 for (p = 0; p < dev->fmt_out->planes; p++) 277 dev->bytesperline_out[p] = 278 (dev->sink_rect.width * dev->fmt_out->bit_depth[p]) / 8; 279 } 280 281 /* Map the field to something that is valid for the current output */ 282 static enum v4l2_field vivid_field_out(struct vivid_dev *dev, enum v4l2_field field) 283 { 284 if (vivid_is_svid_out(dev)) { 285 switch (field) { 286 case V4L2_FIELD_INTERLACED_TB: 287 case V4L2_FIELD_INTERLACED_BT: 288 case V4L2_FIELD_SEQ_TB: 289 case V4L2_FIELD_SEQ_BT: 290 case V4L2_FIELD_ALTERNATE: 291 return field; 292 case V4L2_FIELD_INTERLACED: 293 default: 294 return V4L2_FIELD_INTERLACED; 295 } 296 } 297 if (vivid_is_hdmi_out(dev)) 298 return dev->dv_timings_out.bt.interlaced ? V4L2_FIELD_ALTERNATE : 299 V4L2_FIELD_NONE; 300 return V4L2_FIELD_NONE; 301 } 302 303 static enum tpg_pixel_aspect vivid_get_pixel_aspect(const struct vivid_dev *dev) 304 { 305 if (vivid_is_svid_out(dev)) 306 return (dev->std_out & V4L2_STD_525_60) ? 307 TPG_PIXEL_ASPECT_NTSC : TPG_PIXEL_ASPECT_PAL; 308 309 if (vivid_is_hdmi_out(dev) && 310 dev->sink_rect.width == 720 && dev->sink_rect.height <= 576) 311 return dev->sink_rect.height == 480 ? 312 TPG_PIXEL_ASPECT_NTSC : TPG_PIXEL_ASPECT_PAL; 313 314 return TPG_PIXEL_ASPECT_SQUARE; 315 } 316 317 int vivid_g_fmt_vid_out(struct file *file, void *priv, 318 struct v4l2_format *f) 319 { 320 struct vivid_dev *dev = video_drvdata(file); 321 struct v4l2_pix_format_mplane *mp = &f->fmt.pix_mp; 322 const struct vivid_fmt *fmt = dev->fmt_out; 323 unsigned p; 324 325 mp->width = dev->fmt_out_rect.width; 326 mp->height = dev->fmt_out_rect.height; 327 mp->field = dev->field_out; 328 mp->pixelformat = fmt->fourcc; 329 mp->colorspace = dev->colorspace_out; 330 mp->xfer_func = dev->xfer_func_out; 331 mp->ycbcr_enc = dev->ycbcr_enc_out; 332 mp->quantization = dev->quantization_out; 333 mp->num_planes = fmt->buffers; 334 for (p = 0; p < mp->num_planes; p++) { 335 mp->plane_fmt[p].bytesperline = dev->bytesperline_out[p]; 336 mp->plane_fmt[p].sizeimage = 337 mp->plane_fmt[p].bytesperline * mp->height + 338 fmt->data_offset[p]; 339 } 340 for (p = fmt->buffers; p < fmt->planes; p++) { 341 unsigned stride = dev->bytesperline_out[p]; 342 343 mp->plane_fmt[0].sizeimage += 344 (stride * mp->height) / fmt->vdownsampling[p]; 345 } 346 return 0; 347 } 348 349 int vivid_try_fmt_vid_out(struct file *file, void *priv, 350 struct v4l2_format *f) 351 { 352 struct vivid_dev *dev = video_drvdata(file); 353 struct v4l2_bt_timings *bt = &dev->dv_timings_out.bt; 354 struct v4l2_pix_format_mplane *mp = &f->fmt.pix_mp; 355 struct v4l2_plane_pix_format *pfmt = mp->plane_fmt; 356 const struct vivid_fmt *fmt; 357 unsigned bytesperline, max_bpl; 358 unsigned factor = 1; 359 unsigned w, h; 360 unsigned p; 361 362 fmt = vivid_get_format(dev, mp->pixelformat); 363 if (!fmt) { 364 dprintk(dev, 1, "Fourcc format (0x%08x) unknown.\n", 365 mp->pixelformat); 366 mp->pixelformat = V4L2_PIX_FMT_YUYV; 367 fmt = vivid_get_format(dev, mp->pixelformat); 368 } 369 370 mp->field = vivid_field_out(dev, mp->field); 371 if (vivid_is_svid_out(dev)) { 372 w = 720; 373 h = (dev->std_out & V4L2_STD_525_60) ? 480 : 576; 374 } else { 375 w = dev->sink_rect.width; 376 h = dev->sink_rect.height; 377 } 378 if (V4L2_FIELD_HAS_T_OR_B(mp->field)) 379 factor = 2; 380 if (!dev->has_scaler_out && !dev->has_crop_out && !dev->has_compose_out) { 381 mp->width = w; 382 mp->height = h / factor; 383 } else { 384 struct v4l2_rect r = { 0, 0, mp->width, mp->height * factor }; 385 386 v4l2_rect_set_min_size(&r, &vivid_min_rect); 387 v4l2_rect_set_max_size(&r, &vivid_max_rect); 388 if (dev->has_scaler_out && !dev->has_crop_out) { 389 struct v4l2_rect max_r = { 0, 0, MAX_ZOOM * w, MAX_ZOOM * h }; 390 391 v4l2_rect_set_max_size(&r, &max_r); 392 } else if (!dev->has_scaler_out && dev->has_compose_out && !dev->has_crop_out) { 393 v4l2_rect_set_max_size(&r, &dev->sink_rect); 394 } else if (!dev->has_scaler_out && !dev->has_compose_out) { 395 v4l2_rect_set_min_size(&r, &dev->sink_rect); 396 } 397 mp->width = r.width; 398 mp->height = r.height / factor; 399 } 400 401 /* This driver supports custom bytesperline values */ 402 403 mp->num_planes = fmt->buffers; 404 for (p = 0; p < fmt->buffers; p++) { 405 /* Calculate the minimum supported bytesperline value */ 406 bytesperline = (mp->width * fmt->bit_depth[p]) >> 3; 407 /* Calculate the maximum supported bytesperline value */ 408 max_bpl = (MAX_ZOOM * MAX_WIDTH * fmt->bit_depth[p]) >> 3; 409 410 if (pfmt[p].bytesperline > max_bpl) 411 pfmt[p].bytesperline = max_bpl; 412 if (pfmt[p].bytesperline < bytesperline) 413 pfmt[p].bytesperline = bytesperline; 414 415 pfmt[p].sizeimage = (pfmt[p].bytesperline * mp->height) / 416 fmt->vdownsampling[p] + fmt->data_offset[p]; 417 418 memset(pfmt[p].reserved, 0, sizeof(pfmt[p].reserved)); 419 } 420 for (p = fmt->buffers; p < fmt->planes; p++) 421 pfmt[0].sizeimage += (pfmt[0].bytesperline * mp->height * 422 (fmt->bit_depth[p] / fmt->vdownsampling[p])) / 423 (fmt->bit_depth[0] / fmt->vdownsampling[0]); 424 425 mp->xfer_func = V4L2_XFER_FUNC_DEFAULT; 426 mp->ycbcr_enc = V4L2_YCBCR_ENC_DEFAULT; 427 mp->quantization = V4L2_QUANTIZATION_DEFAULT; 428 if (vivid_is_svid_out(dev)) { 429 mp->colorspace = V4L2_COLORSPACE_SMPTE170M; 430 } else if (dev->dvi_d_out || !(bt->flags & V4L2_DV_FL_IS_CE_VIDEO)) { 431 mp->colorspace = V4L2_COLORSPACE_SRGB; 432 if (dev->dvi_d_out) 433 mp->quantization = V4L2_QUANTIZATION_LIM_RANGE; 434 } else if (bt->width == 720 && bt->height <= 576) { 435 mp->colorspace = V4L2_COLORSPACE_SMPTE170M; 436 } else if (mp->colorspace != V4L2_COLORSPACE_SMPTE170M && 437 mp->colorspace != V4L2_COLORSPACE_REC709 && 438 mp->colorspace != V4L2_COLORSPACE_OPRGB && 439 mp->colorspace != V4L2_COLORSPACE_BT2020 && 440 mp->colorspace != V4L2_COLORSPACE_SRGB) { 441 mp->colorspace = V4L2_COLORSPACE_REC709; 442 } 443 memset(mp->reserved, 0, sizeof(mp->reserved)); 444 return 0; 445 } 446 447 int vivid_s_fmt_vid_out(struct file *file, void *priv, 448 struct v4l2_format *f) 449 { 450 struct v4l2_pix_format_mplane *mp = &f->fmt.pix_mp; 451 struct vivid_dev *dev = video_drvdata(file); 452 struct v4l2_rect *crop = &dev->crop_out; 453 struct v4l2_rect *compose = &dev->compose_out; 454 struct vb2_queue *q = &dev->vb_vid_out_q; 455 int ret = vivid_try_fmt_vid_out(file, priv, f); 456 unsigned factor = 1; 457 unsigned p; 458 459 if (ret < 0) 460 return ret; 461 462 if (vb2_is_busy(q) && 463 (vivid_is_svid_out(dev) || 464 mp->width != dev->fmt_out_rect.width || 465 mp->height != dev->fmt_out_rect.height || 466 mp->pixelformat != dev->fmt_out->fourcc || 467 mp->field != dev->field_out)) { 468 dprintk(dev, 1, "%s device busy\n", __func__); 469 return -EBUSY; 470 } 471 472 /* 473 * Allow for changing the colorspace on the fly. Useful for testing 474 * purposes, and it is something that HDMI transmitters are able 475 * to do. 476 */ 477 if (vb2_is_busy(q)) 478 goto set_colorspace; 479 480 dev->fmt_out = vivid_get_format(dev, mp->pixelformat); 481 if (V4L2_FIELD_HAS_T_OR_B(mp->field)) 482 factor = 2; 483 484 if (dev->has_scaler_out || dev->has_crop_out || dev->has_compose_out) { 485 struct v4l2_rect r = { 0, 0, mp->width, mp->height }; 486 487 if (dev->has_scaler_out) { 488 if (dev->has_crop_out) 489 v4l2_rect_map_inside(crop, &r); 490 else 491 *crop = r; 492 if (dev->has_compose_out && !dev->has_crop_out) { 493 struct v4l2_rect min_r = { 494 0, 0, 495 r.width / MAX_ZOOM, 496 factor * r.height / MAX_ZOOM 497 }; 498 struct v4l2_rect max_r = { 499 0, 0, 500 r.width * MAX_ZOOM, 501 factor * r.height * MAX_ZOOM 502 }; 503 504 v4l2_rect_set_min_size(compose, &min_r); 505 v4l2_rect_set_max_size(compose, &max_r); 506 v4l2_rect_map_inside(compose, &dev->compose_bounds_out); 507 } else if (dev->has_compose_out) { 508 struct v4l2_rect min_r = { 509 0, 0, 510 crop->width / MAX_ZOOM, 511 factor * crop->height / MAX_ZOOM 512 }; 513 struct v4l2_rect max_r = { 514 0, 0, 515 crop->width * MAX_ZOOM, 516 factor * crop->height * MAX_ZOOM 517 }; 518 519 v4l2_rect_set_min_size(compose, &min_r); 520 v4l2_rect_set_max_size(compose, &max_r); 521 v4l2_rect_map_inside(compose, &dev->compose_bounds_out); 522 } 523 } else if (dev->has_compose_out && !dev->has_crop_out) { 524 v4l2_rect_set_size_to(crop, &r); 525 r.height *= factor; 526 v4l2_rect_set_size_to(compose, &r); 527 v4l2_rect_map_inside(compose, &dev->compose_bounds_out); 528 } else if (!dev->has_compose_out) { 529 v4l2_rect_map_inside(crop, &r); 530 r.height /= factor; 531 v4l2_rect_set_size_to(compose, &r); 532 } else { 533 r.height *= factor; 534 v4l2_rect_set_max_size(compose, &r); 535 v4l2_rect_map_inside(compose, &dev->compose_bounds_out); 536 crop->top *= factor; 537 crop->height *= factor; 538 v4l2_rect_set_size_to(crop, compose); 539 v4l2_rect_map_inside(crop, &r); 540 crop->top /= factor; 541 crop->height /= factor; 542 } 543 } else { 544 struct v4l2_rect r = { 0, 0, mp->width, mp->height }; 545 546 v4l2_rect_set_size_to(crop, &r); 547 r.height /= factor; 548 v4l2_rect_set_size_to(compose, &r); 549 } 550 551 dev->fmt_out_rect.width = mp->width; 552 dev->fmt_out_rect.height = mp->height; 553 for (p = 0; p < mp->num_planes; p++) 554 dev->bytesperline_out[p] = mp->plane_fmt[p].bytesperline; 555 for (p = dev->fmt_out->buffers; p < dev->fmt_out->planes; p++) 556 dev->bytesperline_out[p] = 557 (dev->bytesperline_out[0] * dev->fmt_out->bit_depth[p]) / 558 dev->fmt_out->bit_depth[0]; 559 dev->field_out = mp->field; 560 if (vivid_is_svid_out(dev)) 561 dev->tv_field_out = mp->field; 562 563 set_colorspace: 564 dev->colorspace_out = mp->colorspace; 565 dev->xfer_func_out = mp->xfer_func; 566 dev->ycbcr_enc_out = mp->ycbcr_enc; 567 dev->quantization_out = mp->quantization; 568 if (dev->loop_video) { 569 vivid_send_source_change(dev, SVID); 570 vivid_send_source_change(dev, HDMI); 571 } 572 return 0; 573 } 574 575 int vidioc_g_fmt_vid_out_mplane(struct file *file, void *priv, 576 struct v4l2_format *f) 577 { 578 struct vivid_dev *dev = video_drvdata(file); 579 580 if (!dev->multiplanar) 581 return -ENOTTY; 582 return vivid_g_fmt_vid_out(file, priv, f); 583 } 584 585 int vidioc_try_fmt_vid_out_mplane(struct file *file, void *priv, 586 struct v4l2_format *f) 587 { 588 struct vivid_dev *dev = video_drvdata(file); 589 590 if (!dev->multiplanar) 591 return -ENOTTY; 592 return vivid_try_fmt_vid_out(file, priv, f); 593 } 594 595 int vidioc_s_fmt_vid_out_mplane(struct file *file, void *priv, 596 struct v4l2_format *f) 597 { 598 struct vivid_dev *dev = video_drvdata(file); 599 600 if (!dev->multiplanar) 601 return -ENOTTY; 602 return vivid_s_fmt_vid_out(file, priv, f); 603 } 604 605 int vidioc_g_fmt_vid_out(struct file *file, void *priv, 606 struct v4l2_format *f) 607 { 608 struct vivid_dev *dev = video_drvdata(file); 609 610 if (dev->multiplanar) 611 return -ENOTTY; 612 return fmt_sp2mp_func(file, priv, f, vivid_g_fmt_vid_out); 613 } 614 615 int vidioc_try_fmt_vid_out(struct file *file, void *priv, 616 struct v4l2_format *f) 617 { 618 struct vivid_dev *dev = video_drvdata(file); 619 620 if (dev->multiplanar) 621 return -ENOTTY; 622 return fmt_sp2mp_func(file, priv, f, vivid_try_fmt_vid_out); 623 } 624 625 int vidioc_s_fmt_vid_out(struct file *file, void *priv, 626 struct v4l2_format *f) 627 { 628 struct vivid_dev *dev = video_drvdata(file); 629 630 if (dev->multiplanar) 631 return -ENOTTY; 632 return fmt_sp2mp_func(file, priv, f, vivid_s_fmt_vid_out); 633 } 634 635 int vivid_vid_out_g_selection(struct file *file, void *priv, 636 struct v4l2_selection *sel) 637 { 638 struct vivid_dev *dev = video_drvdata(file); 639 640 if (!dev->has_crop_out && !dev->has_compose_out) 641 return -ENOTTY; 642 if (sel->type != V4L2_BUF_TYPE_VIDEO_OUTPUT) 643 return -EINVAL; 644 645 sel->r.left = sel->r.top = 0; 646 switch (sel->target) { 647 case V4L2_SEL_TGT_CROP: 648 if (!dev->has_crop_out) 649 return -EINVAL; 650 sel->r = dev->crop_out; 651 break; 652 case V4L2_SEL_TGT_CROP_DEFAULT: 653 if (!dev->has_crop_out) 654 return -EINVAL; 655 sel->r = dev->fmt_out_rect; 656 break; 657 case V4L2_SEL_TGT_CROP_BOUNDS: 658 if (!dev->has_crop_out) 659 return -EINVAL; 660 sel->r = vivid_max_rect; 661 break; 662 case V4L2_SEL_TGT_COMPOSE: 663 if (!dev->has_compose_out) 664 return -EINVAL; 665 sel->r = dev->compose_out; 666 break; 667 case V4L2_SEL_TGT_COMPOSE_DEFAULT: 668 case V4L2_SEL_TGT_COMPOSE_BOUNDS: 669 if (!dev->has_compose_out) 670 return -EINVAL; 671 sel->r = dev->sink_rect; 672 break; 673 default: 674 return -EINVAL; 675 } 676 return 0; 677 } 678 679 int vivid_vid_out_s_selection(struct file *file, void *fh, struct v4l2_selection *s) 680 { 681 struct vivid_dev *dev = video_drvdata(file); 682 struct v4l2_rect *crop = &dev->crop_out; 683 struct v4l2_rect *compose = &dev->compose_out; 684 unsigned factor = V4L2_FIELD_HAS_T_OR_B(dev->field_out) ? 2 : 1; 685 int ret; 686 687 if (!dev->has_crop_out && !dev->has_compose_out) 688 return -ENOTTY; 689 if (s->type != V4L2_BUF_TYPE_VIDEO_OUTPUT) 690 return -EINVAL; 691 692 switch (s->target) { 693 case V4L2_SEL_TGT_CROP: 694 if (!dev->has_crop_out) 695 return -EINVAL; 696 ret = vivid_vid_adjust_sel(s->flags, &s->r); 697 if (ret) 698 return ret; 699 v4l2_rect_set_min_size(&s->r, &vivid_min_rect); 700 v4l2_rect_set_max_size(&s->r, &dev->fmt_out_rect); 701 if (dev->has_scaler_out) { 702 struct v4l2_rect max_rect = { 703 0, 0, 704 dev->sink_rect.width * MAX_ZOOM, 705 (dev->sink_rect.height / factor) * MAX_ZOOM 706 }; 707 708 v4l2_rect_set_max_size(&s->r, &max_rect); 709 if (dev->has_compose_out) { 710 struct v4l2_rect min_rect = { 711 0, 0, 712 s->r.width / MAX_ZOOM, 713 (s->r.height * factor) / MAX_ZOOM 714 }; 715 struct v4l2_rect max_rect = { 716 0, 0, 717 s->r.width * MAX_ZOOM, 718 (s->r.height * factor) * MAX_ZOOM 719 }; 720 721 v4l2_rect_set_min_size(compose, &min_rect); 722 v4l2_rect_set_max_size(compose, &max_rect); 723 v4l2_rect_map_inside(compose, &dev->compose_bounds_out); 724 } 725 } else if (dev->has_compose_out) { 726 s->r.top *= factor; 727 s->r.height *= factor; 728 v4l2_rect_set_max_size(&s->r, &dev->sink_rect); 729 v4l2_rect_set_size_to(compose, &s->r); 730 v4l2_rect_map_inside(compose, &dev->compose_bounds_out); 731 s->r.top /= factor; 732 s->r.height /= factor; 733 } else { 734 v4l2_rect_set_size_to(&s->r, &dev->sink_rect); 735 s->r.height /= factor; 736 } 737 v4l2_rect_map_inside(&s->r, &dev->fmt_out_rect); 738 *crop = s->r; 739 break; 740 case V4L2_SEL_TGT_COMPOSE: 741 if (!dev->has_compose_out) 742 return -EINVAL; 743 ret = vivid_vid_adjust_sel(s->flags, &s->r); 744 if (ret) 745 return ret; 746 v4l2_rect_set_min_size(&s->r, &vivid_min_rect); 747 v4l2_rect_set_max_size(&s->r, &dev->sink_rect); 748 v4l2_rect_map_inside(&s->r, &dev->compose_bounds_out); 749 s->r.top /= factor; 750 s->r.height /= factor; 751 if (dev->has_scaler_out) { 752 struct v4l2_rect fmt = dev->fmt_out_rect; 753 struct v4l2_rect max_rect = { 754 0, 0, 755 s->r.width * MAX_ZOOM, 756 s->r.height * MAX_ZOOM 757 }; 758 struct v4l2_rect min_rect = { 759 0, 0, 760 s->r.width / MAX_ZOOM, 761 s->r.height / MAX_ZOOM 762 }; 763 764 v4l2_rect_set_min_size(&fmt, &min_rect); 765 if (!dev->has_crop_out) 766 v4l2_rect_set_max_size(&fmt, &max_rect); 767 if (!v4l2_rect_same_size(&dev->fmt_out_rect, &fmt) && 768 vb2_is_busy(&dev->vb_vid_out_q)) 769 return -EBUSY; 770 if (dev->has_crop_out) { 771 v4l2_rect_set_min_size(crop, &min_rect); 772 v4l2_rect_set_max_size(crop, &max_rect); 773 } 774 dev->fmt_out_rect = fmt; 775 } else if (dev->has_crop_out) { 776 struct v4l2_rect fmt = dev->fmt_out_rect; 777 778 v4l2_rect_set_min_size(&fmt, &s->r); 779 if (!v4l2_rect_same_size(&dev->fmt_out_rect, &fmt) && 780 vb2_is_busy(&dev->vb_vid_out_q)) 781 return -EBUSY; 782 dev->fmt_out_rect = fmt; 783 v4l2_rect_set_size_to(crop, &s->r); 784 v4l2_rect_map_inside(crop, &dev->fmt_out_rect); 785 } else { 786 if (!v4l2_rect_same_size(&s->r, &dev->fmt_out_rect) && 787 vb2_is_busy(&dev->vb_vid_out_q)) 788 return -EBUSY; 789 v4l2_rect_set_size_to(&dev->fmt_out_rect, &s->r); 790 v4l2_rect_set_size_to(crop, &s->r); 791 crop->height /= factor; 792 v4l2_rect_map_inside(crop, &dev->fmt_out_rect); 793 } 794 s->r.top *= factor; 795 s->r.height *= factor; 796 if (dev->bitmap_out && (compose->width != s->r.width || 797 compose->height != s->r.height)) { 798 vfree(dev->bitmap_out); 799 dev->bitmap_out = NULL; 800 } 801 *compose = s->r; 802 break; 803 default: 804 return -EINVAL; 805 } 806 807 return 0; 808 } 809 810 int vivid_vid_out_g_pixelaspect(struct file *file, void *priv, 811 int type, struct v4l2_fract *f) 812 { 813 struct vivid_dev *dev = video_drvdata(file); 814 815 if (type != V4L2_BUF_TYPE_VIDEO_OUTPUT) 816 return -EINVAL; 817 818 switch (vivid_get_pixel_aspect(dev)) { 819 case TPG_PIXEL_ASPECT_NTSC: 820 f->numerator = 11; 821 f->denominator = 10; 822 break; 823 case TPG_PIXEL_ASPECT_PAL: 824 f->numerator = 54; 825 f->denominator = 59; 826 break; 827 default: 828 break; 829 } 830 return 0; 831 } 832 833 int vidioc_g_fmt_vid_out_overlay(struct file *file, void *priv, 834 struct v4l2_format *f) 835 { 836 struct vivid_dev *dev = video_drvdata(file); 837 const struct v4l2_rect *compose = &dev->compose_out; 838 struct v4l2_window *win = &f->fmt.win; 839 unsigned clipcount = win->clipcount; 840 841 if (!dev->has_fb) 842 return -EINVAL; 843 win->w.top = dev->overlay_out_top; 844 win->w.left = dev->overlay_out_left; 845 win->w.width = compose->width; 846 win->w.height = compose->height; 847 win->clipcount = dev->clipcount_out; 848 win->field = V4L2_FIELD_ANY; 849 win->chromakey = dev->chromakey_out; 850 win->global_alpha = dev->global_alpha_out; 851 if (clipcount > dev->clipcount_out) 852 clipcount = dev->clipcount_out; 853 if (dev->bitmap_out == NULL) 854 win->bitmap = NULL; 855 else if (win->bitmap) { 856 if (copy_to_user(win->bitmap, dev->bitmap_out, 857 ((dev->compose_out.width + 7) / 8) * dev->compose_out.height)) 858 return -EFAULT; 859 } 860 if (clipcount && win->clips) { 861 if (copy_to_user(win->clips, dev->clips_out, 862 clipcount * sizeof(dev->clips_out[0]))) 863 return -EFAULT; 864 } 865 return 0; 866 } 867 868 int vidioc_try_fmt_vid_out_overlay(struct file *file, void *priv, 869 struct v4l2_format *f) 870 { 871 struct vivid_dev *dev = video_drvdata(file); 872 const struct v4l2_rect *compose = &dev->compose_out; 873 struct v4l2_window *win = &f->fmt.win; 874 int i, j; 875 876 if (!dev->has_fb) 877 return -EINVAL; 878 win->w.left = clamp_t(int, win->w.left, 879 -dev->display_width, dev->display_width); 880 win->w.top = clamp_t(int, win->w.top, 881 -dev->display_height, dev->display_height); 882 win->w.width = compose->width; 883 win->w.height = compose->height; 884 /* 885 * It makes no sense for an OSD to overlay only top or bottom fields, 886 * so always set this to ANY. 887 */ 888 win->field = V4L2_FIELD_ANY; 889 if (win->clipcount && !win->clips) 890 win->clipcount = 0; 891 if (win->clipcount > MAX_CLIPS) 892 win->clipcount = MAX_CLIPS; 893 if (win->clipcount) { 894 if (copy_from_user(dev->try_clips_out, win->clips, 895 win->clipcount * sizeof(dev->clips_out[0]))) 896 return -EFAULT; 897 for (i = 0; i < win->clipcount; i++) { 898 struct v4l2_rect *r = &dev->try_clips_out[i].c; 899 900 r->top = clamp_t(s32, r->top, 0, dev->display_height - 1); 901 r->height = clamp_t(s32, r->height, 1, dev->display_height - r->top); 902 r->left = clamp_t(u32, r->left, 0, dev->display_width - 1); 903 r->width = clamp_t(u32, r->width, 1, dev->display_width - r->left); 904 } 905 /* 906 * Yeah, so sue me, it's an O(n^2) algorithm. But n is a small 907 * number and it's typically a one-time deal. 908 */ 909 for (i = 0; i < win->clipcount - 1; i++) { 910 struct v4l2_rect *r1 = &dev->try_clips_out[i].c; 911 912 for (j = i + 1; j < win->clipcount; j++) { 913 struct v4l2_rect *r2 = &dev->try_clips_out[j].c; 914 915 if (v4l2_rect_overlap(r1, r2)) 916 return -EINVAL; 917 } 918 } 919 if (copy_to_user(win->clips, dev->try_clips_out, 920 win->clipcount * sizeof(dev->clips_out[0]))) 921 return -EFAULT; 922 } 923 return 0; 924 } 925 926 int vidioc_s_fmt_vid_out_overlay(struct file *file, void *priv, 927 struct v4l2_format *f) 928 { 929 struct vivid_dev *dev = video_drvdata(file); 930 const struct v4l2_rect *compose = &dev->compose_out; 931 struct v4l2_window *win = &f->fmt.win; 932 int ret = vidioc_try_fmt_vid_out_overlay(file, priv, f); 933 unsigned bitmap_size = ((compose->width + 7) / 8) * compose->height; 934 unsigned clips_size = win->clipcount * sizeof(dev->clips_out[0]); 935 void *new_bitmap = NULL; 936 937 if (ret) 938 return ret; 939 940 if (win->bitmap) { 941 new_bitmap = vzalloc(bitmap_size); 942 943 if (!new_bitmap) 944 return -ENOMEM; 945 if (copy_from_user(new_bitmap, win->bitmap, bitmap_size)) { 946 vfree(new_bitmap); 947 return -EFAULT; 948 } 949 } 950 951 dev->overlay_out_top = win->w.top; 952 dev->overlay_out_left = win->w.left; 953 vfree(dev->bitmap_out); 954 dev->bitmap_out = new_bitmap; 955 dev->clipcount_out = win->clipcount; 956 if (dev->clipcount_out) 957 memcpy(dev->clips_out, dev->try_clips_out, clips_size); 958 dev->chromakey_out = win->chromakey; 959 dev->global_alpha_out = win->global_alpha; 960 return ret; 961 } 962 963 int vivid_vid_out_overlay(struct file *file, void *fh, unsigned i) 964 { 965 struct vivid_dev *dev = video_drvdata(file); 966 967 if (i && !dev->fmt_out->can_do_overlay) { 968 dprintk(dev, 1, "unsupported output format for output overlay\n"); 969 return -EINVAL; 970 } 971 972 dev->overlay_out_enabled = i; 973 return 0; 974 } 975 976 int vivid_vid_out_g_fbuf(struct file *file, void *fh, 977 struct v4l2_framebuffer *a) 978 { 979 struct vivid_dev *dev = video_drvdata(file); 980 981 a->capability = V4L2_FBUF_CAP_EXTERNOVERLAY | 982 V4L2_FBUF_CAP_BITMAP_CLIPPING | 983 V4L2_FBUF_CAP_LIST_CLIPPING | 984 V4L2_FBUF_CAP_CHROMAKEY | 985 V4L2_FBUF_CAP_SRC_CHROMAKEY | 986 V4L2_FBUF_CAP_GLOBAL_ALPHA | 987 V4L2_FBUF_CAP_LOCAL_ALPHA | 988 V4L2_FBUF_CAP_LOCAL_INV_ALPHA; 989 a->flags = V4L2_FBUF_FLAG_OVERLAY | dev->fbuf_out_flags; 990 a->base = (void *)dev->video_pbase; 991 a->fmt.width = dev->display_width; 992 a->fmt.height = dev->display_height; 993 if (dev->fb_defined.green.length == 5) 994 a->fmt.pixelformat = V4L2_PIX_FMT_ARGB555; 995 else 996 a->fmt.pixelformat = V4L2_PIX_FMT_RGB565; 997 a->fmt.bytesperline = dev->display_byte_stride; 998 a->fmt.sizeimage = a->fmt.height * a->fmt.bytesperline; 999 a->fmt.field = V4L2_FIELD_NONE; 1000 a->fmt.colorspace = V4L2_COLORSPACE_SRGB; 1001 a->fmt.priv = 0; 1002 return 0; 1003 } 1004 1005 int vivid_vid_out_s_fbuf(struct file *file, void *fh, 1006 const struct v4l2_framebuffer *a) 1007 { 1008 struct vivid_dev *dev = video_drvdata(file); 1009 const unsigned chroma_flags = V4L2_FBUF_FLAG_CHROMAKEY | 1010 V4L2_FBUF_FLAG_SRC_CHROMAKEY; 1011 const unsigned alpha_flags = V4L2_FBUF_FLAG_GLOBAL_ALPHA | 1012 V4L2_FBUF_FLAG_LOCAL_ALPHA | 1013 V4L2_FBUF_FLAG_LOCAL_INV_ALPHA; 1014 1015 1016 if ((a->flags & chroma_flags) == chroma_flags) 1017 return -EINVAL; 1018 switch (a->flags & alpha_flags) { 1019 case 0: 1020 case V4L2_FBUF_FLAG_GLOBAL_ALPHA: 1021 case V4L2_FBUF_FLAG_LOCAL_ALPHA: 1022 case V4L2_FBUF_FLAG_LOCAL_INV_ALPHA: 1023 break; 1024 default: 1025 return -EINVAL; 1026 } 1027 dev->fbuf_out_flags &= ~(chroma_flags | alpha_flags); 1028 dev->fbuf_out_flags = a->flags & (chroma_flags | alpha_flags); 1029 return 0; 1030 } 1031 1032 static const struct v4l2_audioout vivid_audio_outputs[] = { 1033 { 0, "Line-Out 1" }, 1034 { 1, "Line-Out 2" }, 1035 }; 1036 1037 int vidioc_enum_output(struct file *file, void *priv, 1038 struct v4l2_output *out) 1039 { 1040 struct vivid_dev *dev = video_drvdata(file); 1041 1042 if (out->index >= dev->num_outputs) 1043 return -EINVAL; 1044 1045 out->type = V4L2_OUTPUT_TYPE_ANALOG; 1046 switch (dev->output_type[out->index]) { 1047 case SVID: 1048 snprintf(out->name, sizeof(out->name), "S-Video %u", 1049 dev->output_name_counter[out->index]); 1050 out->std = V4L2_STD_ALL; 1051 if (dev->has_audio_outputs) 1052 out->audioset = (1 << ARRAY_SIZE(vivid_audio_outputs)) - 1; 1053 out->capabilities = V4L2_OUT_CAP_STD; 1054 break; 1055 case HDMI: 1056 snprintf(out->name, sizeof(out->name), "HDMI %u", 1057 dev->output_name_counter[out->index]); 1058 out->capabilities = V4L2_OUT_CAP_DV_TIMINGS; 1059 break; 1060 } 1061 return 0; 1062 } 1063 1064 int vidioc_g_output(struct file *file, void *priv, unsigned *o) 1065 { 1066 struct vivid_dev *dev = video_drvdata(file); 1067 1068 *o = dev->output; 1069 return 0; 1070 } 1071 1072 int vidioc_s_output(struct file *file, void *priv, unsigned o) 1073 { 1074 struct vivid_dev *dev = video_drvdata(file); 1075 1076 if (o >= dev->num_outputs) 1077 return -EINVAL; 1078 1079 if (o == dev->output) 1080 return 0; 1081 1082 if (vb2_is_busy(&dev->vb_vid_out_q) || 1083 vb2_is_busy(&dev->vb_vbi_out_q) || 1084 vb2_is_busy(&dev->vb_meta_out_q)) 1085 return -EBUSY; 1086 1087 dev->output = o; 1088 dev->tv_audio_output = 0; 1089 if (dev->output_type[o] == SVID) 1090 dev->vid_out_dev.tvnorms = V4L2_STD_ALL; 1091 else 1092 dev->vid_out_dev.tvnorms = 0; 1093 1094 dev->vbi_out_dev.tvnorms = dev->vid_out_dev.tvnorms; 1095 dev->meta_out_dev.tvnorms = dev->vid_out_dev.tvnorms; 1096 vivid_update_format_out(dev); 1097 1098 v4l2_ctrl_activate(dev->ctrl_display_present, vivid_is_hdmi_out(dev)); 1099 if (vivid_is_hdmi_out(dev)) 1100 v4l2_ctrl_s_ctrl(dev->ctrl_display_present, 1101 dev->display_present[dev->output]); 1102 1103 return 0; 1104 } 1105 1106 int vidioc_enumaudout(struct file *file, void *fh, struct v4l2_audioout *vout) 1107 { 1108 if (vout->index >= ARRAY_SIZE(vivid_audio_outputs)) 1109 return -EINVAL; 1110 *vout = vivid_audio_outputs[vout->index]; 1111 return 0; 1112 } 1113 1114 int vidioc_g_audout(struct file *file, void *fh, struct v4l2_audioout *vout) 1115 { 1116 struct vivid_dev *dev = video_drvdata(file); 1117 1118 if (!vivid_is_svid_out(dev)) 1119 return -EINVAL; 1120 *vout = vivid_audio_outputs[dev->tv_audio_output]; 1121 return 0; 1122 } 1123 1124 int vidioc_s_audout(struct file *file, void *fh, const struct v4l2_audioout *vout) 1125 { 1126 struct vivid_dev *dev = video_drvdata(file); 1127 1128 if (!vivid_is_svid_out(dev)) 1129 return -EINVAL; 1130 if (vout->index >= ARRAY_SIZE(vivid_audio_outputs)) 1131 return -EINVAL; 1132 dev->tv_audio_output = vout->index; 1133 return 0; 1134 } 1135 1136 int vivid_vid_out_s_std(struct file *file, void *priv, v4l2_std_id id) 1137 { 1138 struct vivid_dev *dev = video_drvdata(file); 1139 1140 if (!vivid_is_svid_out(dev)) 1141 return -ENODATA; 1142 if (dev->std_out == id) 1143 return 0; 1144 if (vb2_is_busy(&dev->vb_vid_out_q) || vb2_is_busy(&dev->vb_vbi_out_q)) 1145 return -EBUSY; 1146 dev->std_out = id; 1147 vivid_update_format_out(dev); 1148 return 0; 1149 } 1150 1151 static bool valid_cvt_gtf_timings(struct v4l2_dv_timings *timings) 1152 { 1153 struct v4l2_bt_timings *bt = &timings->bt; 1154 1155 if ((bt->standards & (V4L2_DV_BT_STD_CVT | V4L2_DV_BT_STD_GTF)) && 1156 v4l2_valid_dv_timings(timings, &vivid_dv_timings_cap, NULL, NULL)) 1157 return true; 1158 1159 return false; 1160 } 1161 1162 int vivid_vid_out_s_dv_timings(struct file *file, void *_fh, 1163 struct v4l2_dv_timings *timings) 1164 { 1165 struct vivid_dev *dev = video_drvdata(file); 1166 if (!vivid_is_hdmi_out(dev)) 1167 return -ENODATA; 1168 if (!v4l2_find_dv_timings_cap(timings, &vivid_dv_timings_cap, 1169 0, NULL, NULL) && 1170 !valid_cvt_gtf_timings(timings)) 1171 return -EINVAL; 1172 if (v4l2_match_dv_timings(timings, &dev->dv_timings_out, 0, true)) 1173 return 0; 1174 if (vb2_is_busy(&dev->vb_vid_out_q)) 1175 return -EBUSY; 1176 dev->dv_timings_out = *timings; 1177 vivid_update_format_out(dev); 1178 return 0; 1179 } 1180 1181 int vivid_vid_out_g_parm(struct file *file, void *priv, 1182 struct v4l2_streamparm *parm) 1183 { 1184 struct vivid_dev *dev = video_drvdata(file); 1185 1186 if (parm->type != (dev->multiplanar ? 1187 V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE : 1188 V4L2_BUF_TYPE_VIDEO_OUTPUT)) 1189 return -EINVAL; 1190 1191 parm->parm.output.capability = V4L2_CAP_TIMEPERFRAME; 1192 parm->parm.output.timeperframe = dev->timeperframe_vid_out; 1193 parm->parm.output.writebuffers = 1; 1194 1195 return 0; 1196 } 1197 1198 int vidioc_subscribe_event(struct v4l2_fh *fh, 1199 const struct v4l2_event_subscription *sub) 1200 { 1201 switch (sub->type) { 1202 case V4L2_EVENT_SOURCE_CHANGE: 1203 if (fh->vdev->vfl_dir == VFL_DIR_RX) 1204 return v4l2_src_change_event_subscribe(fh, sub); 1205 break; 1206 default: 1207 return v4l2_ctrl_subscribe_event(fh, sub); 1208 } 1209 return -EINVAL; 1210 } 1211