Lines Matching refs:dev
86 struct vivid_dev *dev = vb2_get_drv_priv(vq);
87 unsigned buffers = tpg_g_buffers(&dev->tpg);
88 unsigned h = dev->fmt_cap_rect.height;
91 if (dev->field_cap == V4L2_FIELD_ALTERNATE) {
100 if (dev->queue_setup_error) {
105 dev->queue_setup_error = false;
116 if (sizes[p] < tpg_g_line_width(&dev->tpg, p) * h +
117 dev->fmt_cap->data_offset[p])
122 sizes[p] = (tpg_g_line_width(&dev->tpg, p) * h) /
123 dev->fmt_cap->vdownsampling[p] +
124 dev->fmt_cap->data_offset[p];
132 dprintk(dev, 1, "%s: count=%d\n", __func__, *nbuffers);
134 dprintk(dev, 1, "%s: size[%u]=%u\n", __func__, p, sizes[p]);
141 struct vivid_dev *dev = vb2_get_drv_priv(vb->vb2_queue);
143 unsigned buffers = tpg_g_buffers(&dev->tpg);
146 dprintk(dev, 1, "%s\n", __func__);
148 if (WARN_ON(NULL == dev->fmt_cap))
151 if (dev->buf_prepare_error) {
156 dev->buf_prepare_error = false;
160 size = (tpg_g_line_width(&dev->tpg, p) *
161 dev->fmt_cap_rect.height) /
162 dev->fmt_cap->vdownsampling[p] +
163 dev->fmt_cap->data_offset[p];
166 dprintk(dev, 1, "%s data will not fit into plane %u (%lu < %lu)\n",
172 vb->planes[p].data_offset = dev->fmt_cap->data_offset[p];
181 struct vivid_dev *dev = vb2_get_drv_priv(vb->vb2_queue);
186 if (!vivid_is_sdtv_cap(dev))
194 if (dev->std_cap[dev->input] & V4L2_STD_525_60)
207 struct vivid_dev *dev = vb2_get_drv_priv(vb->vb2_queue);
210 dprintk(dev, 1, "%s\n", __func__);
212 spin_lock(&dev->slock);
213 list_add_tail(&buf->list, &dev->vid_cap_active);
214 spin_unlock(&dev->slock);
219 struct vivid_dev *dev = vb2_get_drv_priv(vq);
223 if (vb2_is_streaming(&dev->vb_vid_out_q))
224 dev->can_loop_video = vivid_vid_can_loop(dev);
226 dev->vid_cap_seq_count = 0;
227 dprintk(dev, 1, "%s\n", __func__);
229 dev->must_blank[i] = tpg_g_perc_fill(&dev->tpg) < 100;
230 if (dev->start_streaming_error) {
231 dev->start_streaming_error = false;
234 err = vivid_start_generating_vid_cap(dev, &dev->vid_cap_streaming);
239 list_for_each_entry_safe(buf, tmp, &dev->vid_cap_active, list) {
251 struct vivid_dev *dev = vb2_get_drv_priv(vq);
253 dprintk(dev, 1, "%s\n", __func__);
254 vivid_stop_generating_vid_cap(dev, &dev->vid_cap_streaming);
255 dev->can_loop_video = false;
260 struct vivid_dev *dev = vb2_get_drv_priv(vb->vb2_queue);
262 v4l2_ctrl_request_complete(vb->req_obj.req, &dev->ctrl_hdl_vid_cap);
282 void vivid_update_quality(struct vivid_dev *dev)
286 if (dev->loop_video && (vivid_is_svid_cap(dev) || vivid_is_hdmi_cap(dev))) {
291 tpg_s_quality(&dev->tpg, TPG_QUAL_NOISE, 0);
294 if (vivid_is_hdmi_cap(dev) &&
295 VIVID_INVALID_SIGNAL(dev->dv_timings_signal_mode[dev->input])) {
296 tpg_s_quality(&dev->tpg, TPG_QUAL_NOISE, 0);
299 if (vivid_is_sdtv_cap(dev) &&
300 VIVID_INVALID_SIGNAL(dev->std_signal_mode[dev->input])) {
301 tpg_s_quality(&dev->tpg, TPG_QUAL_NOISE, 0);
304 if (!vivid_is_tv_cap(dev)) {
305 tpg_s_quality(&dev->tpg, TPG_QUAL_COLOR, 0);
315 freq_modulus = (dev->tv_freq - 676 /* (43.25-1) * 16 */) % (6 * 16);
317 tpg_s_quality(&dev->tpg, TPG_QUAL_NOISE,
318 next_pseudo_random32(dev->tv_freq ^ 0x55) & 0x3f);
322 tpg_s_quality(&dev->tpg, TPG_QUAL_GRAY, 0);
324 tpg_s_quality(&dev->tpg, TPG_QUAL_COLOR, 0);
330 static enum tpg_quality vivid_get_quality(struct vivid_dev *dev, s32 *afc)
336 if (tpg_g_quality(&dev->tpg) == TPG_QUAL_COLOR ||
337 tpg_g_quality(&dev->tpg) == TPG_QUAL_NOISE)
338 return tpg_g_quality(&dev->tpg);
346 freq_modulus = (dev->tv_freq - 676 /* (43.25-1) * 16 */) % (6 * 16);
352 enum tpg_video_aspect vivid_get_video_aspect(const struct vivid_dev *dev)
354 if (vivid_is_sdtv_cap(dev))
355 return dev->std_aspect_ratio[dev->input];
357 if (vivid_is_hdmi_cap(dev))
358 return dev->dv_timings_aspect_ratio[dev->input];
363 static enum tpg_pixel_aspect vivid_get_pixel_aspect(const struct vivid_dev *dev)
365 if (vivid_is_sdtv_cap(dev))
366 return (dev->std_cap[dev->input] & V4L2_STD_525_60) ?
369 if (vivid_is_hdmi_cap(dev) &&
370 dev->src_rect.width == 720 && dev->src_rect.height <= 576)
371 return dev->src_rect.height == 480 ?
381 void vivid_update_format_cap(struct vivid_dev *dev, bool keep_controls)
383 struct v4l2_bt_timings *bt = &dev->dv_timings_cap[dev->input].bt;
387 switch (dev->input_type[dev->input]) {
390 dev->src_rect.width = webcam_sizes[dev->webcam_size_idx].width;
391 dev->src_rect.height = webcam_sizes[dev->webcam_size_idx].height;
392 dev->timeperframe_vid_cap = webcam_intervals[dev->webcam_ival_idx];
393 dev->field_cap = V4L2_FIELD_NONE;
394 tpg_s_rgb_range(&dev->tpg, V4L2_DV_RGB_RANGE_AUTO);
398 dev->field_cap = dev->tv_field_cap;
399 dev->src_rect.width = 720;
400 if (dev->std_cap[dev->input] & V4L2_STD_525_60) {
401 dev->src_rect.height = 480;
402 dev->timeperframe_vid_cap = (struct v4l2_fract) { 1001, 30000 };
403 dev->service_set_cap = V4L2_SLICED_CAPTION_525;
405 dev->src_rect.height = 576;
406 dev->timeperframe_vid_cap = (struct v4l2_fract) { 1000, 25000 };
407 dev->service_set_cap = V4L2_SLICED_WSS_625 | V4L2_SLICED_TELETEXT_B;
409 tpg_s_rgb_range(&dev->tpg, V4L2_DV_RGB_RANGE_AUTO);
412 dev->src_rect.width = bt->width;
413 dev->src_rect.height = bt->height;
415 if (dev->reduced_fps && can_reduce_fps(bt)) {
422 dev->timeperframe_vid_cap = (struct v4l2_fract) {
426 dev->field_cap = V4L2_FIELD_ALTERNATE;
428 dev->field_cap = V4L2_FIELD_NONE;
434 if (keep_controls || !dev->colorspace)
438 v4l2_ctrl_s_ctrl(dev->colorspace, VIVID_CS_170M);
440 v4l2_ctrl_s_ctrl(dev->colorspace, VIVID_CS_709);
441 v4l2_ctrl_s_ctrl(dev->real_rgb_range_cap, 1);
443 v4l2_ctrl_s_ctrl(dev->colorspace, VIVID_CS_SRGB);
444 v4l2_ctrl_s_ctrl(dev->real_rgb_range_cap, 0);
446 tpg_s_rgb_range(&dev->tpg, v4l2_ctrl_g_ctrl(dev->rgb_range_cap));
449 vfree(dev->bitmap_cap);
450 dev->bitmap_cap = NULL;
451 vivid_update_quality(dev);
452 tpg_reset_source(&dev->tpg, dev->src_rect.width, dev->src_rect.height, dev->field_cap);
453 dev->crop_cap = dev->src_rect;
454 dev->crop_bounds_cap = dev->src_rect;
455 if (dev->bitmap_cap &&
456 (dev->compose_cap.width != dev->crop_cap.width ||
457 dev->compose_cap.height != dev->crop_cap.height)) {
458 vfree(dev->bitmap_cap);
459 dev->bitmap_cap = NULL;
461 dev->compose_cap = dev->crop_cap;
462 if (V4L2_FIELD_HAS_T_OR_B(dev->field_cap))
463 dev->compose_cap.height /= 2;
464 dev->fmt_cap_rect = dev->compose_cap;
465 tpg_s_video_aspect(&dev->tpg, vivid_get_video_aspect(dev));
466 tpg_s_pixel_aspect(&dev->tpg, vivid_get_pixel_aspect(dev));
467 tpg_update_mv_step(&dev->tpg);
471 static enum v4l2_field vivid_field_cap(struct vivid_dev *dev, enum v4l2_field field)
473 if (vivid_is_sdtv_cap(dev)) {
488 if (vivid_is_hdmi_cap(dev))
489 return dev->dv_timings_cap[dev->input].bt.interlaced ?
494 static unsigned vivid_colorspace_cap(struct vivid_dev *dev)
496 if (!dev->loop_video || vivid_is_webcam(dev) || vivid_is_tv_cap(dev))
497 return tpg_g_colorspace(&dev->tpg);
498 return dev->colorspace_out;
501 static unsigned vivid_xfer_func_cap(struct vivid_dev *dev)
503 if (!dev->loop_video || vivid_is_webcam(dev) || vivid_is_tv_cap(dev))
504 return tpg_g_xfer_func(&dev->tpg);
505 return dev->xfer_func_out;
508 static unsigned vivid_ycbcr_enc_cap(struct vivid_dev *dev)
510 if (!dev->loop_video || vivid_is_webcam(dev) || vivid_is_tv_cap(dev))
511 return tpg_g_ycbcr_enc(&dev->tpg);
512 return dev->ycbcr_enc_out;
515 static unsigned int vivid_hsv_enc_cap(struct vivid_dev *dev)
517 if (!dev->loop_video || vivid_is_webcam(dev) || vivid_is_tv_cap(dev))
518 return tpg_g_hsv_enc(&dev->tpg);
519 return dev->hsv_enc_out;
522 static unsigned vivid_quantization_cap(struct vivid_dev *dev)
524 if (!dev->loop_video || vivid_is_webcam(dev) || vivid_is_tv_cap(dev))
525 return tpg_g_quantization(&dev->tpg);
526 return dev->quantization_out;
532 struct vivid_dev *dev = video_drvdata(file);
536 mp->width = dev->fmt_cap_rect.width;
537 mp->height = dev->fmt_cap_rect.height;
538 mp->field = dev->field_cap;
539 mp->pixelformat = dev->fmt_cap->fourcc;
540 mp->colorspace = vivid_colorspace_cap(dev);
541 mp->xfer_func = vivid_xfer_func_cap(dev);
542 if (dev->fmt_cap->color_enc == TGP_COLOR_ENC_HSV)
543 mp->hsv_enc = vivid_hsv_enc_cap(dev);
545 mp->ycbcr_enc = vivid_ycbcr_enc_cap(dev);
546 mp->quantization = vivid_quantization_cap(dev);
547 mp->num_planes = dev->fmt_cap->buffers;
549 mp->plane_fmt[p].bytesperline = tpg_g_bytesperline(&dev->tpg, p);
551 (tpg_g_line_width(&dev->tpg, p) * mp->height) /
552 dev->fmt_cap->vdownsampling[p] +
553 dev->fmt_cap->data_offset[p];
563 struct vivid_dev *dev = video_drvdata(file);
571 fmt = vivid_get_format(dev, mp->pixelformat);
573 dprintk(dev, 1, "Fourcc format (0x%08x) unknown.\n",
576 fmt = vivid_get_format(dev, mp->pixelformat);
579 mp->field = vivid_field_cap(dev, mp->field);
580 if (vivid_is_webcam(dev)) {
588 } else if (vivid_is_sdtv_cap(dev)) {
590 h = (dev->std_cap[dev->input] & V4L2_STD_525_60) ? 480 : 576;
592 w = dev->src_rect.width;
593 h = dev->src_rect.height;
597 if (vivid_is_webcam(dev) ||
598 (!dev->has_scaler_cap && !dev->has_crop_cap && !dev->has_compose_cap)) {
606 if (dev->has_scaler_cap && !dev->has_compose_cap) {
610 } else if (!dev->has_scaler_cap && dev->has_crop_cap && !dev->has_compose_cap) {
611 v4l2_rect_set_max_size(&r, &dev->src_rect);
612 } else if (!dev->has_scaler_cap && !dev->has_crop_cap) {
613 v4l2_rect_set_min_size(&r, &dev->src_rect);
644 mp->colorspace = vivid_colorspace_cap(dev);
647 mp->xfer_func = vivid_xfer_func_cap(dev);
651 mp->hsv_enc = vivid_hsv_enc_cap(dev);
654 mp->ycbcr_enc = vivid_ycbcr_enc_cap(dev);
656 mp->ycbcr_enc = vivid_ycbcr_enc_cap(dev);
662 mp->quantization = vivid_quantization_cap(dev);
664 mp->quantization = vivid_quantization_cap(dev);
675 struct vivid_dev *dev = video_drvdata(file);
676 struct v4l2_rect *crop = &dev->crop_cap;
677 struct v4l2_rect *compose = &dev->compose_cap;
678 struct vb2_queue *q = &dev->vb_vid_cap_q;
688 dprintk(dev, 1, "%s device busy\n", __func__);
692 if (dev->overlay_cap_owner && dev->fb_cap.fmt.pixelformat != mp->pixelformat) {
693 dprintk(dev, 1, "overlay is active, can't change pixelformat\n");
697 dev->fmt_cap = vivid_get_format(dev, mp->pixelformat);
703 if (!vivid_is_webcam(dev) &&
704 (dev->has_scaler_cap || dev->has_crop_cap || dev->has_compose_cap)) {
707 if (dev->has_scaler_cap) {
708 if (dev->has_compose_cap)
712 if (dev->has_crop_cap && !dev->has_compose_cap) {
726 v4l2_rect_map_inside(crop, &dev->crop_bounds_cap);
727 } else if (dev->has_crop_cap) {
741 v4l2_rect_map_inside(crop, &dev->crop_bounds_cap);
743 } else if (dev->has_crop_cap && !dev->has_compose_cap) {
746 v4l2_rect_map_inside(crop, &dev->crop_bounds_cap);
750 } else if (!dev->has_crop_cap) {
755 v4l2_rect_map_inside(crop, &dev->crop_bounds_cap);
763 } else if (vivid_is_webcam(dev)) {
769 dev->webcam_size_idx = i;
770 if (dev->webcam_ival_idx >= 2 * (VIVID_WEBCAM_SIZES - i))
771 dev->webcam_ival_idx = 2 * (VIVID_WEBCAM_SIZES - i) - 1;
772 vivid_update_format_cap(dev, false);
781 dev->fmt_cap_rect.width = mp->width;
782 dev->fmt_cap_rect.height = mp->height;
783 tpg_s_buf_height(&dev->tpg, mp->height);
784 tpg_s_fourcc(&dev->tpg, dev->fmt_cap->fourcc);
785 for (p = 0; p < tpg_g_buffers(&dev->tpg); p++)
786 tpg_s_bytesperline(&dev->tpg, p, mp->plane_fmt[p].bytesperline);
787 dev->field_cap = mp->field;
788 if (dev->field_cap == V4L2_FIELD_ALTERNATE)
789 tpg_s_field(&dev->tpg, V4L2_FIELD_TOP, true);
791 tpg_s_field(&dev->tpg, dev->field_cap, false);
792 tpg_s_crop_compose(&dev->tpg, &dev->crop_cap, &dev->compose_cap);
793 if (vivid_is_sdtv_cap(dev))
794 dev->tv_field_cap = mp->field;
795 tpg_update_mv_step(&dev->tpg);
796 dev->tpg.colorspace = mp->colorspace;
797 dev->tpg.xfer_func = mp->xfer_func;
798 if (dev->fmt_cap->color_enc == TGP_COLOR_ENC_YCBCR)
799 dev->tpg.ycbcr_enc = mp->ycbcr_enc;
801 dev->tpg.hsv_enc = mp->hsv_enc;
802 dev->tpg.quantization = mp->quantization;
810 struct vivid_dev *dev = video_drvdata(file);
812 if (!dev->multiplanar)
820 struct vivid_dev *dev = video_drvdata(file);
822 if (!dev->multiplanar)
830 struct vivid_dev *dev = video_drvdata(file);
832 if (!dev->multiplanar)
840 struct vivid_dev *dev = video_drvdata(file);
842 if (dev->multiplanar)
850 struct vivid_dev *dev = video_drvdata(file);
852 if (dev->multiplanar)
860 struct vivid_dev *dev = video_drvdata(file);
862 if (dev->multiplanar)
870 struct vivid_dev *dev = video_drvdata(file);
872 if (!dev->has_crop_cap && !dev->has_compose_cap)
876 if (vivid_is_webcam(dev))
882 if (!dev->has_crop_cap)
884 sel->r = dev->crop_cap;
888 if (!dev->has_crop_cap)
890 sel->r = dev->src_rect;
893 if (!dev->has_compose_cap)
898 if (!dev->has_compose_cap)
900 sel->r = dev->compose_cap;
903 if (!dev->has_compose_cap)
905 sel->r = dev->fmt_cap_rect;
915 struct vivid_dev *dev = video_drvdata(file);
916 struct v4l2_rect *crop = &dev->crop_cap;
917 struct v4l2_rect *compose = &dev->compose_cap;
920 unsigned factor = V4L2_FIELD_HAS_T_OR_B(dev->field_cap) ? 2 : 1;
923 if (!dev->has_crop_cap && !dev->has_compose_cap)
927 if (vivid_is_webcam(dev))
932 if (!dev->has_crop_cap)
938 v4l2_rect_set_max_size(&s->r, &dev->src_rect);
939 v4l2_rect_map_inside(&s->r, &dev->crop_bounds_cap);
942 if (dev->has_scaler_cap) {
943 struct v4l2_rect fmt = dev->fmt_cap_rect;
956 if (!dev->has_compose_cap)
958 if (!v4l2_rect_same_size(&dev->fmt_cap_rect, &fmt) &&
959 vb2_is_busy(&dev->vb_vid_cap_q))
961 if (dev->has_compose_cap) {
966 dev->fmt_cap_rect = fmt;
967 tpg_s_buf_height(&dev->tpg, fmt.height);
968 } else if (dev->has_compose_cap) {
969 struct v4l2_rect fmt = dev->fmt_cap_rect;
972 if (!v4l2_rect_same_size(&dev->fmt_cap_rect, &fmt) &&
973 vb2_is_busy(&dev->vb_vid_cap_q))
975 dev->fmt_cap_rect = fmt;
976 tpg_s_buf_height(&dev->tpg, fmt.height);
978 v4l2_rect_map_inside(compose, &dev->fmt_cap_rect);
980 if (!v4l2_rect_same_size(&s->r, &dev->fmt_cap_rect) &&
981 vb2_is_busy(&dev->vb_vid_cap_q))
983 v4l2_rect_set_size_to(&dev->fmt_cap_rect, &s->r);
985 v4l2_rect_map_inside(compose, &dev->fmt_cap_rect);
986 tpg_s_buf_height(&dev->tpg, dev->fmt_cap_rect.height);
993 if (!dev->has_compose_cap)
999 v4l2_rect_set_max_size(&s->r, &dev->fmt_cap_rect);
1000 if (dev->has_scaler_cap) {
1003 dev->src_rect.width * MAX_ZOOM,
1004 (dev->src_rect.height / factor) * MAX_ZOOM
1008 if (dev->has_crop_cap) {
1022 v4l2_rect_map_inside(crop, &dev->crop_bounds_cap);
1024 } else if (dev->has_crop_cap) {
1027 v4l2_rect_set_max_size(&s->r, &dev->src_rect);
1029 v4l2_rect_map_inside(crop, &dev->crop_bounds_cap);
1033 v4l2_rect_set_size_to(&s->r, &dev->src_rect);
1036 v4l2_rect_map_inside(&s->r, &dev->fmt_cap_rect);
1043 if (dev->bitmap_cap && (compose->width != orig_compose_w ||
1045 vfree(dev->bitmap_cap);
1046 dev->bitmap_cap = NULL;
1048 tpg_s_crop_compose(&dev->tpg, crop, compose);
1055 struct vivid_dev *dev = video_drvdata(file);
1060 switch (vivid_get_pixel_aspect(dev)) {
1078 struct vivid_dev *dev = video_drvdata(file);
1081 if (dev->multiplanar)
1096 struct vivid_dev *dev = video_drvdata(file);
1097 const struct v4l2_rect *compose = &dev->compose_cap;
1101 if (dev->multiplanar)
1104 win->w.top = dev->overlay_cap_top;
1105 win->w.left = dev->overlay_cap_left;
1108 win->field = dev->overlay_cap_field;
1109 win->clipcount = dev->clipcount_cap;
1110 if (clipcount > dev->clipcount_cap)
1111 clipcount = dev->clipcount_cap;
1112 if (dev->bitmap_cap == NULL)
1115 if (copy_to_user(win->bitmap, dev->bitmap_cap,
1120 if (copy_to_user(win->clips, dev->clips_cap,
1121 clipcount * sizeof(dev->clips_cap[0])))
1130 struct vivid_dev *dev = video_drvdata(file);
1131 const struct v4l2_rect *compose = &dev->compose_cap;
1135 if (dev->multiplanar)
1139 -dev->fb_cap.fmt.width, dev->fb_cap.fmt.width);
1141 -dev->fb_cap.fmt.height, dev->fb_cap.fmt.height);
1153 if (copy_from_user(dev->try_clips_cap, win->clips,
1154 win->clipcount * sizeof(dev->clips_cap[0])))
1157 struct v4l2_rect *r = &dev->try_clips_cap[i].c;
1159 r->top = clamp_t(s32, r->top, 0, dev->fb_cap.fmt.height - 1);
1160 r->height = clamp_t(s32, r->height, 1, dev->fb_cap.fmt.height - r->top);
1161 r->left = clamp_t(u32, r->left, 0, dev->fb_cap.fmt.width - 1);
1162 r->width = clamp_t(u32, r->width, 1, dev->fb_cap.fmt.width - r->left);
1169 struct v4l2_rect *r1 = &dev->try_clips_cap[i].c;
1172 struct v4l2_rect *r2 = &dev->try_clips_cap[j].c;
1178 if (copy_to_user(win->clips, dev->try_clips_cap,
1179 win->clipcount * sizeof(dev->clips_cap[0])))
1188 struct vivid_dev *dev = video_drvdata(file);
1189 const struct v4l2_rect *compose = &dev->compose_cap;
1193 unsigned clips_size = win->clipcount * sizeof(dev->clips_cap[0]);
1210 dev->overlay_cap_top = win->w.top;
1211 dev->overlay_cap_left = win->w.left;
1212 dev->overlay_cap_field = win->field;
1213 vfree(dev->bitmap_cap);
1214 dev->bitmap_cap = new_bitmap;
1215 dev->clipcount_cap = win->clipcount;
1216 if (dev->clipcount_cap)
1217 memcpy(dev->clips_cap, dev->try_clips_cap, clips_size);
1223 struct vivid_dev *dev = video_drvdata(file);
1225 if (dev->multiplanar)
1228 if (i && dev->fb_vbase_cap == NULL)
1231 if (i && dev->fb_cap.fmt.pixelformat != dev->fmt_cap->fourcc) {
1232 dprintk(dev, 1, "mismatch between overlay and video capture pixelformats\n");
1236 if (dev->overlay_cap_owner && dev->overlay_cap_owner != fh)
1238 dev->overlay_cap_owner = i ? fh : NULL;
1245 struct vivid_dev *dev = video_drvdata(file);
1247 if (dev->multiplanar)
1250 *a = dev->fb_cap;
1263 struct vivid_dev *dev = video_drvdata(file);
1266 if (dev->multiplanar)
1272 if (dev->overlay_cap_owner)
1276 dev->fb_cap.base = NULL;
1277 dev->fb_vbase_cap = NULL;
1283 fmt = vivid_get_format(dev, a->fmt.pixelformat);
1298 dev->fb_vbase_cap = phys_to_virt((unsigned long)a->base);
1299 dev->fb_cap = *a;
1300 dev->overlay_cap_left = clamp_t(int, dev->overlay_cap_left,
1301 -dev->fb_cap.fmt.width, dev->fb_cap.fmt.width);
1302 dev->overlay_cap_top = clamp_t(int, dev->overlay_cap_top,
1303 -dev->fb_cap.fmt.height, dev->fb_cap.fmt.height);
1315 struct vivid_dev *dev = video_drvdata(file);
1317 if (inp->index >= dev->num_inputs)
1321 switch (dev->input_type[inp->index]) {
1324 dev->input_name_counter[inp->index]);
1329 dev->input_name_counter[inp->index]);
1332 if (dev->has_audio_inputs)
1338 dev->input_name_counter[inp->index]);
1340 if (dev->has_audio_inputs)
1346 dev->input_name_counter[inp->index]);
1348 if (dev->edid_blocks == 0 ||
1349 dev->dv_timings_signal_mode[dev->input] == NO_SIGNAL)
1351 else if (dev->dv_timings_signal_mode[dev->input] == NO_LOCK ||
1352 dev->dv_timings_signal_mode[dev->input] == OUT_OF_RANGE)
1356 if (dev->sensor_hflip)
1358 if (dev->sensor_vflip)
1360 if (dev->input == inp->index && vivid_is_sdtv_cap(dev)) {
1361 if (dev->std_signal_mode[dev->input] == NO_SIGNAL) {
1363 } else if (dev->std_signal_mode[dev->input] == NO_LOCK) {
1365 } else if (vivid_is_tv_cap(dev)) {
1366 switch (tpg_g_quality(&dev->tpg)) {
1383 struct vivid_dev *dev = video_drvdata(file);
1385 *i = dev->input;
1391 struct vivid_dev *dev = video_drvdata(file);
1392 struct v4l2_bt_timings *bt = &dev->dv_timings_cap[dev->input].bt;
1395 if (i >= dev->num_inputs)
1398 if (i == dev->input)
1401 if (vb2_is_busy(&dev->vb_vid_cap_q) ||
1402 vb2_is_busy(&dev->vb_vbi_cap_q) ||
1403 vb2_is_busy(&dev->vb_meta_cap_q))
1406 dev->input = i;
1407 dev->vid_cap_dev.tvnorms = 0;
1408 if (dev->input_type[i] == TV || dev->input_type[i] == SVID) {
1409 dev->tv_audio_input = (dev->input_type[i] == TV) ? 0 : 1;
1410 dev->vid_cap_dev.tvnorms = V4L2_STD_ALL;
1412 dev->vbi_cap_dev.tvnorms = dev->vid_cap_dev.tvnorms;
1413 dev->meta_cap_dev.tvnorms = dev->vid_cap_dev.tvnorms;
1414 vivid_update_format_cap(dev, false);
1416 if (dev->colorspace) {
1417 switch (dev->input_type[i]) {
1419 v4l2_ctrl_s_ctrl(dev->colorspace, VIVID_CS_SRGB);
1423 v4l2_ctrl_s_ctrl(dev->colorspace, VIVID_CS_170M);
1427 if (dev->src_rect.width == 720 && dev->src_rect.height <= 576)
1428 v4l2_ctrl_s_ctrl(dev->colorspace, VIVID_CS_170M);
1430 v4l2_ctrl_s_ctrl(dev->colorspace, VIVID_CS_709);
1432 v4l2_ctrl_s_ctrl(dev->colorspace, VIVID_CS_SRGB);
1445 brightness = 128 * i + dev->input_brightness[i];
1446 v4l2_ctrl_modify_range(dev->brightness,
1448 v4l2_ctrl_s_ctrl(dev->brightness, brightness);
1451 v4l2_ctrl_activate(dev->ctrl_dv_timings_signal_mode,
1452 vivid_is_hdmi_cap(dev));
1453 v4l2_ctrl_activate(dev->ctrl_dv_timings, vivid_is_hdmi_cap(dev) &&
1454 dev->dv_timings_signal_mode[dev->input] ==
1456 v4l2_ctrl_activate(dev->ctrl_std_signal_mode, vivid_is_sdtv_cap(dev));
1457 v4l2_ctrl_activate(dev->ctrl_standard, vivid_is_sdtv_cap(dev) &&
1458 dev->std_signal_mode[dev->input]);
1460 if (vivid_is_hdmi_cap(dev)) {
1461 v4l2_ctrl_s_ctrl(dev->ctrl_dv_timings_signal_mode,
1462 dev->dv_timings_signal_mode[dev->input]);
1463 v4l2_ctrl_s_ctrl(dev->ctrl_dv_timings,
1464 dev->query_dv_timings[dev->input]);
1465 } else if (vivid_is_sdtv_cap(dev)) {
1466 v4l2_ctrl_s_ctrl(dev->ctrl_std_signal_mode,
1467 dev->std_signal_mode[dev->input]);
1468 v4l2_ctrl_s_ctrl(dev->ctrl_standard,
1469 dev->std_signal_mode[dev->input]);
1485 struct vivid_dev *dev = video_drvdata(file);
1487 if (!vivid_is_sdtv_cap(dev))
1489 *vin = vivid_audio_inputs[dev->tv_audio_input];
1495 struct vivid_dev *dev = video_drvdata(file);
1497 if (!vivid_is_sdtv_cap(dev))
1501 dev->tv_audio_input = vin->index;
1507 struct vivid_dev *dev = video_drvdata(file);
1511 vf->frequency = dev->tv_freq;
1517 struct vivid_dev *dev = video_drvdata(file);
1521 dev->tv_freq = clamp_t(unsigned, vf->frequency, MIN_TV_FREQ, MAX_TV_FREQ);
1522 if (vivid_is_tv_cap(dev))
1523 vivid_update_quality(dev);
1529 struct vivid_dev *dev = video_drvdata(file);
1535 dev->tv_audmode = vt->audmode;
1541 struct vivid_dev *dev = video_drvdata(file);
1549 vt->audmode = dev->tv_audmode;
1552 qual = vivid_get_quality(dev, &vt->afc);
1564 unsigned int channel_nr = dev->tv_freq / (6 * 16);
1566 (dev->std_cap[dev->input] & V4L2_STD_NTSC_M) ? 4 : 3;
1576 if (dev->std_cap[dev->input] & V4L2_STD_NTSC_M)
1632 struct vivid_dev *dev = video_drvdata(file);
1633 unsigned int last = dev->query_std_last[dev->input];
1635 if (!vivid_is_sdtv_cap(dev))
1637 if (dev->std_signal_mode[dev->input] == NO_SIGNAL ||
1638 dev->std_signal_mode[dev->input] == NO_LOCK) {
1642 if (vivid_is_tv_cap(dev) && tpg_g_quality(&dev->tpg) == TPG_QUAL_NOISE) {
1644 } else if (dev->std_signal_mode[dev->input] == CURRENT_STD) {
1645 *id = dev->std_cap[dev->input];
1646 } else if (dev->std_signal_mode[dev->input] == SELECTED_STD) {
1647 *id = dev->query_std[dev->input];
1650 dev->query_std_last[dev->input] =
1659 struct vivid_dev *dev = video_drvdata(file);
1661 if (!vivid_is_sdtv_cap(dev))
1663 if (dev->std_cap[dev->input] == id)
1665 if (vb2_is_busy(&dev->vb_vid_cap_q) || vb2_is_busy(&dev->vb_vbi_cap_q))
1667 dev->std_cap[dev->input] = id;
1668 vivid_update_format_cap(dev, false);
1735 struct vivid_dev *dev = video_drvdata(file);
1737 if (!vivid_is_hdmi_cap(dev))
1744 if (v4l2_match_dv_timings(timings, &dev->dv_timings_cap[dev->input],
1747 if (vb2_is_busy(&dev->vb_vid_cap_q))
1750 dev->dv_timings_cap[dev->input] = *timings;
1751 vivid_update_format_cap(dev, false);
1758 struct vivid_dev *dev = video_drvdata(file);
1759 unsigned int input = dev->input;
1760 unsigned int last = dev->query_dv_timings_last[input];
1762 if (!vivid_is_hdmi_cap(dev))
1764 if (dev->dv_timings_signal_mode[input] == NO_SIGNAL ||
1765 dev->edid_blocks == 0)
1767 if (dev->dv_timings_signal_mode[input] == NO_LOCK)
1769 if (dev->dv_timings_signal_mode[input] == OUT_OF_RANGE) {
1773 if (dev->dv_timings_signal_mode[input] == CURRENT_DV_TIMINGS) {
1774 *timings = dev->dv_timings_cap[input];
1775 } else if (dev->dv_timings_signal_mode[input] ==
1778 v4l2_dv_timings_presets[dev->query_dv_timings[input]];
1782 dev->query_dv_timings_last[input] =
1783 (last + 1) % dev->query_dv_timings_size;
1791 struct vivid_dev *dev = video_drvdata(file);
1798 if (edid->pad >= dev->num_inputs)
1800 if (dev->input_type[edid->pad] != HDMI || edid->start_block)
1803 dev->edid_blocks = 0;
1804 v4l2_ctrl_s_ctrl(dev->ctrl_tx_edid_present, 0);
1805 v4l2_ctrl_s_ctrl(dev->ctrl_tx_hotplug, 0);
1809 if (edid->blocks > dev->edid_max_blocks) {
1810 edid->blocks = dev->edid_max_blocks;
1818 if (vb2_is_busy(&dev->vb_vid_cap_q))
1821 dev->edid_blocks = edid->blocks;
1822 memcpy(dev->edid, edid->edid, edid->blocks * 128);
1824 for (i = 0, j = 0; i < dev->num_outputs; i++)
1825 if (dev->output_type[i] == HDMI)
1827 dev->display_present[i] << j++;
1829 v4l2_ctrl_s_ctrl(dev->ctrl_tx_edid_present, display_present);
1830 v4l2_ctrl_s_ctrl(dev->ctrl_tx_hotplug, display_present);
1834 cec_s_phys_addr(dev->cec_rx_adap, phys_addr, false);
1836 for (i = 0; i < MAX_OUTPUTS && dev->cec_tx_adap[i]; i++)
1837 cec_s_phys_addr(dev->cec_tx_adap[i],
1838 dev->display_present[i] ?
1848 struct vivid_dev *dev = video_drvdata(file);
1850 if (!vivid_is_webcam(dev) && !dev->has_scaler_cap)
1852 if (vivid_get_format(dev, fsize->pixel_format) == NULL)
1854 if (vivid_is_webcam(dev)) {
1877 struct vivid_dev *dev = video_drvdata(file);
1881 fmt = vivid_get_format(dev, fival->pixel_format);
1885 if (!vivid_is_webcam(dev)) {
1893 fival->discrete = dev->timeperframe_vid_cap;
1913 struct vivid_dev *dev = video_drvdata(file);
1915 if (parm->type != (dev->multiplanar ?
1921 parm->parm.capture.timeperframe = dev->timeperframe_vid_cap;
1929 struct vivid_dev *dev = video_drvdata(file);
1930 unsigned ival_sz = 2 * (VIVID_WEBCAM_SIZES - dev->webcam_size_idx);
1934 if (parm->type != (dev->multiplanar ?
1938 if (!vivid_is_webcam(dev))
1950 dev->webcam_ival_idx = i;
1951 tpf = webcam_intervals[dev->webcam_ival_idx];
1954 dev->cap_seq_resync = true;
1955 dev->timeperframe_vid_cap = tpf;