1/* 2 * vivid-core.h - core datastructures 3 * 4 * Copyright 2014 Cisco Systems, Inc. and/or its affiliates. All rights reserved. 5 * 6 * This program is free software; you may redistribute it and/or modify 7 * it under the terms of the GNU General Public License as published by 8 * the Free Software Foundation; version 2 of the License. 9 * 10 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 11 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 12 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 13 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS 14 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN 15 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 16 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 17 * SOFTWARE. 18 */ 19 20#ifndef _VIVID_CORE_H_ 21#define _VIVID_CORE_H_ 22 23#include <linux/fb.h> 24#include <media/videobuf2-core.h> 25#include <media/v4l2-device.h> 26#include <media/v4l2-dev.h> 27#include <media/v4l2-ctrls.h> 28#include "vivid-tpg.h" 29#include "vivid-rds-gen.h" 30#include "vivid-vbi-gen.h" 31 32#define dprintk(dev, level, fmt, arg...) \ 33 v4l2_dbg(level, vivid_debug, &dev->v4l2_dev, fmt, ## arg) 34 35/* Maximum allowed frame rate 36 * 37 * vivid will allow setting timeperframe in [1/FPS_MAX - FPS_MAX/1] range. 38 * 39 * Ideally FPS_MAX should be infinity, i.e. practically UINT_MAX, but that 40 * might hit application errors when they manipulate these values. 41 * 42 * Besides, for tpf < 10ms image-generation logic should be changed, to avoid 43 * producing frames with equal content. 44 */ 45#define FPS_MAX 100 46 47/* The maximum number of clip rectangles */ 48#define MAX_CLIPS 16 49/* The maximum number of inputs */ 50#define MAX_INPUTS 16 51/* The maximum number of outputs */ 52#define MAX_OUTPUTS 16 53/* The maximum up or down scaling factor is 4 */ 54#define MAX_ZOOM 4 55/* The maximum image width/height are set to 4K DMT */ 56#define MAX_WIDTH 4096 57#define MAX_HEIGHT 2160 58/* The minimum image width/height */ 59#define MIN_WIDTH 16 60#define MIN_HEIGHT 16 61/* The data_offset of plane 0 for the multiplanar formats */ 62#define PLANE0_DATA_OFFSET 128 63 64/* The supported TV frequency range in MHz */ 65#define MIN_TV_FREQ (44U * 16U) 66#define MAX_TV_FREQ (958U * 16U) 67 68/* The number of samples returned in every SDR buffer */ 69#define SDR_CAP_SAMPLES_PER_BUF 0x4000 70 71/* used by the threads to know when to resync internal counters */ 72#define JIFFIES_PER_DAY (3600U * 24U * HZ) 73#define JIFFIES_RESYNC (JIFFIES_PER_DAY * (0xf0000000U / JIFFIES_PER_DAY)) 74 75extern const struct v4l2_rect vivid_min_rect; 76extern const struct v4l2_rect vivid_max_rect; 77extern unsigned vivid_debug; 78 79struct vivid_fmt { 80 const char *name; 81 u32 fourcc; /* v4l2 format id */ 82 bool is_yuv; 83 bool can_do_overlay; 84 u8 vdownsampling[TPG_MAX_PLANES]; 85 u32 alpha_mask; 86 u8 planes; 87 u8 buffers; 88 u32 data_offset[TPG_MAX_PLANES]; 89 u32 bit_depth[TPG_MAX_PLANES]; 90}; 91 92extern struct vivid_fmt vivid_formats[]; 93 94/* buffer for one video frame */ 95struct vivid_buffer { 96 /* common v4l buffer stuff -- must be first */ 97 struct vb2_buffer vb; 98 struct list_head list; 99}; 100 101enum vivid_input { 102 WEBCAM, 103 TV, 104 SVID, 105 HDMI, 106}; 107 108enum vivid_signal_mode { 109 CURRENT_DV_TIMINGS, 110 CURRENT_STD = CURRENT_DV_TIMINGS, 111 NO_SIGNAL, 112 NO_LOCK, 113 OUT_OF_RANGE, 114 SELECTED_DV_TIMINGS, 115 SELECTED_STD = SELECTED_DV_TIMINGS, 116 CYCLE_DV_TIMINGS, 117 CYCLE_STD = CYCLE_DV_TIMINGS, 118 CUSTOM_DV_TIMINGS, 119}; 120 121enum vivid_colorspace { 122 VIVID_CS_170M, 123 VIVID_CS_709, 124 VIVID_CS_SRGB, 125 VIVID_CS_ADOBERGB, 126 VIVID_CS_2020, 127 VIVID_CS_240M, 128 VIVID_CS_SYS_M, 129 VIVID_CS_SYS_BG, 130}; 131 132#define VIVID_INVALID_SIGNAL(mode) \ 133 ((mode) == NO_SIGNAL || (mode) == NO_LOCK || (mode) == OUT_OF_RANGE) 134 135struct vivid_dev { 136 unsigned inst; 137 struct v4l2_device v4l2_dev; 138 struct v4l2_ctrl_handler ctrl_hdl_user_gen; 139 struct v4l2_ctrl_handler ctrl_hdl_user_vid; 140 struct v4l2_ctrl_handler ctrl_hdl_user_aud; 141 struct v4l2_ctrl_handler ctrl_hdl_streaming; 142 struct v4l2_ctrl_handler ctrl_hdl_sdtv_cap; 143 struct v4l2_ctrl_handler ctrl_hdl_loop_out; 144 struct video_device vid_cap_dev; 145 struct v4l2_ctrl_handler ctrl_hdl_vid_cap; 146 struct video_device vid_out_dev; 147 struct v4l2_ctrl_handler ctrl_hdl_vid_out; 148 struct video_device vbi_cap_dev; 149 struct v4l2_ctrl_handler ctrl_hdl_vbi_cap; 150 struct video_device vbi_out_dev; 151 struct v4l2_ctrl_handler ctrl_hdl_vbi_out; 152 struct video_device radio_rx_dev; 153 struct v4l2_ctrl_handler ctrl_hdl_radio_rx; 154 struct video_device radio_tx_dev; 155 struct v4l2_ctrl_handler ctrl_hdl_radio_tx; 156 struct video_device sdr_cap_dev; 157 struct v4l2_ctrl_handler ctrl_hdl_sdr_cap; 158 spinlock_t slock; 159 struct mutex mutex; 160 161 /* capabilities */ 162 u32 vid_cap_caps; 163 u32 vid_out_caps; 164 u32 vbi_cap_caps; 165 u32 vbi_out_caps; 166 u32 sdr_cap_caps; 167 u32 radio_rx_caps; 168 u32 radio_tx_caps; 169 170 /* supported features */ 171 bool multiplanar; 172 unsigned num_inputs; 173 u8 input_type[MAX_INPUTS]; 174 u8 input_name_counter[MAX_INPUTS]; 175 unsigned num_outputs; 176 u8 output_type[MAX_OUTPUTS]; 177 u8 output_name_counter[MAX_OUTPUTS]; 178 bool has_audio_inputs; 179 bool has_audio_outputs; 180 bool has_vid_cap; 181 bool has_vid_out; 182 bool has_vbi_cap; 183 bool has_raw_vbi_cap; 184 bool has_sliced_vbi_cap; 185 bool has_vbi_out; 186 bool has_raw_vbi_out; 187 bool has_sliced_vbi_out; 188 bool has_radio_rx; 189 bool has_radio_tx; 190 bool has_sdr_cap; 191 bool has_fb; 192 193 bool can_loop_video; 194 195 /* controls */ 196 struct v4l2_ctrl *brightness; 197 struct v4l2_ctrl *contrast; 198 struct v4l2_ctrl *saturation; 199 struct v4l2_ctrl *hue; 200 struct { 201 /* autogain/gain cluster */ 202 struct v4l2_ctrl *autogain; 203 struct v4l2_ctrl *gain; 204 }; 205 struct v4l2_ctrl *volume; 206 struct v4l2_ctrl *mute; 207 struct v4l2_ctrl *alpha; 208 struct v4l2_ctrl *button; 209 struct v4l2_ctrl *boolean; 210 struct v4l2_ctrl *int32; 211 struct v4l2_ctrl *int64; 212 struct v4l2_ctrl *menu; 213 struct v4l2_ctrl *string; 214 struct v4l2_ctrl *bitmask; 215 struct v4l2_ctrl *int_menu; 216 struct v4l2_ctrl *test_pattern; 217 struct v4l2_ctrl *colorspace; 218 struct v4l2_ctrl *rgb_range_cap; 219 struct v4l2_ctrl *real_rgb_range_cap; 220 struct { 221 /* std_signal_mode/standard cluster */ 222 struct v4l2_ctrl *ctrl_std_signal_mode; 223 struct v4l2_ctrl *ctrl_standard; 224 }; 225 struct { 226 /* dv_timings_signal_mode/timings cluster */ 227 struct v4l2_ctrl *ctrl_dv_timings_signal_mode; 228 struct v4l2_ctrl *ctrl_dv_timings; 229 }; 230 struct v4l2_ctrl *ctrl_has_crop_cap; 231 struct v4l2_ctrl *ctrl_has_compose_cap; 232 struct v4l2_ctrl *ctrl_has_scaler_cap; 233 struct v4l2_ctrl *ctrl_has_crop_out; 234 struct v4l2_ctrl *ctrl_has_compose_out; 235 struct v4l2_ctrl *ctrl_has_scaler_out; 236 struct v4l2_ctrl *ctrl_tx_mode; 237 struct v4l2_ctrl *ctrl_tx_rgb_range; 238 239 struct v4l2_ctrl *radio_tx_rds_pi; 240 struct v4l2_ctrl *radio_tx_rds_pty; 241 struct v4l2_ctrl *radio_tx_rds_mono_stereo; 242 struct v4l2_ctrl *radio_tx_rds_art_head; 243 struct v4l2_ctrl *radio_tx_rds_compressed; 244 struct v4l2_ctrl *radio_tx_rds_dyn_pty; 245 struct v4l2_ctrl *radio_tx_rds_ta; 246 struct v4l2_ctrl *radio_tx_rds_tp; 247 struct v4l2_ctrl *radio_tx_rds_ms; 248 struct v4l2_ctrl *radio_tx_rds_psname; 249 struct v4l2_ctrl *radio_tx_rds_radiotext; 250 251 struct v4l2_ctrl *radio_rx_rds_pty; 252 struct v4l2_ctrl *radio_rx_rds_ta; 253 struct v4l2_ctrl *radio_rx_rds_tp; 254 struct v4l2_ctrl *radio_rx_rds_ms; 255 struct v4l2_ctrl *radio_rx_rds_psname; 256 struct v4l2_ctrl *radio_rx_rds_radiotext; 257 258 unsigned input_brightness[MAX_INPUTS]; 259 unsigned osd_mode; 260 unsigned button_pressed; 261 bool sensor_hflip; 262 bool sensor_vflip; 263 bool hflip; 264 bool vflip; 265 bool vbi_cap_interlaced; 266 bool loop_video; 267 268 /* Framebuffer */ 269 unsigned long video_pbase; 270 void *video_vbase; 271 u32 video_buffer_size; 272 int display_width; 273 int display_height; 274 int display_byte_stride; 275 int bits_per_pixel; 276 int bytes_per_pixel; 277 struct fb_info fb_info; 278 struct fb_var_screeninfo fb_defined; 279 struct fb_fix_screeninfo fb_fix; 280 281 /* Error injection */ 282 bool queue_setup_error; 283 bool buf_prepare_error; 284 bool start_streaming_error; 285 bool dqbuf_error; 286 bool seq_wrap; 287 bool time_wrap; 288 __kernel_time_t time_wrap_offset; 289 unsigned perc_dropped_buffers; 290 enum vivid_signal_mode std_signal_mode; 291 unsigned query_std_last; 292 v4l2_std_id query_std; 293 enum tpg_video_aspect std_aspect_ratio; 294 295 enum vivid_signal_mode dv_timings_signal_mode; 296 char **query_dv_timings_qmenu; 297 unsigned query_dv_timings_size; 298 unsigned query_dv_timings_last; 299 unsigned query_dv_timings; 300 enum tpg_video_aspect dv_timings_aspect_ratio; 301 302 /* Input */ 303 unsigned input; 304 v4l2_std_id std_cap; 305 struct v4l2_dv_timings dv_timings_cap; 306 u32 service_set_cap; 307 struct vivid_vbi_gen_data vbi_gen; 308 u8 *edid; 309 unsigned edid_blocks; 310 unsigned edid_max_blocks; 311 unsigned webcam_size_idx; 312 unsigned webcam_ival_idx; 313 unsigned tv_freq; 314 unsigned tv_audmode; 315 unsigned tv_field_cap; 316 unsigned tv_audio_input; 317 318 /* Capture Overlay */ 319 struct v4l2_framebuffer fb_cap; 320 struct v4l2_fh *overlay_cap_owner; 321 void *fb_vbase_cap; 322 int overlay_cap_top, overlay_cap_left; 323 enum v4l2_field overlay_cap_field; 324 void *bitmap_cap; 325 struct v4l2_clip clips_cap[MAX_CLIPS]; 326 struct v4l2_clip try_clips_cap[MAX_CLIPS]; 327 unsigned clipcount_cap; 328 329 /* Output */ 330 unsigned output; 331 v4l2_std_id std_out; 332 struct v4l2_dv_timings dv_timings_out; 333 u32 colorspace_out; 334 u32 ycbcr_enc_out; 335 u32 quantization_out; 336 u32 service_set_out; 337 unsigned bytesperline_out[TPG_MAX_PLANES]; 338 unsigned tv_field_out; 339 unsigned tv_audio_output; 340 bool vbi_out_have_wss; 341 u8 vbi_out_wss[2]; 342 bool vbi_out_have_cc[2]; 343 u8 vbi_out_cc[2][2]; 344 bool dvi_d_out; 345 u8 *scaled_line; 346 u8 *blended_line; 347 unsigned cur_scaled_line; 348 349 /* Output Overlay */ 350 void *fb_vbase_out; 351 bool overlay_out_enabled; 352 int overlay_out_top, overlay_out_left; 353 void *bitmap_out; 354 struct v4l2_clip clips_out[MAX_CLIPS]; 355 struct v4l2_clip try_clips_out[MAX_CLIPS]; 356 unsigned clipcount_out; 357 unsigned fbuf_out_flags; 358 u32 chromakey_out; 359 u8 global_alpha_out; 360 361 /* video capture */ 362 struct tpg_data tpg; 363 unsigned ms_vid_cap; 364 bool must_blank[VIDEO_MAX_FRAME]; 365 366 const struct vivid_fmt *fmt_cap; 367 struct v4l2_fract timeperframe_vid_cap; 368 enum v4l2_field field_cap; 369 struct v4l2_rect src_rect; 370 struct v4l2_rect fmt_cap_rect; 371 struct v4l2_rect crop_cap; 372 struct v4l2_rect compose_cap; 373 struct v4l2_rect crop_bounds_cap; 374 struct vb2_queue vb_vid_cap_q; 375 struct list_head vid_cap_active; 376 struct vb2_queue vb_vbi_cap_q; 377 struct list_head vbi_cap_active; 378 379 /* thread for generating video capture stream */ 380 struct task_struct *kthread_vid_cap; 381 unsigned long jiffies_vid_cap; 382 u32 cap_seq_offset; 383 u32 cap_seq_count; 384 bool cap_seq_resync; 385 u32 vid_cap_seq_start; 386 u32 vid_cap_seq_count; 387 bool vid_cap_streaming; 388 u32 vbi_cap_seq_start; 389 u32 vbi_cap_seq_count; 390 bool vbi_cap_streaming; 391 bool stream_sliced_vbi_cap; 392 393 /* video output */ 394 const struct vivid_fmt *fmt_out; 395 struct v4l2_fract timeperframe_vid_out; 396 enum v4l2_field field_out; 397 struct v4l2_rect sink_rect; 398 struct v4l2_rect fmt_out_rect; 399 struct v4l2_rect crop_out; 400 struct v4l2_rect compose_out; 401 struct v4l2_rect compose_bounds_out; 402 struct vb2_queue vb_vid_out_q; 403 struct list_head vid_out_active; 404 struct vb2_queue vb_vbi_out_q; 405 struct list_head vbi_out_active; 406 407 /* video loop precalculated rectangles */ 408 409 /* 410 * Intersection between what the output side composes and the capture side 411 * crops. I.e., what actually needs to be copied from the output buffer to 412 * the capture buffer. 413 */ 414 struct v4l2_rect loop_vid_copy; 415 /* The part of the output buffer that (after scaling) corresponds to loop_vid_copy. */ 416 struct v4l2_rect loop_vid_out; 417 /* The part of the capture buffer that (after scaling) corresponds to loop_vid_copy. */ 418 struct v4l2_rect loop_vid_cap; 419 /* 420 * The intersection of the framebuffer, the overlay output window and 421 * loop_vid_copy. I.e., the part of the framebuffer that actually should be 422 * blended with the compose_out rectangle. This uses the framebuffer origin. 423 */ 424 struct v4l2_rect loop_fb_copy; 425 /* The same as loop_fb_copy but with compose_out origin. */ 426 struct v4l2_rect loop_vid_overlay; 427 /* 428 * The part of the capture buffer that (after scaling) corresponds 429 * to loop_vid_overlay. 430 */ 431 struct v4l2_rect loop_vid_overlay_cap; 432 433 /* thread for generating video output stream */ 434 struct task_struct *kthread_vid_out; 435 unsigned long jiffies_vid_out; 436 u32 out_seq_offset; 437 u32 out_seq_count; 438 bool out_seq_resync; 439 u32 vid_out_seq_start; 440 u32 vid_out_seq_count; 441 bool vid_out_streaming; 442 u32 vbi_out_seq_start; 443 u32 vbi_out_seq_count; 444 bool vbi_out_streaming; 445 bool stream_sliced_vbi_out; 446 447 /* SDR capture */ 448 struct vb2_queue vb_sdr_cap_q; 449 struct list_head sdr_cap_active; 450 unsigned sdr_adc_freq; 451 unsigned sdr_fm_freq; 452 int sdr_fixp_src_phase; 453 int sdr_fixp_mod_phase; 454 455 bool tstamp_src_is_soe; 456 bool has_crop_cap; 457 bool has_compose_cap; 458 bool has_scaler_cap; 459 bool has_crop_out; 460 bool has_compose_out; 461 bool has_scaler_out; 462 463 /* thread for generating SDR stream */ 464 struct task_struct *kthread_sdr_cap; 465 unsigned long jiffies_sdr_cap; 466 u32 sdr_cap_seq_offset; 467 u32 sdr_cap_seq_count; 468 bool sdr_cap_seq_resync; 469 470 /* RDS generator */ 471 struct vivid_rds_gen rds_gen; 472 473 /* Radio receiver */ 474 unsigned radio_rx_freq; 475 unsigned radio_rx_audmode; 476 int radio_rx_sig_qual; 477 unsigned radio_rx_hw_seek_mode; 478 bool radio_rx_hw_seek_prog_lim; 479 bool radio_rx_rds_controls; 480 bool radio_rx_rds_enabled; 481 unsigned radio_rx_rds_use_alternates; 482 unsigned radio_rx_rds_last_block; 483 struct v4l2_fh *radio_rx_rds_owner; 484 485 /* Radio transmitter */ 486 unsigned radio_tx_freq; 487 unsigned radio_tx_subchans; 488 bool radio_tx_rds_controls; 489 unsigned radio_tx_rds_last_block; 490 struct v4l2_fh *radio_tx_rds_owner; 491 492 /* Shared between radio receiver and transmitter */ 493 bool radio_rds_loop; 494 struct timespec radio_rds_init_ts; 495}; 496 497static inline bool vivid_is_webcam(const struct vivid_dev *dev) 498{ 499 return dev->input_type[dev->input] == WEBCAM; 500} 501 502static inline bool vivid_is_tv_cap(const struct vivid_dev *dev) 503{ 504 return dev->input_type[dev->input] == TV; 505} 506 507static inline bool vivid_is_svid_cap(const struct vivid_dev *dev) 508{ 509 return dev->input_type[dev->input] == SVID; 510} 511 512static inline bool vivid_is_hdmi_cap(const struct vivid_dev *dev) 513{ 514 return dev->input_type[dev->input] == HDMI; 515} 516 517static inline bool vivid_is_sdtv_cap(const struct vivid_dev *dev) 518{ 519 return vivid_is_tv_cap(dev) || vivid_is_svid_cap(dev); 520} 521 522static inline bool vivid_is_svid_out(const struct vivid_dev *dev) 523{ 524 return dev->output_type[dev->output] == SVID; 525} 526 527static inline bool vivid_is_hdmi_out(const struct vivid_dev *dev) 528{ 529 return dev->output_type[dev->output] == HDMI; 530} 531 532#endif 533