Lines Matching refs:dev
59 static inline unsigned int webcam_ival_count(const struct vivid_dev *dev,
79 struct vivid_dev *dev = vb2_get_drv_priv(vq);
80 unsigned buffers = tpg_g_buffers(&dev->tpg);
81 unsigned h = dev->fmt_cap_rect.height;
84 if (dev->field_cap == V4L2_FIELD_ALTERNATE) {
93 if (dev->queue_setup_error) {
98 dev->queue_setup_error = false;
109 if (sizes[p] < tpg_g_line_width(&dev->tpg, p) * h +
110 dev->fmt_cap->data_offset[p])
115 sizes[p] = (tpg_g_line_width(&dev->tpg, p) * h) /
116 dev->fmt_cap->vdownsampling[p] +
117 dev->fmt_cap->data_offset[p];
125 dprintk(dev, 1, "%s: count=%d\n", __func__, *nbuffers);
127 dprintk(dev, 1, "%s: size[%u]=%u\n", __func__, p, sizes[p]);
134 struct vivid_dev *dev = vb2_get_drv_priv(vb->vb2_queue);
136 unsigned buffers = tpg_g_buffers(&dev->tpg);
139 dprintk(dev, 1, "%s\n", __func__);
141 if (WARN_ON(NULL == dev->fmt_cap))
144 if (dev->buf_prepare_error) {
149 dev->buf_prepare_error = false;
153 size = (tpg_g_line_width(&dev->tpg, p) *
154 dev->fmt_cap_rect.height) /
155 dev->fmt_cap->vdownsampling[p] +
156 dev->fmt_cap->data_offset[p];
159 dprintk(dev, 1, "%s data will not fit into plane %u (%lu < %lu)\n",
165 vb->planes[p].data_offset = dev->fmt_cap->data_offset[p];
174 struct vivid_dev *dev = vb2_get_drv_priv(vb->vb2_queue);
179 if (!vivid_is_sdtv_cap(dev))
187 if (dev->std_cap[dev->input] & V4L2_STD_525_60)
200 struct vivid_dev *dev = vb2_get_drv_priv(vb->vb2_queue);
203 dprintk(dev, 1, "%s\n", __func__);
205 spin_lock(&dev->slock);
206 list_add_tail(&buf->list, &dev->vid_cap_active);
207 spin_unlock(&dev->slock);
212 struct vivid_dev *dev = vb2_get_drv_priv(vq);
216 if (vb2_is_streaming(&dev->vb_vid_out_q))
217 dev->can_loop_video = vivid_vid_can_loop(dev);
219 dev->vid_cap_seq_count = 0;
220 dprintk(dev, 1, "%s\n", __func__);
222 dev->must_blank[i] = tpg_g_perc_fill(&dev->tpg) < 100;
223 if (dev->start_streaming_error) {
224 dev->start_streaming_error = false;
227 err = vivid_start_generating_vid_cap(dev, &dev->vid_cap_streaming);
232 list_for_each_entry_safe(buf, tmp, &dev->vid_cap_active, list) {
244 struct vivid_dev *dev = vb2_get_drv_priv(vq);
246 dprintk(dev, 1, "%s\n", __func__);
247 vivid_stop_generating_vid_cap(dev, &dev->vid_cap_streaming);
248 dev->can_loop_video = false;
253 struct vivid_dev *dev = vb2_get_drv_priv(vb->vb2_queue);
255 v4l2_ctrl_request_complete(vb->req_obj.req, &dev->ctrl_hdl_vid_cap);
275 void vivid_update_quality(struct vivid_dev *dev)
279 if (dev->loop_video && (vivid_is_svid_cap(dev) || vivid_is_hdmi_cap(dev))) {
284 tpg_s_quality(&dev->tpg, TPG_QUAL_NOISE, 0);
287 if (vivid_is_hdmi_cap(dev) &&
288 VIVID_INVALID_SIGNAL(dev->dv_timings_signal_mode[dev->input])) {
289 tpg_s_quality(&dev->tpg, TPG_QUAL_NOISE, 0);
292 if (vivid_is_sdtv_cap(dev) &&
293 VIVID_INVALID_SIGNAL(dev->std_signal_mode[dev->input])) {
294 tpg_s_quality(&dev->tpg, TPG_QUAL_NOISE, 0);
297 if (!vivid_is_tv_cap(dev)) {
298 tpg_s_quality(&dev->tpg, TPG_QUAL_COLOR, 0);
308 freq_modulus = (dev->tv_freq - 676 /* (43.25-1) * 16 */) % (6 * 16);
310 tpg_s_quality(&dev->tpg, TPG_QUAL_NOISE,
311 next_pseudo_random32(dev->tv_freq ^ 0x55) & 0x3f);
315 tpg_s_quality(&dev->tpg, TPG_QUAL_GRAY, 0);
317 tpg_s_quality(&dev->tpg, TPG_QUAL_COLOR, 0);
323 static enum tpg_quality vivid_get_quality(struct vivid_dev *dev, s32 *afc)
329 if (tpg_g_quality(&dev->tpg) == TPG_QUAL_COLOR ||
330 tpg_g_quality(&dev->tpg) == TPG_QUAL_NOISE)
331 return tpg_g_quality(&dev->tpg);
339 freq_modulus = (dev->tv_freq - 676 /* (43.25-1) * 16 */) % (6 * 16);
345 enum tpg_video_aspect vivid_get_video_aspect(const struct vivid_dev *dev)
347 if (vivid_is_sdtv_cap(dev))
348 return dev->std_aspect_ratio[dev->input];
350 if (vivid_is_hdmi_cap(dev))
351 return dev->dv_timings_aspect_ratio[dev->input];
356 static enum tpg_pixel_aspect vivid_get_pixel_aspect(const struct vivid_dev *dev)
358 if (vivid_is_sdtv_cap(dev))
359 return (dev->std_cap[dev->input] & V4L2_STD_525_60) ?
362 if (vivid_is_hdmi_cap(dev) &&
363 dev->src_rect.width == 720 && dev->src_rect.height <= 576)
364 return dev->src_rect.height == 480 ?
374 void vivid_update_format_cap(struct vivid_dev *dev, bool keep_controls)
376 struct v4l2_bt_timings *bt = &dev->dv_timings_cap[dev->input].bt;
381 switch (dev->input_type[dev->input]) {
384 dev->src_rect.width = webcam_sizes[dev->webcam_size_idx].width;
385 dev->src_rect.height = webcam_sizes[dev->webcam_size_idx].height;
386 dev->timeperframe_vid_cap = webcam_intervals[dev->webcam_ival_idx];
387 dev->field_cap = V4L2_FIELD_NONE;
388 tpg_s_rgb_range(&dev->tpg, V4L2_DV_RGB_RANGE_AUTO);
392 dev->field_cap = dev->tv_field_cap;
393 dev->src_rect.width = 720;
394 if (dev->std_cap[dev->input] & V4L2_STD_525_60) {
395 dev->src_rect.height = 480;
396 dev->timeperframe_vid_cap = (struct v4l2_fract) { 1001, 30000 };
397 dev->service_set_cap = V4L2_SLICED_CAPTION_525;
399 dev->src_rect.height = 576;
400 dev->timeperframe_vid_cap = (struct v4l2_fract) { 1000, 25000 };
401 dev->service_set_cap = V4L2_SLICED_WSS_625 | V4L2_SLICED_TELETEXT_B;
403 tpg_s_rgb_range(&dev->tpg, V4L2_DV_RGB_RANGE_AUTO);
406 dev->src_rect.width = bt->width;
407 dev->src_rect.height = bt->height;
409 if (dev->reduced_fps && can_reduce_fps(bt)) {
416 dev->timeperframe_vid_cap = (struct v4l2_fract) {
420 dev->field_cap = V4L2_FIELD_ALTERNATE;
422 dev->field_cap = V4L2_FIELD_NONE;
428 if (keep_controls || !dev->colorspace)
432 v4l2_ctrl_s_ctrl(dev->colorspace, VIVID_CS_170M);
434 v4l2_ctrl_s_ctrl(dev->colorspace, VIVID_CS_709);
435 v4l2_ctrl_s_ctrl(dev->real_rgb_range_cap, 1);
437 v4l2_ctrl_s_ctrl(dev->colorspace, VIVID_CS_SRGB);
438 v4l2_ctrl_s_ctrl(dev->real_rgb_range_cap, 0);
440 tpg_s_rgb_range(&dev->tpg, v4l2_ctrl_g_ctrl(dev->rgb_range_cap));
443 vivid_update_quality(dev);
444 tpg_reset_source(&dev->tpg, dev->src_rect.width, dev->src_rect.height, dev->field_cap);
445 dev->crop_cap = dev->src_rect;
446 dev->crop_bounds_cap = dev->src_rect;
447 dev->compose_cap = dev->crop_cap;
448 if (V4L2_FIELD_HAS_T_OR_B(dev->field_cap))
449 dev->compose_cap.height /= 2;
450 dev->fmt_cap_rect = dev->compose_cap;
451 tpg_s_video_aspect(&dev->tpg, vivid_get_video_aspect(dev));
452 tpg_s_pixel_aspect(&dev->tpg, vivid_get_pixel_aspect(dev));
453 tpg_update_mv_step(&dev->tpg);
462 dims[0] = roundup(dev->src_rect.width, PIXEL_ARRAY_DIV);
463 dims[1] = roundup(dev->src_rect.height, PIXEL_ARRAY_DIV);
464 v4l2_ctrl_modify_dimensions(dev->pixel_array, dims);
468 static enum v4l2_field vivid_field_cap(struct vivid_dev *dev, enum v4l2_field field)
470 if (vivid_is_sdtv_cap(dev)) {
485 if (vivid_is_hdmi_cap(dev))
486 return dev->dv_timings_cap[dev->input].bt.interlaced ?
491 static unsigned vivid_colorspace_cap(struct vivid_dev *dev)
493 if (!dev->loop_video || vivid_is_webcam(dev) || vivid_is_tv_cap(dev))
494 return tpg_g_colorspace(&dev->tpg);
495 return dev->colorspace_out;
498 static unsigned vivid_xfer_func_cap(struct vivid_dev *dev)
500 if (!dev->loop_video || vivid_is_webcam(dev) || vivid_is_tv_cap(dev))
501 return tpg_g_xfer_func(&dev->tpg);
502 return dev->xfer_func_out;
505 static unsigned vivid_ycbcr_enc_cap(struct vivid_dev *dev)
507 if (!dev->loop_video || vivid_is_webcam(dev) || vivid_is_tv_cap(dev))
508 return tpg_g_ycbcr_enc(&dev->tpg);
509 return dev->ycbcr_enc_out;
512 static unsigned int vivid_hsv_enc_cap(struct vivid_dev *dev)
514 if (!dev->loop_video || vivid_is_webcam(dev) || vivid_is_tv_cap(dev))
515 return tpg_g_hsv_enc(&dev->tpg);
516 return dev->hsv_enc_out;
519 static unsigned vivid_quantization_cap(struct vivid_dev *dev)
521 if (!dev->loop_video || vivid_is_webcam(dev) || vivid_is_tv_cap(dev))
522 return tpg_g_quantization(&dev->tpg);
523 return dev->quantization_out;
529 struct vivid_dev *dev = video_drvdata(file);
533 mp->width = dev->fmt_cap_rect.width;
534 mp->height = dev->fmt_cap_rect.height;
535 mp->field = dev->field_cap;
536 mp->pixelformat = dev->fmt_cap->fourcc;
537 mp->colorspace = vivid_colorspace_cap(dev);
538 mp->xfer_func = vivid_xfer_func_cap(dev);
539 if (dev->fmt_cap->color_enc == TGP_COLOR_ENC_HSV)
540 mp->hsv_enc = vivid_hsv_enc_cap(dev);
542 mp->ycbcr_enc = vivid_ycbcr_enc_cap(dev);
543 mp->quantization = vivid_quantization_cap(dev);
544 mp->num_planes = dev->fmt_cap->buffers;
546 mp->plane_fmt[p].bytesperline = tpg_g_bytesperline(&dev->tpg, p);
548 (tpg_g_line_width(&dev->tpg, p) * mp->height) /
549 dev->fmt_cap->vdownsampling[p] +
550 dev->fmt_cap->data_offset[p];
560 struct vivid_dev *dev = video_drvdata(file);
568 fmt = vivid_get_format(dev, mp->pixelformat);
570 dprintk(dev, 1, "Fourcc format (0x%08x) unknown.\n",
573 fmt = vivid_get_format(dev, mp->pixelformat);
576 mp->field = vivid_field_cap(dev, mp->field);
577 if (vivid_is_webcam(dev)) {
585 } else if (vivid_is_sdtv_cap(dev)) {
587 h = (dev->std_cap[dev->input] & V4L2_STD_525_60) ? 480 : 576;
589 w = dev->src_rect.width;
590 h = dev->src_rect.height;
594 if (vivid_is_webcam(dev) ||
595 (!dev->has_scaler_cap && !dev->has_crop_cap && !dev->has_compose_cap)) {
603 if (dev->has_scaler_cap && !dev->has_compose_cap) {
607 } else if (!dev->has_scaler_cap && dev->has_crop_cap && !dev->has_compose_cap) {
608 v4l2_rect_set_max_size(&r, &dev->src_rect);
609 } else if (!dev->has_scaler_cap && !dev->has_crop_cap) {
610 v4l2_rect_set_min_size(&r, &dev->src_rect);
641 mp->colorspace = vivid_colorspace_cap(dev);
644 mp->xfer_func = vivid_xfer_func_cap(dev);
648 mp->hsv_enc = vivid_hsv_enc_cap(dev);
651 mp->ycbcr_enc = vivid_ycbcr_enc_cap(dev);
653 mp->ycbcr_enc = vivid_ycbcr_enc_cap(dev);
659 mp->quantization = vivid_quantization_cap(dev);
661 mp->quantization = vivid_quantization_cap(dev);
672 struct vivid_dev *dev = video_drvdata(file);
673 struct v4l2_rect *crop = &dev->crop_cap;
674 struct v4l2_rect *compose = &dev->compose_cap;
675 struct vb2_queue *q = &dev->vb_vid_cap_q;
685 dprintk(dev, 1, "%s device busy\n", __func__);
689 dev->fmt_cap = vivid_get_format(dev, mp->pixelformat);
695 if (!vivid_is_webcam(dev) &&
696 (dev->has_scaler_cap || dev->has_crop_cap || dev->has_compose_cap)) {
699 if (dev->has_scaler_cap) {
700 if (dev->has_compose_cap)
704 if (dev->has_crop_cap && !dev->has_compose_cap) {
718 v4l2_rect_map_inside(crop, &dev->crop_bounds_cap);
719 } else if (dev->has_crop_cap) {
733 v4l2_rect_map_inside(crop, &dev->crop_bounds_cap);
735 } else if (dev->has_crop_cap && !dev->has_compose_cap) {
738 v4l2_rect_map_inside(crop, &dev->crop_bounds_cap);
742 } else if (!dev->has_crop_cap) {
747 v4l2_rect_map_inside(crop, &dev->crop_bounds_cap);
755 } else if (vivid_is_webcam(dev)) {
756 unsigned int ival_sz = webcam_ival_count(dev, dev->webcam_size_idx);
763 dev->webcam_size_idx = i;
764 if (dev->webcam_ival_idx >= ival_sz)
765 dev->webcam_ival_idx = ival_sz - 1;
766 vivid_update_format_cap(dev, false);
775 dev->fmt_cap_rect.width = mp->width;
776 dev->fmt_cap_rect.height = mp->height;
777 tpg_s_buf_height(&dev->tpg, mp->height);
778 tpg_s_fourcc(&dev->tpg, dev->fmt_cap->fourcc);
779 for (p = 0; p < tpg_g_buffers(&dev->tpg); p++)
780 tpg_s_bytesperline(&dev->tpg, p, mp->plane_fmt[p].bytesperline);
781 dev->field_cap = mp->field;
782 if (dev->field_cap == V4L2_FIELD_ALTERNATE)
783 tpg_s_field(&dev->tpg, V4L2_FIELD_TOP, true);
785 tpg_s_field(&dev->tpg, dev->field_cap, false);
786 tpg_s_crop_compose(&dev->tpg, &dev->crop_cap, &dev->compose_cap);
787 if (vivid_is_sdtv_cap(dev))
788 dev->tv_field_cap = mp->field;
789 tpg_update_mv_step(&dev->tpg);
790 dev->tpg.colorspace = mp->colorspace;
791 dev->tpg.xfer_func = mp->xfer_func;
792 if (dev->fmt_cap->color_enc == TGP_COLOR_ENC_YCBCR)
793 dev->tpg.ycbcr_enc = mp->ycbcr_enc;
795 dev->tpg.hsv_enc = mp->hsv_enc;
796 dev->tpg.quantization = mp->quantization;
804 struct vivid_dev *dev = video_drvdata(file);
806 if (!dev->multiplanar)
814 struct vivid_dev *dev = video_drvdata(file);
816 if (!dev->multiplanar)
824 struct vivid_dev *dev = video_drvdata(file);
826 if (!dev->multiplanar)
834 struct vivid_dev *dev = video_drvdata(file);
836 if (dev->multiplanar)
844 struct vivid_dev *dev = video_drvdata(file);
846 if (dev->multiplanar)
854 struct vivid_dev *dev = video_drvdata(file);
856 if (dev->multiplanar)
864 struct vivid_dev *dev = video_drvdata(file);
866 if (!dev->has_crop_cap && !dev->has_compose_cap)
870 if (vivid_is_webcam(dev))
876 if (!dev->has_crop_cap)
878 sel->r = dev->crop_cap;
882 if (!dev->has_crop_cap)
884 sel->r = dev->src_rect;
887 if (!dev->has_compose_cap)
892 if (!dev->has_compose_cap)
894 sel->r = dev->compose_cap;
897 if (!dev->has_compose_cap)
899 sel->r = dev->fmt_cap_rect;
909 struct vivid_dev *dev = video_drvdata(file);
910 struct v4l2_rect *crop = &dev->crop_cap;
911 struct v4l2_rect *compose = &dev->compose_cap;
912 unsigned factor = V4L2_FIELD_HAS_T_OR_B(dev->field_cap) ? 2 : 1;
915 if (!dev->has_crop_cap && !dev->has_compose_cap)
919 if (vivid_is_webcam(dev))
924 if (!dev->has_crop_cap)
930 v4l2_rect_set_max_size(&s->r, &dev->src_rect);
931 v4l2_rect_map_inside(&s->r, &dev->crop_bounds_cap);
934 if (dev->has_scaler_cap) {
935 struct v4l2_rect fmt = dev->fmt_cap_rect;
948 if (!dev->has_compose_cap)
950 if (!v4l2_rect_same_size(&dev->fmt_cap_rect, &fmt) &&
951 vb2_is_busy(&dev->vb_vid_cap_q))
953 if (dev->has_compose_cap) {
958 dev->fmt_cap_rect = fmt;
959 tpg_s_buf_height(&dev->tpg, fmt.height);
960 } else if (dev->has_compose_cap) {
961 struct v4l2_rect fmt = dev->fmt_cap_rect;
964 if (!v4l2_rect_same_size(&dev->fmt_cap_rect, &fmt) &&
965 vb2_is_busy(&dev->vb_vid_cap_q))
967 dev->fmt_cap_rect = fmt;
968 tpg_s_buf_height(&dev->tpg, fmt.height);
970 v4l2_rect_map_inside(compose, &dev->fmt_cap_rect);
972 if (!v4l2_rect_same_size(&s->r, &dev->fmt_cap_rect) &&
973 vb2_is_busy(&dev->vb_vid_cap_q))
975 v4l2_rect_set_size_to(&dev->fmt_cap_rect, &s->r);
977 v4l2_rect_map_inside(compose, &dev->fmt_cap_rect);
978 tpg_s_buf_height(&dev->tpg, dev->fmt_cap_rect.height);
985 if (!dev->has_compose_cap)
991 v4l2_rect_set_max_size(&s->r, &dev->fmt_cap_rect);
992 if (dev->has_scaler_cap) {
995 dev->src_rect.width * MAX_ZOOM,
996 (dev->src_rect.height / factor) * MAX_ZOOM
1000 if (dev->has_crop_cap) {
1014 v4l2_rect_map_inside(crop, &dev->crop_bounds_cap);
1016 } else if (dev->has_crop_cap) {
1019 v4l2_rect_set_max_size(&s->r, &dev->src_rect);
1021 v4l2_rect_map_inside(crop, &dev->crop_bounds_cap);
1025 v4l2_rect_set_size_to(&s->r, &dev->src_rect);
1028 v4l2_rect_map_inside(&s->r, &dev->fmt_cap_rect);
1035 tpg_s_crop_compose(&dev->tpg, crop, compose);
1042 struct vivid_dev *dev = video_drvdata(file);
1047 switch (vivid_get_pixel_aspect(dev)) {
1070 struct vivid_dev *dev = video_drvdata(file);
1072 if (inp->index >= dev->num_inputs)
1076 switch (dev->input_type[inp->index]) {
1079 dev->input_name_counter[inp->index]);
1084 dev->input_name_counter[inp->index]);
1087 if (dev->has_audio_inputs)
1093 dev->input_name_counter[inp->index]);
1095 if (dev->has_audio_inputs)
1101 dev->input_name_counter[inp->index]);
1103 if (dev->edid_blocks == 0 ||
1104 dev->dv_timings_signal_mode[dev->input] == NO_SIGNAL)
1106 else if (dev->dv_timings_signal_mode[dev->input] == NO_LOCK ||
1107 dev->dv_timings_signal_mode[dev->input] == OUT_OF_RANGE)
1111 if (dev->sensor_hflip)
1113 if (dev->sensor_vflip)
1115 if (dev->input == inp->index && vivid_is_sdtv_cap(dev)) {
1116 if (dev->std_signal_mode[dev->input] == NO_SIGNAL) {
1118 } else if (dev->std_signal_mode[dev->input] == NO_LOCK) {
1120 } else if (vivid_is_tv_cap(dev)) {
1121 switch (tpg_g_quality(&dev->tpg)) {
1138 struct vivid_dev *dev = video_drvdata(file);
1140 *i = dev->input;
1146 struct vivid_dev *dev = video_drvdata(file);
1147 struct v4l2_bt_timings *bt = &dev->dv_timings_cap[dev->input].bt;
1150 if (i >= dev->num_inputs)
1153 if (i == dev->input)
1156 if (vb2_is_busy(&dev->vb_vid_cap_q) ||
1157 vb2_is_busy(&dev->vb_vbi_cap_q) ||
1158 vb2_is_busy(&dev->vb_meta_cap_q))
1161 dev->input = i;
1162 dev->vid_cap_dev.tvnorms = 0;
1163 if (dev->input_type[i] == TV || dev->input_type[i] == SVID) {
1164 dev->tv_audio_input = (dev->input_type[i] == TV) ? 0 : 1;
1165 dev->vid_cap_dev.tvnorms = V4L2_STD_ALL;
1167 dev->vbi_cap_dev.tvnorms = dev->vid_cap_dev.tvnorms;
1168 dev->meta_cap_dev.tvnorms = dev->vid_cap_dev.tvnorms;
1169 vivid_update_format_cap(dev, false);
1171 if (dev->colorspace) {
1172 switch (dev->input_type[i]) {
1174 v4l2_ctrl_s_ctrl(dev->colorspace, VIVID_CS_SRGB);
1178 v4l2_ctrl_s_ctrl(dev->colorspace, VIVID_CS_170M);
1182 if (dev->src_rect.width == 720 && dev->src_rect.height <= 576)
1183 v4l2_ctrl_s_ctrl(dev->colorspace, VIVID_CS_170M);
1185 v4l2_ctrl_s_ctrl(dev->colorspace, VIVID_CS_709);
1187 v4l2_ctrl_s_ctrl(dev->colorspace, VIVID_CS_SRGB);
1200 brightness = 128 * i + dev->input_brightness[i];
1201 v4l2_ctrl_modify_range(dev->brightness,
1203 v4l2_ctrl_s_ctrl(dev->brightness, brightness);
1206 v4l2_ctrl_activate(dev->ctrl_dv_timings_signal_mode,
1207 vivid_is_hdmi_cap(dev));
1208 v4l2_ctrl_activate(dev->ctrl_dv_timings, vivid_is_hdmi_cap(dev) &&
1209 dev->dv_timings_signal_mode[dev->input] ==
1211 v4l2_ctrl_activate(dev->ctrl_std_signal_mode, vivid_is_sdtv_cap(dev));
1212 v4l2_ctrl_activate(dev->ctrl_standard, vivid_is_sdtv_cap(dev) &&
1213 dev->std_signal_mode[dev->input]);
1215 if (vivid_is_hdmi_cap(dev)) {
1216 v4l2_ctrl_s_ctrl(dev->ctrl_dv_timings_signal_mode,
1217 dev->dv_timings_signal_mode[dev->input]);
1218 v4l2_ctrl_s_ctrl(dev->ctrl_dv_timings,
1219 dev->query_dv_timings[dev->input]);
1220 } else if (vivid_is_sdtv_cap(dev)) {
1221 v4l2_ctrl_s_ctrl(dev->ctrl_std_signal_mode,
1222 dev->std_signal_mode[dev->input]);
1223 v4l2_ctrl_s_ctrl(dev->ctrl_standard,
1224 dev->std_signal_mode[dev->input]);
1240 struct vivid_dev *dev = video_drvdata(file);
1242 if (!vivid_is_sdtv_cap(dev))
1244 *vin = vivid_audio_inputs[dev->tv_audio_input];
1250 struct vivid_dev *dev = video_drvdata(file);
1252 if (!vivid_is_sdtv_cap(dev))
1256 dev->tv_audio_input = vin->index;
1262 struct vivid_dev *dev = video_drvdata(file);
1266 vf->frequency = dev->tv_freq;
1272 struct vivid_dev *dev = video_drvdata(file);
1276 dev->tv_freq = clamp_t(unsigned, vf->frequency, MIN_TV_FREQ, MAX_TV_FREQ);
1277 if (vivid_is_tv_cap(dev))
1278 vivid_update_quality(dev);
1284 struct vivid_dev *dev = video_drvdata(file);
1290 dev->tv_audmode = vt->audmode;
1296 struct vivid_dev *dev = video_drvdata(file);
1304 vt->audmode = dev->tv_audmode;
1307 qual = vivid_get_quality(dev, &vt->afc);
1319 unsigned int channel_nr = dev->tv_freq / (6 * 16);
1321 (dev->std_cap[dev->input] & V4L2_STD_NTSC_M) ? 4 : 3;
1331 if (dev->std_cap[dev->input] & V4L2_STD_NTSC_M)
1387 struct vivid_dev *dev = video_drvdata(file);
1388 unsigned int last = dev->query_std_last[dev->input];
1390 if (!vivid_is_sdtv_cap(dev))
1392 if (dev->std_signal_mode[dev->input] == NO_SIGNAL ||
1393 dev->std_signal_mode[dev->input] == NO_LOCK) {
1397 if (vivid_is_tv_cap(dev) && tpg_g_quality(&dev->tpg) == TPG_QUAL_NOISE) {
1399 } else if (dev->std_signal_mode[dev->input] == CURRENT_STD) {
1400 *id = dev->std_cap[dev->input];
1401 } else if (dev->std_signal_mode[dev->input] == SELECTED_STD) {
1402 *id = dev->query_std[dev->input];
1405 dev->query_std_last[dev->input] =
1414 struct vivid_dev *dev = video_drvdata(file);
1416 if (!vivid_is_sdtv_cap(dev))
1418 if (dev->std_cap[dev->input] == id)
1420 if (vb2_is_busy(&dev->vb_vid_cap_q) || vb2_is_busy(&dev->vb_vbi_cap_q))
1422 dev->std_cap[dev->input] = id;
1423 vivid_update_format_cap(dev, false);
1490 struct vivid_dev *dev = video_drvdata(file);
1492 if (!vivid_is_hdmi_cap(dev))
1499 if (v4l2_match_dv_timings(timings, &dev->dv_timings_cap[dev->input],
1502 if (vb2_is_busy(&dev->vb_vid_cap_q))
1505 dev->dv_timings_cap[dev->input] = *timings;
1506 vivid_update_format_cap(dev, false);
1513 struct vivid_dev *dev = video_drvdata(file);
1514 unsigned int input = dev->input;
1515 unsigned int last = dev->query_dv_timings_last[input];
1517 if (!vivid_is_hdmi_cap(dev))
1519 if (dev->dv_timings_signal_mode[input] == NO_SIGNAL ||
1520 dev->edid_blocks == 0)
1522 if (dev->dv_timings_signal_mode[input] == NO_LOCK)
1524 if (dev->dv_timings_signal_mode[input] == OUT_OF_RANGE) {
1528 if (dev->dv_timings_signal_mode[input] == CURRENT_DV_TIMINGS) {
1529 *timings = dev->dv_timings_cap[input];
1530 } else if (dev->dv_timings_signal_mode[input] ==
1533 v4l2_dv_timings_presets[dev->query_dv_timings[input]];
1537 dev->query_dv_timings_last[input] =
1538 (last + 1) % dev->query_dv_timings_size;
1546 struct vivid_dev *dev = video_drvdata(file);
1553 if (edid->pad >= dev->num_inputs)
1555 if (dev->input_type[edid->pad] != HDMI || edid->start_block)
1558 dev->edid_blocks = 0;
1559 v4l2_ctrl_s_ctrl(dev->ctrl_tx_edid_present, 0);
1560 v4l2_ctrl_s_ctrl(dev->ctrl_tx_hotplug, 0);
1564 if (edid->blocks > dev->edid_max_blocks) {
1565 edid->blocks = dev->edid_max_blocks;
1573 if (vb2_is_busy(&dev->vb_vid_cap_q))
1576 dev->edid_blocks = edid->blocks;
1577 memcpy(dev->edid, edid->edid, edid->blocks * 128);
1579 for (i = 0, j = 0; i < dev->num_outputs; i++)
1580 if (dev->output_type[i] == HDMI)
1582 dev->display_present[i] << j++;
1584 v4l2_ctrl_s_ctrl(dev->ctrl_tx_edid_present, display_present);
1585 v4l2_ctrl_s_ctrl(dev->ctrl_tx_hotplug, display_present);
1589 cec_s_phys_addr(dev->cec_rx_adap, phys_addr, false);
1591 for (i = 0; i < MAX_OUTPUTS && dev->cec_tx_adap[i]; i++)
1592 cec_s_phys_addr(dev->cec_tx_adap[i],
1593 dev->display_present[i] ?
1603 struct vivid_dev *dev = video_drvdata(file);
1605 if (!vivid_is_webcam(dev) && !dev->has_scaler_cap)
1607 if (vivid_get_format(dev, fsize->pixel_format) == NULL)
1609 if (vivid_is_webcam(dev)) {
1632 struct vivid_dev *dev = video_drvdata(file);
1636 fmt = vivid_get_format(dev, fival->pixel_format);
1640 if (!vivid_is_webcam(dev)) {
1648 fival->discrete = dev->timeperframe_vid_cap;
1658 if (fival->index >= webcam_ival_count(dev, i))
1668 struct vivid_dev *dev = video_drvdata(file);
1670 if (parm->type != (dev->multiplanar ?
1676 parm->parm.capture.timeperframe = dev->timeperframe_vid_cap;
1684 struct vivid_dev *dev = video_drvdata(file);
1685 unsigned int ival_sz = webcam_ival_count(dev, dev->webcam_size_idx);
1689 if (parm->type != (dev->multiplanar ?
1693 if (!vivid_is_webcam(dev))
1705 dev->webcam_ival_idx = i;
1706 tpf = webcam_intervals[dev->webcam_ival_idx];
1709 dev->cap_seq_resync = true;
1710 dev->timeperframe_vid_cap = tpf;