Lines Matching full: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->vdownsampling[p] +
111 dev->fmt_cap->data_offset[p])
116 sizes[p] = (tpg_g_line_width(&dev->tpg, p) * h) /
117 dev->fmt_cap->vdownsampling[p] +
118 dev->fmt_cap->data_offset[p];
126 dprintk(dev, 1, "%s: count=%d\n", __func__, *nbuffers);
128 dprintk(dev, 1, "%s: size[%u]=%u\n", __func__, p, sizes[p]);
135 struct vivid_dev *dev = vb2_get_drv_priv(vb->vb2_queue);
137 unsigned buffers = tpg_g_buffers(&dev->tpg);
140 dprintk(dev, 1, "%s\n", __func__);
142 if (WARN_ON(NULL == dev->fmt_cap))
145 if (dev->buf_prepare_error) {
150 dev->buf_prepare_error = false;
154 size = (tpg_g_line_width(&dev->tpg, p) *
155 dev->fmt_cap_rect.height) /
156 dev->fmt_cap->vdownsampling[p] +
157 dev->fmt_cap->data_offset[p];
160 dprintk(dev, 1, "%s data will not fit into plane %u (%lu < %lu)\n",
166 vb->planes[p].data_offset = dev->fmt_cap->data_offset[p];
175 struct vivid_dev *dev = vb2_get_drv_priv(vb->vb2_queue);
180 if (!vivid_is_sdtv_cap(dev))
188 if (dev->std_cap[dev->input] & V4L2_STD_525_60)
201 struct vivid_dev *dev = vb2_get_drv_priv(vb->vb2_queue);
204 dprintk(dev, 1, "%s\n", __func__);
206 spin_lock(&dev->slock);
207 list_add_tail(&buf->list, &dev->vid_cap_active);
208 spin_unlock(&dev->slock);
213 struct vivid_dev *dev = vb2_get_drv_priv(vq);
217 if (vb2_is_streaming(&dev->vb_vid_out_q))
218 dev->can_loop_video = vivid_vid_can_loop(dev);
220 dev->vid_cap_seq_count = 0;
221 dprintk(dev, 1, "%s\n", __func__);
223 dev->must_blank[i] = tpg_g_perc_fill(&dev->tpg) < 100;
224 if (dev->start_streaming_error) {
225 dev->start_streaming_error = false;
228 err = vivid_start_generating_vid_cap(dev, &dev->vid_cap_streaming);
233 list_for_each_entry_safe(buf, tmp, &dev->vid_cap_active, list) {
245 struct vivid_dev *dev = vb2_get_drv_priv(vq);
247 dprintk(dev, 1, "%s\n", __func__);
248 vivid_stop_generating_vid_cap(dev, &dev->vid_cap_streaming);
249 dev->can_loop_video = false;
254 struct vivid_dev *dev = vb2_get_drv_priv(vb->vb2_queue);
256 v4l2_ctrl_request_complete(vb->req_obj.req, &dev->ctrl_hdl_vid_cap);
276 void vivid_update_quality(struct vivid_dev *dev)
280 if (dev->loop_video && (vivid_is_svid_cap(dev) || vivid_is_hdmi_cap(dev))) {
285 tpg_s_quality(&dev->tpg, TPG_QUAL_NOISE, 0);
288 if (vivid_is_hdmi_cap(dev) &&
289 VIVID_INVALID_SIGNAL(dev->dv_timings_signal_mode[dev->input])) {
290 tpg_s_quality(&dev->tpg, TPG_QUAL_NOISE, 0);
293 if (vivid_is_sdtv_cap(dev) &&
294 VIVID_INVALID_SIGNAL(dev->std_signal_mode[dev->input])) {
295 tpg_s_quality(&dev->tpg, TPG_QUAL_NOISE, 0);
298 if (!vivid_is_tv_cap(dev)) {
299 tpg_s_quality(&dev->tpg, TPG_QUAL_COLOR, 0);
309 freq_modulus = (dev->tv_freq - 676 /* (43.25-1) * 16 */) % (6 * 16);
311 tpg_s_quality(&dev->tpg, TPG_QUAL_NOISE,
312 next_pseudo_random32(dev->tv_freq ^ 0x55) & 0x3f);
316 tpg_s_quality(&dev->tpg, TPG_QUAL_GRAY, 0);
318 tpg_s_quality(&dev->tpg, TPG_QUAL_COLOR, 0);
324 static enum tpg_quality vivid_get_quality(struct vivid_dev *dev, s32 *afc)
330 if (tpg_g_quality(&dev->tpg) == TPG_QUAL_COLOR ||
331 tpg_g_quality(&dev->tpg) == TPG_QUAL_NOISE)
332 return tpg_g_quality(&dev->tpg);
340 freq_modulus = (dev->tv_freq - 676 /* (43.25-1) * 16 */) % (6 * 16);
346 enum tpg_video_aspect vivid_get_video_aspect(const struct vivid_dev *dev)
348 if (vivid_is_sdtv_cap(dev))
349 return dev->std_aspect_ratio[dev->input];
351 if (vivid_is_hdmi_cap(dev))
352 return dev->dv_timings_aspect_ratio[dev->input];
357 static enum tpg_pixel_aspect vivid_get_pixel_aspect(const struct vivid_dev *dev)
359 if (vivid_is_sdtv_cap(dev))
360 return (dev->std_cap[dev->input] & V4L2_STD_525_60) ?
363 if (vivid_is_hdmi_cap(dev) &&
364 dev->src_rect.width == 720 && dev->src_rect.height <= 576)
365 return dev->src_rect.height == 480 ?
375 void vivid_update_format_cap(struct vivid_dev *dev, bool keep_controls)
377 struct v4l2_bt_timings *bt = &dev->dv_timings_cap[dev->input].bt;
382 switch (dev->input_type[dev->input]) {
385 dev->src_rect.width = webcam_sizes[dev->webcam_size_idx].width;
386 dev->src_rect.height = webcam_sizes[dev->webcam_size_idx].height;
387 dev->timeperframe_vid_cap = webcam_intervals[dev->webcam_ival_idx];
388 dev->field_cap = V4L2_FIELD_NONE;
389 tpg_s_rgb_range(&dev->tpg, V4L2_DV_RGB_RANGE_AUTO);
393 dev->field_cap = dev->tv_field_cap;
394 dev->src_rect.width = 720;
395 if (dev->std_cap[dev->input] & V4L2_STD_525_60) {
396 dev->src_rect.height = 480;
397 dev->timeperframe_vid_cap = (struct v4l2_fract) { 1001, 30000 };
398 dev->service_set_cap = V4L2_SLICED_CAPTION_525;
400 dev->src_rect.height = 576;
401 dev->timeperframe_vid_cap = (struct v4l2_fract) { 1000, 25000 };
402 dev->service_set_cap = V4L2_SLICED_WSS_625 | V4L2_SLICED_TELETEXT_B;
404 tpg_s_rgb_range(&dev->tpg, V4L2_DV_RGB_RANGE_AUTO);
407 dev->src_rect.width = bt->width;
408 dev->src_rect.height = bt->height;
410 if (dev->reduced_fps && can_reduce_fps(bt)) {
417 dev->timeperframe_vid_cap = (struct v4l2_fract) {
421 dev->field_cap = V4L2_FIELD_ALTERNATE;
423 dev->field_cap = V4L2_FIELD_NONE;
429 if (keep_controls || !dev->colorspace)
433 v4l2_ctrl_s_ctrl(dev->colorspace, VIVID_CS_170M);
435 v4l2_ctrl_s_ctrl(dev->colorspace, VIVID_CS_709);
436 v4l2_ctrl_s_ctrl(dev->real_rgb_range_cap, 1);
438 v4l2_ctrl_s_ctrl(dev->colorspace, VIVID_CS_SRGB);
439 v4l2_ctrl_s_ctrl(dev->real_rgb_range_cap, 0);
441 tpg_s_rgb_range(&dev->tpg, v4l2_ctrl_g_ctrl(dev->rgb_range_cap));
444 vivid_update_quality(dev);
445 tpg_reset_source(&dev->tpg, dev->src_rect.width, dev->src_rect.height, dev->field_cap);
446 dev->crop_cap = dev->src_rect;
447 dev->crop_bounds_cap = dev->src_rect;
448 dev->compose_cap = dev->crop_cap;
449 if (V4L2_FIELD_HAS_T_OR_B(dev->field_cap))
450 dev->compose_cap.height /= 2;
451 dev->fmt_cap_rect = dev->compose_cap;
452 tpg_s_video_aspect(&dev->tpg, vivid_get_video_aspect(dev));
453 tpg_s_pixel_aspect(&dev->tpg, vivid_get_pixel_aspect(dev));
454 tpg_update_mv_step(&dev->tpg);
463 dims[0] = roundup(dev->src_rect.width, PIXEL_ARRAY_DIV);
464 dims[1] = roundup(dev->src_rect.height, PIXEL_ARRAY_DIV);
465 v4l2_ctrl_modify_dimensions(dev->pixel_array, dims);
469 static enum v4l2_field vivid_field_cap(struct vivid_dev *dev, enum v4l2_field field)
471 if (vivid_is_sdtv_cap(dev)) {
486 if (vivid_is_hdmi_cap(dev))
487 return dev->dv_timings_cap[dev->input].bt.interlaced ?
492 static unsigned vivid_colorspace_cap(struct vivid_dev *dev)
494 if (!dev->loop_video || vivid_is_webcam(dev) || vivid_is_tv_cap(dev))
495 return tpg_g_colorspace(&dev->tpg);
496 return dev->colorspace_out;
499 static unsigned vivid_xfer_func_cap(struct vivid_dev *dev)
501 if (!dev->loop_video || vivid_is_webcam(dev) || vivid_is_tv_cap(dev))
502 return tpg_g_xfer_func(&dev->tpg);
503 return dev->xfer_func_out;
506 static unsigned vivid_ycbcr_enc_cap(struct vivid_dev *dev)
508 if (!dev->loop_video || vivid_is_webcam(dev) || vivid_is_tv_cap(dev))
509 return tpg_g_ycbcr_enc(&dev->tpg);
510 return dev->ycbcr_enc_out;
513 static unsigned int vivid_hsv_enc_cap(struct vivid_dev *dev)
515 if (!dev->loop_video || vivid_is_webcam(dev) || vivid_is_tv_cap(dev))
516 return tpg_g_hsv_enc(&dev->tpg);
517 return dev->hsv_enc_out;
520 static unsigned vivid_quantization_cap(struct vivid_dev *dev)
522 if (!dev->loop_video || vivid_is_webcam(dev) || vivid_is_tv_cap(dev))
523 return tpg_g_quantization(&dev->tpg);
524 return dev->quantization_out;
530 struct vivid_dev *dev = video_drvdata(file);
534 mp->width = dev->fmt_cap_rect.width;
535 mp->height = dev->fmt_cap_rect.height;
536 mp->field = dev->field_cap;
537 mp->pixelformat = dev->fmt_cap->fourcc;
538 mp->colorspace = vivid_colorspace_cap(dev);
539 mp->xfer_func = vivid_xfer_func_cap(dev);
540 if (dev->fmt_cap->color_enc == TGP_COLOR_ENC_HSV)
541 mp->hsv_enc = vivid_hsv_enc_cap(dev);
543 mp->ycbcr_enc = vivid_ycbcr_enc_cap(dev);
544 mp->quantization = vivid_quantization_cap(dev);
545 mp->num_planes = dev->fmt_cap->buffers;
547 mp->plane_fmt[p].bytesperline = tpg_g_bytesperline(&dev->tpg, p);
549 (tpg_g_line_width(&dev->tpg, p) * mp->height) /
550 dev->fmt_cap->vdownsampling[p] +
551 dev->fmt_cap->data_offset[p];
561 struct vivid_dev *dev = video_drvdata(file);
569 fmt = vivid_get_format(dev, mp->pixelformat);
571 dprintk(dev, 1, "Fourcc format (0x%08x) unknown.\n",
574 fmt = vivid_get_format(dev, mp->pixelformat);
577 mp->field = vivid_field_cap(dev, mp->field);
578 if (vivid_is_webcam(dev)) {
586 } else if (vivid_is_sdtv_cap(dev)) {
588 h = (dev->std_cap[dev->input] & V4L2_STD_525_60) ? 480 : 576;
590 w = dev->src_rect.width;
591 h = dev->src_rect.height;
595 if (vivid_is_webcam(dev) ||
596 (!dev->has_scaler_cap && !dev->has_crop_cap && !dev->has_compose_cap)) {
604 if (dev->has_scaler_cap && !dev->has_compose_cap) {
608 } else if (!dev->has_scaler_cap && dev->has_crop_cap && !dev->has_compose_cap) {
609 v4l2_rect_set_max_size(&r, &dev->src_rect);
610 } else if (!dev->has_scaler_cap && !dev->has_crop_cap) {
611 v4l2_rect_set_min_size(&r, &dev->src_rect);
642 mp->colorspace = vivid_colorspace_cap(dev);
645 mp->xfer_func = vivid_xfer_func_cap(dev);
649 mp->hsv_enc = vivid_hsv_enc_cap(dev);
652 mp->ycbcr_enc = vivid_ycbcr_enc_cap(dev);
654 mp->ycbcr_enc = vivid_ycbcr_enc_cap(dev);
660 mp->quantization = vivid_quantization_cap(dev);
662 mp->quantization = vivid_quantization_cap(dev);
673 struct vivid_dev *dev = video_drvdata(file);
674 struct v4l2_rect *crop = &dev->crop_cap;
675 struct v4l2_rect *compose = &dev->compose_cap;
676 struct vb2_queue *q = &dev->vb_vid_cap_q;
686 dprintk(dev, 1, "%s device busy\n", __func__);
690 dev->fmt_cap = vivid_get_format(dev, mp->pixelformat);
696 if (!vivid_is_webcam(dev) &&
697 (dev->has_scaler_cap || dev->has_crop_cap || dev->has_compose_cap)) {
700 if (dev->has_scaler_cap) {
701 if (dev->has_compose_cap)
705 if (dev->has_crop_cap && !dev->has_compose_cap) {
719 v4l2_rect_map_inside(crop, &dev->crop_bounds_cap);
720 } else if (dev->has_crop_cap) {
734 v4l2_rect_map_inside(crop, &dev->crop_bounds_cap);
736 } else if (dev->has_crop_cap && !dev->has_compose_cap) {
739 v4l2_rect_map_inside(crop, &dev->crop_bounds_cap);
743 } else if (!dev->has_crop_cap) {
748 v4l2_rect_map_inside(crop, &dev->crop_bounds_cap);
756 } else if (vivid_is_webcam(dev)) {
757 unsigned int ival_sz = webcam_ival_count(dev, dev->webcam_size_idx);
764 dev->webcam_size_idx = i;
765 if (dev->webcam_ival_idx >= ival_sz)
766 dev->webcam_ival_idx = ival_sz - 1;
767 vivid_update_format_cap(dev, false);
776 dev->fmt_cap_rect.width = mp->width;
777 dev->fmt_cap_rect.height = mp->height;
778 tpg_s_buf_height(&dev->tpg, mp->height);
779 tpg_s_fourcc(&dev->tpg, dev->fmt_cap->fourcc);
780 for (p = 0; p < tpg_g_buffers(&dev->tpg); p++)
781 tpg_s_bytesperline(&dev->tpg, p, mp->plane_fmt[p].bytesperline);
782 dev->field_cap = mp->field;
783 if (dev->field_cap == V4L2_FIELD_ALTERNATE)
784 tpg_s_field(&dev->tpg, V4L2_FIELD_TOP, true);
786 tpg_s_field(&dev->tpg, dev->field_cap, false);
787 tpg_s_crop_compose(&dev->tpg, &dev->crop_cap, &dev->compose_cap);
788 if (vivid_is_sdtv_cap(dev))
789 dev->tv_field_cap = mp->field;
790 tpg_update_mv_step(&dev->tpg);
791 dev->tpg.colorspace = mp->colorspace;
792 dev->tpg.xfer_func = mp->xfer_func;
793 if (dev->fmt_cap->color_enc == TGP_COLOR_ENC_YCBCR)
794 dev->tpg.ycbcr_enc = mp->ycbcr_enc;
796 dev->tpg.hsv_enc = mp->hsv_enc;
797 dev->tpg.quantization = mp->quantization;
805 struct vivid_dev *dev = video_drvdata(file);
807 if (!dev->multiplanar)
815 struct vivid_dev *dev = video_drvdata(file);
817 if (!dev->multiplanar)
825 struct vivid_dev *dev = video_drvdata(file);
827 if (!dev->multiplanar)
835 struct vivid_dev *dev = video_drvdata(file);
837 if (dev->multiplanar)
845 struct vivid_dev *dev = video_drvdata(file);
847 if (dev->multiplanar)
855 struct vivid_dev *dev = video_drvdata(file);
857 if (dev->multiplanar)
865 struct vivid_dev *dev = video_drvdata(file);
867 if (!dev->has_crop_cap && !dev->has_compose_cap)
871 if (vivid_is_webcam(dev))
877 if (!dev->has_crop_cap)
879 sel->r = dev->crop_cap;
883 if (!dev->has_crop_cap)
885 sel->r = dev->src_rect;
888 if (!dev->has_compose_cap)
893 if (!dev->has_compose_cap)
895 sel->r = dev->compose_cap;
898 if (!dev->has_compose_cap)
900 sel->r = dev->fmt_cap_rect;
910 struct vivid_dev *dev = video_drvdata(file);
911 struct v4l2_rect *crop = &dev->crop_cap;
912 struct v4l2_rect *compose = &dev->compose_cap;
913 unsigned factor = V4L2_FIELD_HAS_T_OR_B(dev->field_cap) ? 2 : 1;
916 if (!dev->has_crop_cap && !dev->has_compose_cap)
920 if (vivid_is_webcam(dev))
925 if (!dev->has_crop_cap)
931 v4l2_rect_set_max_size(&s->r, &dev->src_rect);
932 v4l2_rect_map_inside(&s->r, &dev->crop_bounds_cap);
935 if (dev->has_scaler_cap) {
936 struct v4l2_rect fmt = dev->fmt_cap_rect;
949 if (!dev->has_compose_cap)
951 if (!v4l2_rect_same_size(&dev->fmt_cap_rect, &fmt) &&
952 vb2_is_busy(&dev->vb_vid_cap_q))
954 if (dev->has_compose_cap) {
959 dev->fmt_cap_rect = fmt;
960 tpg_s_buf_height(&dev->tpg, fmt.height);
961 } else if (dev->has_compose_cap) {
962 struct v4l2_rect fmt = dev->fmt_cap_rect;
965 if (!v4l2_rect_same_size(&dev->fmt_cap_rect, &fmt) &&
966 vb2_is_busy(&dev->vb_vid_cap_q))
968 dev->fmt_cap_rect = fmt;
969 tpg_s_buf_height(&dev->tpg, fmt.height);
971 v4l2_rect_map_inside(compose, &dev->fmt_cap_rect);
973 if (!v4l2_rect_same_size(&s->r, &dev->fmt_cap_rect) &&
974 vb2_is_busy(&dev->vb_vid_cap_q))
976 v4l2_rect_set_size_to(&dev->fmt_cap_rect, &s->r);
978 v4l2_rect_map_inside(compose, &dev->fmt_cap_rect);
979 tpg_s_buf_height(&dev->tpg, dev->fmt_cap_rect.height);
986 if (!dev->has_compose_cap)
992 v4l2_rect_set_max_size(&s->r, &dev->fmt_cap_rect);
993 if (dev->has_scaler_cap) {
996 dev->src_rect.width * MAX_ZOOM,
997 (dev->src_rect.height / factor) * MAX_ZOOM
1001 if (dev->has_crop_cap) {
1015 v4l2_rect_map_inside(crop, &dev->crop_bounds_cap);
1017 } else if (dev->has_crop_cap) {
1020 v4l2_rect_set_max_size(&s->r, &dev->src_rect);
1022 v4l2_rect_map_inside(crop, &dev->crop_bounds_cap);
1026 v4l2_rect_set_size_to(&s->r, &dev->src_rect);
1029 v4l2_rect_map_inside(&s->r, &dev->fmt_cap_rect);
1036 tpg_s_crop_compose(&dev->tpg, crop, compose);
1043 struct vivid_dev *dev = video_drvdata(file);
1048 switch (vivid_get_pixel_aspect(dev)) {
1071 struct vivid_dev *dev = video_drvdata(file);
1073 if (inp->index >= dev->num_inputs)
1077 switch (dev->input_type[inp->index]) {
1080 dev->input_name_counter[inp->index]);
1085 dev->input_name_counter[inp->index]);
1088 if (dev->has_audio_inputs)
1094 dev->input_name_counter[inp->index]);
1096 if (dev->has_audio_inputs)
1102 dev->input_name_counter[inp->index]);
1104 if (dev->edid_blocks == 0 ||
1105 dev->dv_timings_signal_mode[dev->input] == NO_SIGNAL)
1107 else if (dev->dv_timings_signal_mode[dev->input] == NO_LOCK ||
1108 dev->dv_timings_signal_mode[dev->input] == OUT_OF_RANGE)
1112 if (dev->sensor_hflip)
1114 if (dev->sensor_vflip)
1116 if (dev->input == inp->index && vivid_is_sdtv_cap(dev)) {
1117 if (dev->std_signal_mode[dev->input] == NO_SIGNAL) {
1119 } else if (dev->std_signal_mode[dev->input] == NO_LOCK) {
1121 } else if (vivid_is_tv_cap(dev)) {
1122 switch (tpg_g_quality(&dev->tpg)) {
1139 struct vivid_dev *dev = video_drvdata(file);
1141 *i = dev->input;
1147 struct vivid_dev *dev = video_drvdata(file);
1148 struct v4l2_bt_timings *bt = &dev->dv_timings_cap[dev->input].bt;
1151 if (i >= dev->num_inputs)
1154 if (i == dev->input)
1157 if (vb2_is_busy(&dev->vb_vid_cap_q) ||
1158 vb2_is_busy(&dev->vb_vbi_cap_q) ||
1159 vb2_is_busy(&dev->vb_meta_cap_q))
1162 dev->input = i;
1163 dev->vid_cap_dev.tvnorms = 0;
1164 if (dev->input_type[i] == TV || dev->input_type[i] == SVID) {
1165 dev->tv_audio_input = (dev->input_type[i] == TV) ? 0 : 1;
1166 dev->vid_cap_dev.tvnorms = V4L2_STD_ALL;
1168 dev->vbi_cap_dev.tvnorms = dev->vid_cap_dev.tvnorms;
1169 dev->meta_cap_dev.tvnorms = dev->vid_cap_dev.tvnorms;
1170 vivid_update_format_cap(dev, false);
1172 if (dev->colorspace) {
1173 switch (dev->input_type[i]) {
1175 v4l2_ctrl_s_ctrl(dev->colorspace, VIVID_CS_SRGB);
1179 v4l2_ctrl_s_ctrl(dev->colorspace, VIVID_CS_170M);
1183 if (dev->src_rect.width == 720 && dev->src_rect.height <= 576)
1184 v4l2_ctrl_s_ctrl(dev->colorspace, VIVID_CS_170M);
1186 v4l2_ctrl_s_ctrl(dev->colorspace, VIVID_CS_709);
1188 v4l2_ctrl_s_ctrl(dev->colorspace, VIVID_CS_SRGB);
1201 brightness = 128 * i + dev->input_brightness[i];
1202 v4l2_ctrl_modify_range(dev->brightness,
1204 v4l2_ctrl_s_ctrl(dev->brightness, brightness);
1207 v4l2_ctrl_activate(dev->ctrl_dv_timings_signal_mode,
1208 vivid_is_hdmi_cap(dev));
1209 v4l2_ctrl_activate(dev->ctrl_dv_timings, vivid_is_hdmi_cap(dev) &&
1210 dev->dv_timings_signal_mode[dev->input] ==
1212 v4l2_ctrl_activate(dev->ctrl_std_signal_mode, vivid_is_sdtv_cap(dev));
1213 v4l2_ctrl_activate(dev->ctrl_standard, vivid_is_sdtv_cap(dev) &&
1214 dev->std_signal_mode[dev->input]);
1216 if (vivid_is_hdmi_cap(dev)) {
1217 v4l2_ctrl_s_ctrl(dev->ctrl_dv_timings_signal_mode,
1218 dev->dv_timings_signal_mode[dev->input]);
1219 v4l2_ctrl_s_ctrl(dev->ctrl_dv_timings,
1220 dev->query_dv_timings[dev->input]);
1221 } else if (vivid_is_sdtv_cap(dev)) {
1222 v4l2_ctrl_s_ctrl(dev->ctrl_std_signal_mode,
1223 dev->std_signal_mode[dev->input]);
1224 v4l2_ctrl_s_ctrl(dev->ctrl_standard,
1225 dev->std_signal_mode[dev->input]);
1241 struct vivid_dev *dev = video_drvdata(file);
1243 if (!vivid_is_sdtv_cap(dev))
1245 *vin = vivid_audio_inputs[dev->tv_audio_input];
1251 struct vivid_dev *dev = video_drvdata(file);
1253 if (!vivid_is_sdtv_cap(dev))
1257 dev->tv_audio_input = vin->index;
1263 struct vivid_dev *dev = video_drvdata(file);
1267 vf->frequency = dev->tv_freq;
1273 struct vivid_dev *dev = video_drvdata(file);
1277 dev->tv_freq = clamp_t(unsigned, vf->frequency, MIN_TV_FREQ, MAX_TV_FREQ);
1278 if (vivid_is_tv_cap(dev))
1279 vivid_update_quality(dev);
1285 struct vivid_dev *dev = video_drvdata(file);
1291 dev->tv_audmode = vt->audmode;
1297 struct vivid_dev *dev = video_drvdata(file);
1305 vt->audmode = dev->tv_audmode;
1308 qual = vivid_get_quality(dev, &vt->afc);
1320 unsigned int channel_nr = dev->tv_freq / (6 * 16);
1322 (dev->std_cap[dev->input] & V4L2_STD_NTSC_M) ? 4 : 3;
1332 if (dev->std_cap[dev->input] & V4L2_STD_NTSC_M)
1388 struct vivid_dev *dev = video_drvdata(file);
1389 unsigned int last = dev->query_std_last[dev->input];
1391 if (!vivid_is_sdtv_cap(dev))
1393 if (dev->std_signal_mode[dev->input] == NO_SIGNAL ||
1394 dev->std_signal_mode[dev->input] == NO_LOCK) {
1398 if (vivid_is_tv_cap(dev) && tpg_g_quality(&dev->tpg) == TPG_QUAL_NOISE) {
1400 } else if (dev->std_signal_mode[dev->input] == CURRENT_STD) {
1401 *id = dev->std_cap[dev->input];
1402 } else if (dev->std_signal_mode[dev->input] == SELECTED_STD) {
1403 *id = dev->query_std[dev->input];
1406 dev->query_std_last[dev->input] =
1415 struct vivid_dev *dev = video_drvdata(file);
1417 if (!vivid_is_sdtv_cap(dev))
1419 if (dev->std_cap[dev->input] == id)
1421 if (vb2_is_busy(&dev->vb_vid_cap_q) || vb2_is_busy(&dev->vb_vbi_cap_q))
1423 dev->std_cap[dev->input] = id;
1424 vivid_update_format_cap(dev, false);
1502 struct vivid_dev *dev = video_drvdata(file);
1504 if (!vivid_is_hdmi_cap(dev))
1511 if (v4l2_match_dv_timings(timings, &dev->dv_timings_cap[dev->input],
1514 if (vb2_is_busy(&dev->vb_vid_cap_q))
1517 dev->dv_timings_cap[dev->input] = *timings;
1518 vivid_update_format_cap(dev, false);
1525 struct vivid_dev *dev = video_drvdata(file);
1526 unsigned int input = dev->input;
1527 unsigned int last = dev->query_dv_timings_last[input];
1529 if (!vivid_is_hdmi_cap(dev))
1531 if (dev->dv_timings_signal_mode[input] == NO_SIGNAL ||
1532 dev->edid_blocks == 0)
1534 if (dev->dv_timings_signal_mode[input] == NO_LOCK)
1536 if (dev->dv_timings_signal_mode[input] == OUT_OF_RANGE) {
1540 if (dev->dv_timings_signal_mode[input] == CURRENT_DV_TIMINGS) {
1541 *timings = dev->dv_timings_cap[input];
1542 } else if (dev->dv_timings_signal_mode[input] ==
1545 v4l2_dv_timings_presets[dev->query_dv_timings[input]];
1549 dev->query_dv_timings_last[input] =
1550 (last + 1) % dev->query_dv_timings_size;
1558 struct vivid_dev *dev = video_drvdata(file);
1565 if (edid->pad >= dev->num_inputs)
1567 if (dev->input_type[edid->pad] != HDMI || edid->start_block)
1570 dev->edid_blocks = 0;
1571 if (dev->num_outputs) {
1572 v4l2_ctrl_s_ctrl(dev->ctrl_tx_edid_present, 0);
1573 v4l2_ctrl_s_ctrl(dev->ctrl_tx_hotplug, 0);
1578 if (edid->blocks > dev->edid_max_blocks) {
1579 edid->blocks = dev->edid_max_blocks;
1587 if (vb2_is_busy(&dev->vb_vid_cap_q))
1590 dev->edid_blocks = edid->blocks;
1591 memcpy(dev->edid, edid->edid, edid->blocks * 128);
1593 for (i = 0, j = 0; i < dev->num_outputs; i++)
1594 if (dev->output_type[i] == HDMI)
1596 dev->display_present[i] << j++;
1598 if (dev->num_outputs) {
1599 v4l2_ctrl_s_ctrl(dev->ctrl_tx_edid_present, display_present);
1600 v4l2_ctrl_s_ctrl(dev->ctrl_tx_hotplug, display_present);
1605 cec_s_phys_addr(dev->cec_rx_adap, phys_addr, false);
1607 for (i = 0; i < MAX_OUTPUTS && dev->cec_tx_adap[i]; i++)
1608 cec_s_phys_addr(dev->cec_tx_adap[i],
1609 dev->display_present[i] ?
1619 struct vivid_dev *dev = video_drvdata(file);
1621 if (!vivid_is_webcam(dev) && !dev->has_scaler_cap)
1623 if (vivid_get_format(dev, fsize->pixel_format) == NULL)
1625 if (vivid_is_webcam(dev)) {
1648 struct vivid_dev *dev = video_drvdata(file);
1652 fmt = vivid_get_format(dev, fival->pixel_format);
1656 if (!vivid_is_webcam(dev)) {
1664 fival->discrete = dev->timeperframe_vid_cap;
1674 if (fival->index >= webcam_ival_count(dev, i))
1684 struct vivid_dev *dev = video_drvdata(file);
1686 if (parm->type != (dev->multiplanar ?
1692 parm->parm.capture.timeperframe = dev->timeperframe_vid_cap;
1700 struct vivid_dev *dev = video_drvdata(file);
1701 unsigned int ival_sz = webcam_ival_count(dev, dev->webcam_size_idx);
1705 if (parm->type != (dev->multiplanar ?
1709 if (!vivid_is_webcam(dev))
1721 dev->webcam_ival_idx = i;
1722 tpf = webcam_intervals[dev->webcam_ival_idx];
1725 dev->cap_seq_resync = true;
1726 dev->timeperframe_vid_cap = tpf;