1 /* SPDX-License-Identifier: GPL-2.0-only */ 2 /* 3 * vivid-core.h - core datastructures 4 * 5 * Copyright 2014 Cisco Systems, Inc. and/or its affiliates. All rights reserved. 6 */ 7 8 #ifndef _VIVID_CORE_H_ 9 #define _VIVID_CORE_H_ 10 11 #include <linux/fb.h> 12 #include <linux/workqueue.h> 13 #include <media/cec.h> 14 #include <media/videobuf2-v4l2.h> 15 #include <media/v4l2-device.h> 16 #include <media/v4l2-dev.h> 17 #include <media/v4l2-ctrls.h> 18 #include <media/tpg/v4l2-tpg.h> 19 #include "vivid-rds-gen.h" 20 #include "vivid-vbi-gen.h" 21 22 #define dprintk(dev, level, fmt, arg...) \ 23 v4l2_dbg(level, vivid_debug, &dev->v4l2_dev, fmt, ## arg) 24 25 /* The maximum number of inputs */ 26 #define MAX_INPUTS 16 27 /* The maximum number of outputs */ 28 #define MAX_OUTPUTS 16 29 /* The maximum number of video capture buffers */ 30 #define MAX_VID_CAP_BUFFERS 64 31 /* The maximum up or down scaling factor is 4 */ 32 #define MAX_ZOOM 4 33 /* The maximum image width/height are set to 4K DMT */ 34 #define MAX_WIDTH 4096 35 #define MAX_HEIGHT 2160 36 /* The minimum image width/height */ 37 #define MIN_WIDTH 16 38 #define MIN_HEIGHT MIN_WIDTH 39 /* Pixel Array control divider */ 40 #define PIXEL_ARRAY_DIV MIN_WIDTH 41 /* The data_offset of plane 0 for the multiplanar formats */ 42 #define PLANE0_DATA_OFFSET 128 43 44 /* The supported TV frequency range in MHz */ 45 #define MIN_TV_FREQ (44U * 16U) 46 #define MAX_TV_FREQ (958U * 16U) 47 48 /* The number of samples returned in every SDR buffer */ 49 #define SDR_CAP_SAMPLES_PER_BUF 0x4000 50 51 /* used by the threads to know when to resync internal counters */ 52 #define JIFFIES_PER_DAY (3600U * 24U * HZ) 53 #define JIFFIES_RESYNC (JIFFIES_PER_DAY * (0xf0000000U / JIFFIES_PER_DAY)) 54 55 /* 56 * Maximum number of HDMI inputs allowed by vivid, due to limitations 57 * of the Physical Address in the EDID and used by CEC we stop at 15 58 * inputs and outputs. 59 */ 60 #define MAX_HDMI_INPUTS 15 61 #define MAX_HDMI_OUTPUTS 15 62 63 /* Maximum number of S-Video inputs allowed by vivid */ 64 #define MAX_SVID_INPUTS 16 65 66 /* The maximum number of items in a menu control */ 67 #define MAX_MENU_ITEMS BITS_PER_LONG_LONG 68 69 /* Number of fixed menu items in the 'Connected To' menu controls */ 70 #define FIXED_MENU_ITEMS 2 71 72 /* The maximum number of vivid devices */ 73 #define VIVID_MAX_DEVS CONFIG_VIDEO_VIVID_MAX_DEVS 74 75 extern const struct v4l2_rect vivid_min_rect; 76 extern const struct v4l2_rect vivid_max_rect; 77 extern unsigned vivid_debug; 78 79 /* 80 * NULL-terminated string array for the HDMI 'Connected To' menu controls 81 * with the list of possible HDMI outputs. 82 * 83 * The first two items are fixed ("TPG" and "None"). 84 */ 85 extern char *vivid_ctrl_hdmi_to_output_strings[1 + MAX_MENU_ITEMS]; 86 /* Menu control skip mask of all HDMI outputs that are in use */ 87 extern u64 hdmi_to_output_menu_skip_mask; 88 /* 89 * Bitmask of which vivid instances need to update any connected 90 * HDMI outputs. 91 */ 92 extern u64 hdmi_input_update_outputs_mask; 93 /* 94 * Spinlock for access to hdmi_to_output_menu_skip_mask and 95 * hdmi_input_update_outputs_mask. 96 */ 97 extern spinlock_t hdmi_output_skip_mask_lock; 98 /* 99 * Workqueue that updates the menu controls whenever the HDMI menu skip mask 100 * changes. 101 */ 102 extern struct workqueue_struct *update_hdmi_ctrls_workqueue; 103 104 /* 105 * The HDMI menu control value (index in the menu list) maps to an HDMI 106 * output that is part of the given vivid_dev instance and has the given 107 * output index (as returned by VIDIOC_G_OUTPUT). 108 * 109 * NULL/0 if not available. 110 */ 111 extern struct vivid_dev *vivid_ctrl_hdmi_to_output_instance[MAX_MENU_ITEMS]; 112 extern unsigned int vivid_ctrl_hdmi_to_output_index[MAX_MENU_ITEMS]; 113 114 /* 115 * NULL-terminated string array for the S-Video 'Connected To' menu controls 116 * with the list of possible S-Video outputs. 117 * 118 * The first two items are fixed ("TPG" and "None"). 119 */ 120 extern char *vivid_ctrl_svid_to_output_strings[1 + MAX_MENU_ITEMS]; 121 /* Menu control skip mask of all S-Video outputs that are in use */ 122 extern u64 svid_to_output_menu_skip_mask; 123 /* Spinlock for access to svid_to_output_menu_skip_mask */ 124 extern spinlock_t svid_output_skip_mask_lock; 125 /* 126 * Workqueue that updates the menu controls whenever the S-Video menu skip mask 127 * changes. 128 */ 129 extern struct workqueue_struct *update_svid_ctrls_workqueue; 130 131 /* 132 * The S-Video menu control value (index in the menu list) maps to an S-Video 133 * output that is part of the given vivid_dev instance and has the given 134 * output index (as returned by VIDIOC_G_OUTPUT). 135 * 136 * NULL/0 if not available. 137 */ 138 extern struct vivid_dev *vivid_ctrl_svid_to_output_instance[MAX_MENU_ITEMS]; 139 extern unsigned int vivid_ctrl_svid_to_output_index[MAX_MENU_ITEMS]; 140 141 extern struct vivid_dev *vivid_devs[VIVID_MAX_DEVS]; 142 extern unsigned int n_devs; 143 144 struct vivid_fmt { 145 u32 fourcc; /* v4l2 format id */ 146 enum tgp_color_enc color_enc; 147 bool can_do_overlay; 148 u8 vdownsampling[TPG_MAX_PLANES]; 149 u32 alpha_mask; 150 u8 planes; 151 u8 buffers; 152 u32 data_offset[TPG_MAX_PLANES]; 153 u32 bit_depth[TPG_MAX_PLANES]; 154 }; 155 156 extern struct vivid_fmt vivid_formats[]; 157 158 /* buffer for one video frame */ 159 struct vivid_buffer { 160 /* common v4l buffer stuff -- must be first */ 161 struct vb2_v4l2_buffer vb; 162 struct list_head list; 163 }; 164 165 enum vivid_input { 166 WEBCAM, 167 TV, 168 SVID, 169 HDMI, 170 }; 171 172 enum vivid_signal_mode { 173 CURRENT_DV_TIMINGS, 174 CURRENT_STD = CURRENT_DV_TIMINGS, 175 NO_SIGNAL, 176 NO_LOCK, 177 OUT_OF_RANGE, 178 SELECTED_DV_TIMINGS, 179 SELECTED_STD = SELECTED_DV_TIMINGS, 180 CYCLE_DV_TIMINGS, 181 CYCLE_STD = CYCLE_DV_TIMINGS, 182 CUSTOM_DV_TIMINGS, 183 }; 184 185 enum vivid_colorspace { 186 VIVID_CS_170M, 187 VIVID_CS_709, 188 VIVID_CS_SRGB, 189 VIVID_CS_OPRGB, 190 VIVID_CS_2020, 191 VIVID_CS_DCI_P3, 192 VIVID_CS_240M, 193 VIVID_CS_SYS_M, 194 VIVID_CS_SYS_BG, 195 }; 196 197 #define VIVID_INVALID_SIGNAL(mode) \ 198 ((mode) == NO_SIGNAL || (mode) == NO_LOCK || (mode) == OUT_OF_RANGE) 199 200 struct vivid_cec_xfer { 201 struct cec_adapter *adap; 202 u8 msg[CEC_MAX_MSG_SIZE]; 203 u32 len; 204 u32 sft; 205 }; 206 207 struct vivid_dev { 208 u8 inst; 209 struct v4l2_device v4l2_dev; 210 #ifdef CONFIG_MEDIA_CONTROLLER 211 struct media_device mdev; 212 struct media_pad vid_cap_pad; 213 struct media_pad vid_out_pad; 214 struct media_pad vbi_cap_pad; 215 struct media_pad vbi_out_pad; 216 struct media_pad sdr_cap_pad; 217 struct media_pad meta_cap_pad; 218 struct media_pad meta_out_pad; 219 struct media_pad touch_cap_pad; 220 #endif 221 struct v4l2_ctrl_handler ctrl_hdl_user_gen; 222 struct v4l2_ctrl_handler ctrl_hdl_user_vid; 223 struct v4l2_ctrl_handler ctrl_hdl_user_aud; 224 struct v4l2_ctrl_handler ctrl_hdl_streaming; 225 struct v4l2_ctrl_handler ctrl_hdl_sdtv_cap; 226 struct v4l2_ctrl_handler ctrl_hdl_loop_cap; 227 struct v4l2_ctrl_handler ctrl_hdl_fb; 228 struct video_device vid_cap_dev; 229 struct v4l2_ctrl_handler ctrl_hdl_vid_cap; 230 struct video_device vid_out_dev; 231 struct v4l2_ctrl_handler ctrl_hdl_vid_out; 232 struct video_device vbi_cap_dev; 233 struct v4l2_ctrl_handler ctrl_hdl_vbi_cap; 234 struct video_device vbi_out_dev; 235 struct v4l2_ctrl_handler ctrl_hdl_vbi_out; 236 struct video_device radio_rx_dev; 237 struct v4l2_ctrl_handler ctrl_hdl_radio_rx; 238 struct video_device radio_tx_dev; 239 struct v4l2_ctrl_handler ctrl_hdl_radio_tx; 240 struct video_device sdr_cap_dev; 241 struct v4l2_ctrl_handler ctrl_hdl_sdr_cap; 242 struct video_device meta_cap_dev; 243 struct v4l2_ctrl_handler ctrl_hdl_meta_cap; 244 struct video_device meta_out_dev; 245 struct v4l2_ctrl_handler ctrl_hdl_meta_out; 246 struct video_device touch_cap_dev; 247 struct v4l2_ctrl_handler ctrl_hdl_touch_cap; 248 249 spinlock_t slock; 250 struct mutex mutex; 251 struct work_struct update_hdmi_ctrl_work; 252 struct work_struct update_svid_ctrl_work; 253 254 /* capabilities */ 255 u32 vid_cap_caps; 256 u32 vid_out_caps; 257 u32 vbi_cap_caps; 258 u32 vbi_out_caps; 259 u32 sdr_cap_caps; 260 u32 radio_rx_caps; 261 u32 radio_tx_caps; 262 u32 meta_cap_caps; 263 u32 meta_out_caps; 264 u32 touch_cap_caps; 265 266 /* supported features */ 267 bool multiplanar; 268 u8 num_inputs; 269 u8 num_hdmi_inputs; 270 u8 num_svid_inputs; 271 u8 input_type[MAX_INPUTS]; 272 u8 input_name_counter[MAX_INPUTS]; 273 u8 num_outputs; 274 u8 num_hdmi_outputs; 275 u8 output_type[MAX_OUTPUTS]; 276 u8 output_name_counter[MAX_OUTPUTS]; 277 bool has_audio_inputs; 278 bool has_audio_outputs; 279 bool has_vid_cap; 280 bool has_vid_out; 281 bool has_vbi_cap; 282 bool has_raw_vbi_cap; 283 bool has_sliced_vbi_cap; 284 bool has_vbi_out; 285 bool has_raw_vbi_out; 286 bool has_sliced_vbi_out; 287 bool has_radio_rx; 288 bool has_radio_tx; 289 bool has_sdr_cap; 290 bool has_fb; 291 bool has_meta_cap; 292 bool has_meta_out; 293 bool has_tv_tuner; 294 bool has_touch_cap; 295 296 /* Output index (0-MAX_OUTPUTS) to vivid instance of connected input */ 297 struct vivid_dev *output_to_input_instance[MAX_OUTPUTS]; 298 /* Output index (0-MAX_OUTPUTS) to input index (0-MAX_INPUTS) of connected input */ 299 u8 output_to_input_index[MAX_OUTPUTS]; 300 /* Output index (0-MAX_OUTPUTS) to HDMI or S-Video output index (0-MAX_HDMI/SVID_OUTPUTS) */ 301 u8 output_to_iface_index[MAX_OUTPUTS]; 302 /* ctrl_hdmi_to_output or ctrl_svid_to_output control value for each input */ 303 s32 input_is_connected_to_output[MAX_INPUTS]; 304 /* HDMI index (0-MAX_HDMI_OUTPUTS) to output index (0-MAX_OUTPUTS) */ 305 u8 hdmi_index_to_output_index[MAX_HDMI_OUTPUTS]; 306 /* HDMI index (0-MAX_HDMI_INPUTS) to input index (0-MAX_INPUTS) */ 307 u8 hdmi_index_to_input_index[MAX_HDMI_INPUTS]; 308 /* S-Video index (0-MAX_SVID_INPUTS) to input index (0-MAX_INPUTS) */ 309 u8 svid_index_to_input_index[MAX_SVID_INPUTS]; 310 311 /* controls */ 312 struct v4l2_ctrl *brightness; 313 struct v4l2_ctrl *contrast; 314 struct v4l2_ctrl *saturation; 315 struct v4l2_ctrl *hue; 316 struct { 317 /* autogain/gain cluster */ 318 struct v4l2_ctrl *autogain; 319 struct v4l2_ctrl *gain; 320 }; 321 struct v4l2_ctrl *volume; 322 struct v4l2_ctrl *mute; 323 struct v4l2_ctrl *alpha; 324 struct v4l2_ctrl *button; 325 struct v4l2_ctrl *boolean; 326 struct v4l2_ctrl *int32; 327 struct v4l2_ctrl *int64; 328 struct v4l2_ctrl *menu; 329 struct v4l2_ctrl *string; 330 struct v4l2_ctrl *bitmask; 331 struct v4l2_ctrl *int_menu; 332 struct v4l2_ctrl *ro_int32; 333 struct v4l2_ctrl *pixel_array; 334 struct v4l2_ctrl *test_pattern; 335 struct v4l2_ctrl *colorspace; 336 struct v4l2_ctrl *rgb_range_cap; 337 struct v4l2_ctrl *real_rgb_range_cap; 338 struct { 339 /* std_signal_mode/standard cluster */ 340 struct v4l2_ctrl *ctrl_std_signal_mode; 341 struct v4l2_ctrl *ctrl_standard; 342 }; 343 struct { 344 /* dv_timings_signal_mode/timings cluster */ 345 struct v4l2_ctrl *ctrl_dv_timings_signal_mode; 346 struct v4l2_ctrl *ctrl_dv_timings; 347 }; 348 struct v4l2_ctrl *ctrl_has_crop_cap; 349 struct v4l2_ctrl *ctrl_has_compose_cap; 350 struct v4l2_ctrl *ctrl_has_scaler_cap; 351 struct v4l2_ctrl *ctrl_has_crop_out; 352 struct v4l2_ctrl *ctrl_has_compose_out; 353 struct v4l2_ctrl *ctrl_has_scaler_out; 354 struct v4l2_ctrl *ctrl_tx_mode; 355 struct v4l2_ctrl *ctrl_tx_rgb_range; 356 struct v4l2_ctrl *ctrl_tx_edid_present; 357 struct v4l2_ctrl *ctrl_tx_hotplug; 358 struct v4l2_ctrl *ctrl_tx_rxsense; 359 360 struct v4l2_ctrl *ctrl_rx_power_present; 361 362 struct v4l2_ctrl *radio_tx_rds_pi; 363 struct v4l2_ctrl *radio_tx_rds_pty; 364 struct v4l2_ctrl *radio_tx_rds_mono_stereo; 365 struct v4l2_ctrl *radio_tx_rds_art_head; 366 struct v4l2_ctrl *radio_tx_rds_compressed; 367 struct v4l2_ctrl *radio_tx_rds_dyn_pty; 368 struct v4l2_ctrl *radio_tx_rds_ta; 369 struct v4l2_ctrl *radio_tx_rds_tp; 370 struct v4l2_ctrl *radio_tx_rds_ms; 371 struct v4l2_ctrl *radio_tx_rds_psname; 372 struct v4l2_ctrl *radio_tx_rds_radiotext; 373 374 struct v4l2_ctrl *radio_rx_rds_pty; 375 struct v4l2_ctrl *radio_rx_rds_ta; 376 struct v4l2_ctrl *radio_rx_rds_tp; 377 struct v4l2_ctrl *radio_rx_rds_ms; 378 struct v4l2_ctrl *radio_rx_rds_psname; 379 struct v4l2_ctrl *radio_rx_rds_radiotext; 380 381 struct v4l2_ctrl *ctrl_hdmi_to_output[MAX_HDMI_INPUTS]; 382 char ctrl_hdmi_to_output_names[MAX_HDMI_INPUTS][32]; 383 struct v4l2_ctrl *ctrl_svid_to_output[MAX_SVID_INPUTS]; 384 char ctrl_svid_to_output_names[MAX_SVID_INPUTS][32]; 385 386 unsigned input_brightness[MAX_INPUTS]; 387 unsigned osd_mode; 388 unsigned button_pressed; 389 bool sensor_hflip; 390 bool sensor_vflip; 391 bool hflip; 392 bool vflip; 393 bool vbi_cap_interlaced; 394 bool loop_video; 395 bool reduced_fps; 396 397 /* Framebuffer */ 398 unsigned long video_pbase; 399 void *video_vbase; 400 u32 video_buffer_size; 401 int display_width; 402 int display_height; 403 int display_byte_stride; 404 int bits_per_pixel; 405 int bytes_per_pixel; 406 struct fb_info fb_info; 407 struct fb_var_screeninfo fb_defined; 408 struct fb_fix_screeninfo fb_fix; 409 410 /* Error injection */ 411 bool disconnect_error; 412 bool queue_setup_error; 413 bool buf_prepare_error; 414 bool start_streaming_error; 415 bool dqbuf_error; 416 bool req_validate_error; 417 bool seq_wrap; 418 u64 time_wrap; 419 u64 time_wrap_offset; 420 unsigned perc_dropped_buffers; 421 enum vivid_signal_mode std_signal_mode[MAX_INPUTS]; 422 unsigned int query_std_last[MAX_INPUTS]; 423 v4l2_std_id query_std[MAX_INPUTS]; 424 enum tpg_video_aspect std_aspect_ratio[MAX_INPUTS]; 425 426 enum vivid_signal_mode dv_timings_signal_mode[MAX_INPUTS]; 427 char **query_dv_timings_qmenu; 428 char *query_dv_timings_qmenu_strings; 429 unsigned query_dv_timings_size; 430 unsigned int query_dv_timings_last[MAX_INPUTS]; 431 unsigned int query_dv_timings[MAX_INPUTS]; 432 enum tpg_video_aspect dv_timings_aspect_ratio[MAX_INPUTS]; 433 434 /* Input */ 435 unsigned input; 436 v4l2_std_id std_cap[MAX_INPUTS]; 437 struct v4l2_dv_timings dv_timings_cap[MAX_INPUTS]; 438 int dv_timings_cap_sel[MAX_INPUTS]; 439 u32 service_set_cap; 440 struct vivid_vbi_gen_data vbi_gen; 441 u8 *edid; 442 unsigned edid_blocks; 443 unsigned edid_max_blocks; 444 unsigned webcam_size_idx; 445 unsigned webcam_ival_idx; 446 unsigned tv_freq; 447 unsigned tv_audmode; 448 unsigned tv_field_cap; 449 unsigned tv_audio_input; 450 451 u32 power_present; 452 453 /* Output */ 454 unsigned output; 455 v4l2_std_id std_out; 456 struct v4l2_dv_timings dv_timings_out; 457 u32 colorspace_out; 458 u32 ycbcr_enc_out; 459 u32 hsv_enc_out; 460 u32 quantization_out; 461 u32 xfer_func_out; 462 u32 service_set_out; 463 unsigned bytesperline_out[TPG_MAX_PLANES]; 464 unsigned tv_field_out; 465 unsigned tv_audio_output; 466 bool vbi_out_have_wss; 467 u8 vbi_out_wss[2]; 468 bool vbi_out_have_cc[2]; 469 u8 vbi_out_cc[2][2]; 470 bool dvi_d_out; 471 u8 *scaled_line; 472 u8 *blended_line; 473 unsigned cur_scaled_line; 474 475 /* Output Overlay */ 476 void *fb_vbase_out; 477 bool overlay_out_enabled; 478 int overlay_out_top, overlay_out_left; 479 unsigned fbuf_out_flags; 480 u32 chromakey_out; 481 u8 global_alpha_out; 482 483 /* video capture */ 484 struct tpg_data tpg; 485 unsigned ms_vid_cap; 486 bool must_blank[MAX_VID_CAP_BUFFERS]; 487 488 const struct vivid_fmt *fmt_cap; 489 struct v4l2_fract timeperframe_vid_cap; 490 enum v4l2_field field_cap; 491 struct v4l2_rect src_rect; 492 struct v4l2_rect fmt_cap_rect; 493 struct v4l2_rect crop_cap; 494 struct v4l2_rect compose_cap; 495 struct v4l2_rect crop_bounds_cap; 496 struct vb2_queue vb_vid_cap_q; 497 struct list_head vid_cap_active; 498 struct vb2_queue vb_vbi_cap_q; 499 struct list_head vbi_cap_active; 500 struct vb2_queue vb_meta_cap_q; 501 struct list_head meta_cap_active; 502 struct vb2_queue vb_touch_cap_q; 503 struct list_head touch_cap_active; 504 505 /* thread for generating video capture stream */ 506 struct task_struct *kthread_vid_cap; 507 unsigned long jiffies_vid_cap; 508 u64 cap_stream_start; 509 u64 cap_frame_period; 510 u64 cap_frame_eof_offset; 511 u32 cap_seq_offset; 512 u32 cap_seq_count; 513 bool cap_seq_resync; 514 u32 vid_cap_seq_start; 515 u32 vid_cap_seq_count; 516 bool vid_cap_streaming; 517 u32 vbi_cap_seq_start; 518 u32 vbi_cap_seq_count; 519 bool vbi_cap_streaming; 520 u32 meta_cap_seq_start; 521 u32 meta_cap_seq_count; 522 bool meta_cap_streaming; 523 524 /* Touch capture */ 525 struct task_struct *kthread_touch_cap; 526 unsigned long jiffies_touch_cap; 527 u64 touch_cap_stream_start; 528 u32 touch_cap_seq_offset; 529 bool touch_cap_seq_resync; 530 u32 touch_cap_seq_start; 531 u32 touch_cap_seq_count; 532 u32 touch_cap_with_seq_wrap_count; 533 bool touch_cap_streaming; 534 struct v4l2_fract timeperframe_tch_cap; 535 struct v4l2_pix_format tch_format; 536 int tch_pat_random; 537 538 /* video output */ 539 const struct vivid_fmt *fmt_out; 540 struct v4l2_fract timeperframe_vid_out; 541 enum v4l2_field field_out; 542 struct v4l2_rect sink_rect; 543 struct v4l2_rect fmt_out_rect; 544 struct v4l2_rect crop_out; 545 struct v4l2_rect compose_out; 546 struct v4l2_rect compose_bounds_out; 547 struct vb2_queue vb_vid_out_q; 548 struct list_head vid_out_active; 549 struct vb2_queue vb_vbi_out_q; 550 struct list_head vbi_out_active; 551 struct vb2_queue vb_meta_out_q; 552 struct list_head meta_out_active; 553 554 /* video loop precalculated rectangles */ 555 556 /* 557 * Intersection between what the output side composes and the capture side 558 * crops. I.e., what actually needs to be copied from the output buffer to 559 * the capture buffer. 560 */ 561 struct v4l2_rect loop_vid_copy; 562 /* The part of the output buffer that (after scaling) corresponds to loop_vid_copy. */ 563 struct v4l2_rect loop_vid_out; 564 /* The part of the capture buffer that (after scaling) corresponds to loop_vid_copy. */ 565 struct v4l2_rect loop_vid_cap; 566 /* 567 * The intersection of the framebuffer, the overlay output window and 568 * loop_vid_copy. I.e., the part of the framebuffer that actually should be 569 * blended with the compose_out rectangle. This uses the framebuffer origin. 570 */ 571 struct v4l2_rect loop_fb_copy; 572 /* The same as loop_fb_copy but with compose_out origin. */ 573 struct v4l2_rect loop_vid_overlay; 574 /* 575 * The part of the capture buffer that (after scaling) corresponds 576 * to loop_vid_overlay. 577 */ 578 struct v4l2_rect loop_vid_overlay_cap; 579 580 /* thread for generating video output stream */ 581 struct task_struct *kthread_vid_out; 582 unsigned long jiffies_vid_out; 583 u32 out_seq_offset; 584 u32 out_seq_count; 585 bool out_seq_resync; 586 u32 vid_out_seq_start; 587 u32 vid_out_seq_count; 588 bool vid_out_streaming; 589 u32 vbi_out_seq_start; 590 u32 vbi_out_seq_count; 591 bool vbi_out_streaming; 592 bool stream_sliced_vbi_out; 593 u32 meta_out_seq_start; 594 u32 meta_out_seq_count; 595 bool meta_out_streaming; 596 597 /* SDR capture */ 598 struct vb2_queue vb_sdr_cap_q; 599 struct list_head sdr_cap_active; 600 u32 sdr_pixelformat; /* v4l2 format id */ 601 unsigned sdr_buffersize; 602 unsigned sdr_adc_freq; 603 unsigned sdr_fm_freq; 604 unsigned sdr_fm_deviation; 605 int sdr_fixp_src_phase; 606 int sdr_fixp_mod_phase; 607 608 bool tstamp_src_is_soe; 609 bool has_crop_cap; 610 bool has_compose_cap; 611 bool has_scaler_cap; 612 bool has_crop_out; 613 bool has_compose_out; 614 bool has_scaler_out; 615 616 /* thread for generating SDR stream */ 617 struct task_struct *kthread_sdr_cap; 618 unsigned long jiffies_sdr_cap; 619 u32 sdr_cap_seq_offset; 620 u32 sdr_cap_seq_start; 621 u32 sdr_cap_seq_count; 622 u32 sdr_cap_with_seq_wrap_count; 623 bool sdr_cap_seq_resync; 624 625 /* RDS generator */ 626 struct vivid_rds_gen rds_gen; 627 628 /* Radio receiver */ 629 unsigned radio_rx_freq; 630 unsigned radio_rx_audmode; 631 int radio_rx_sig_qual; 632 unsigned radio_rx_hw_seek_mode; 633 bool radio_rx_hw_seek_prog_lim; 634 bool radio_rx_rds_controls; 635 bool radio_rx_rds_enabled; 636 unsigned radio_rx_rds_use_alternates; 637 unsigned radio_rx_rds_last_block; 638 struct v4l2_fh *radio_rx_rds_owner; 639 640 /* Radio transmitter */ 641 unsigned radio_tx_freq; 642 unsigned radio_tx_subchans; 643 bool radio_tx_rds_controls; 644 unsigned radio_tx_rds_last_block; 645 struct v4l2_fh *radio_tx_rds_owner; 646 647 /* Shared between radio receiver and transmitter */ 648 bool radio_rds_loop; 649 ktime_t radio_rds_init_time; 650 651 /* CEC */ 652 struct cec_adapter *cec_rx_adap; 653 struct cec_adapter *cec_tx_adap[MAX_HDMI_OUTPUTS]; 654 struct task_struct *kthread_cec; 655 wait_queue_head_t kthread_waitq_cec; 656 struct vivid_cec_xfer xfers[MAX_OUTPUTS]; 657 spinlock_t cec_xfers_slock; /* read and write cec messages */ 658 u32 cec_sft; /* bus signal free time, in bit periods */ 659 u8 last_initiator; 660 661 /* CEC OSD String */ 662 char osd[14]; 663 unsigned long osd_jiffies; 664 665 bool meta_pts; 666 bool meta_scr; 667 }; 668 vivid_is_webcam(const struct vivid_dev * dev)669 static inline bool vivid_is_webcam(const struct vivid_dev *dev) 670 { 671 return dev->input_type[dev->input] == WEBCAM; 672 } 673 vivid_is_tv_cap(const struct vivid_dev * dev)674 static inline bool vivid_is_tv_cap(const struct vivid_dev *dev) 675 { 676 return dev->input_type[dev->input] == TV; 677 } 678 vivid_is_svid_cap(const struct vivid_dev * dev)679 static inline bool vivid_is_svid_cap(const struct vivid_dev *dev) 680 { 681 return dev->input_type[dev->input] == SVID; 682 } 683 vivid_is_hdmi_cap(const struct vivid_dev * dev)684 static inline bool vivid_is_hdmi_cap(const struct vivid_dev *dev) 685 { 686 return dev->input_type[dev->input] == HDMI; 687 } 688 vivid_is_sdtv_cap(const struct vivid_dev * dev)689 static inline bool vivid_is_sdtv_cap(const struct vivid_dev *dev) 690 { 691 return vivid_is_tv_cap(dev) || vivid_is_svid_cap(dev); 692 } 693 vivid_is_svid_out(const struct vivid_dev * dev)694 static inline bool vivid_is_svid_out(const struct vivid_dev *dev) 695 { 696 return dev->output_type[dev->output] == SVID; 697 } 698 vivid_is_hdmi_out(const struct vivid_dev * dev)699 static inline bool vivid_is_hdmi_out(const struct vivid_dev *dev) 700 { 701 return dev->output_type[dev->output] == HDMI; 702 } 703 704 #endif 705