kernel/drivers/media/platform/vivid/vivid-core.h

   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-v4l2.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
  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 struct vivid_fmt {
  80         u32     fourcc;          /* v4l2 format id */
  81         bool    is_yuv;
  82         bool    can_do_overlay;
  83         u8      vdownsampling[TPG_MAX_PLANES];
  84         u32     alpha_mask;
  85         u8      planes;
  86         u8      buffers;
  87         u32     data_offset[TPG_MAX_PLANES];
  88         u32     bit_depth[TPG_MAX_PLANES];
  89 };
  90
  91 extern struct vivid_fmt vivid_formats[];
  92
  93 /* buffer for one video frame */
  94 struct vivid_buffer {
  95         /* common v4l buffer stuff -- must be first */
  96         struct vb2_v4l2_buffer vb;
  97         struct list_head        list;
  98 };
  99
 100 enum vivid_input {
 101         WEBCAM,
 102         TV,
 103         SVID,
 104         HDMI,
 105 };
 106
 107 enum vivid_signal_mode {
 108         CURRENT_DV_TIMINGS,
 109         CURRENT_STD = CURRENT_DV_TIMINGS,
 110         NO_SIGNAL,
 111         NO_LOCK,
 112         OUT_OF_RANGE,
 113         SELECTED_DV_TIMINGS,
 114         SELECTED_STD = SELECTED_DV_TIMINGS,
 115         CYCLE_DV_TIMINGS,
 116         CYCLE_STD = CYCLE_DV_TIMINGS,
 117         CUSTOM_DV_TIMINGS,
 118 };
 119
 120 enum vivid_colorspace {
 121         VIVID_CS_170M,
 122         VIVID_CS_709,
 123         VIVID_CS_SRGB,
 124         VIVID_CS_ADOBERGB,
 125         VIVID_CS_2020,
 126         VIVID_CS_DCI_P3,
 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
 135 struct 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_cap;
 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                             xfer_func_out;
 337         u32                             service_set_out;
 338         unsigned                        bytesperline_out[TPG_MAX_PLANES];
 339         unsigned                        tv_field_out;
 340         unsigned                        tv_audio_output;
 341         bool                            vbi_out_have_wss;
 342         u8                              vbi_out_wss[2];
 343         bool                            vbi_out_have_cc[2];
 344         u8                              vbi_out_cc[2][2];
 345         bool                            dvi_d_out;
 346         u8                              *scaled_line;
 347         u8                              *blended_line;
 348         unsigned                        cur_scaled_line;
 349
 350         /* Output Overlay */
 351         void                            *fb_vbase_out;
 352         bool                            overlay_out_enabled;
 353         int                             overlay_out_top, overlay_out_left;
 354         void                            *bitmap_out;
 355         struct v4l2_clip                clips_out[MAX_CLIPS];
 356         struct v4l2_clip                try_clips_out[MAX_CLIPS];
 357         unsigned                        clipcount_out;
 358         unsigned                        fbuf_out_flags;
 359         u32                             chromakey_out;
 360         u8                              global_alpha_out;
 361
 362         /* video capture */
 363         struct tpg_data                 tpg;
 364         unsigned                        ms_vid_cap;
 365         bool                            must_blank[VIDEO_MAX_FRAME];
 366
 367         const struct vivid_fmt          *fmt_cap;
 368         struct v4l2_fract               timeperframe_vid_cap;
 369         enum v4l2_field                 field_cap;
 370         struct v4l2_rect                src_rect;
 371         struct v4l2_rect                fmt_cap_rect;
 372         struct v4l2_rect                crop_cap;
 373         struct v4l2_rect                compose_cap;
 374         struct v4l2_rect                crop_bounds_cap;
 375         struct vb2_queue                vb_vid_cap_q;
 376         struct list_head                vid_cap_active;
 377         struct vb2_queue                vb_vbi_cap_q;
 378         struct list_head                vbi_cap_active;
 379
 380         /* thread for generating video capture stream */
 381         struct task_struct              *kthread_vid_cap;
 382         unsigned long                   jiffies_vid_cap;
 383         u32                             cap_seq_offset;
 384         u32                             cap_seq_count;
 385         bool                            cap_seq_resync;
 386         u32                             vid_cap_seq_start;
 387         u32                             vid_cap_seq_count;
 388         bool                            vid_cap_streaming;
 389         u32                             vbi_cap_seq_start;
 390         u32                             vbi_cap_seq_count;
 391         bool                            vbi_cap_streaming;
 392         bool                            stream_sliced_vbi_cap;
 393
 394         /* video output */
 395         const struct vivid_fmt          *fmt_out;
 396         struct v4l2_fract               timeperframe_vid_out;
 397         enum v4l2_field                 field_out;
 398         struct v4l2_rect                sink_rect;
 399         struct v4l2_rect                fmt_out_rect;
 400         struct v4l2_rect                crop_out;
 401         struct v4l2_rect                compose_out;
 402         struct v4l2_rect                compose_bounds_out;
 403         struct vb2_queue                vb_vid_out_q;
 404         struct list_head                vid_out_active;
 405         struct vb2_queue                vb_vbi_out_q;
 406         struct list_head                vbi_out_active;
 407
 408         /* video loop precalculated rectangles */
 409
 410         /*
 411          * Intersection between what the output side composes and the capture side
 412          * crops. I.e., what actually needs to be copied from the output buffer to
 413          * the capture buffer.
 414          */
 415         struct v4l2_rect                loop_vid_copy;
 416         /* The part of the output buffer that (after scaling) corresponds to loop_vid_copy. */
 417         struct v4l2_rect                loop_vid_out;
 418         /* The part of the capture buffer that (after scaling) corresponds to loop_vid_copy. */
 419         struct v4l2_rect                loop_vid_cap;
 420         /*
 421          * The intersection of the framebuffer, the overlay output window and
 422          * loop_vid_copy. I.e., the part of the framebuffer that actually should be
 423          * blended with the compose_out rectangle. This uses the framebuffer origin.
 424          */
 425         struct v4l2_rect                loop_fb_copy;
 426         /* The same as loop_fb_copy but with compose_out origin. */
 427         struct v4l2_rect                loop_vid_overlay;
 428         /*
 429          * The part of the capture buffer that (after scaling) corresponds
 430          * to loop_vid_overlay.
 431          */
 432         struct v4l2_rect                loop_vid_overlay_cap;
 433
 434         /* thread for generating video output stream */
 435         struct task_struct              *kthread_vid_out;
 436         unsigned long                   jiffies_vid_out;
 437         u32                             out_seq_offset;
 438         u32                             out_seq_count;
 439         bool                            out_seq_resync;
 440         u32                             vid_out_seq_start;
 441         u32                             vid_out_seq_count;
 442         bool                            vid_out_streaming;
 443         u32                             vbi_out_seq_start;
 444         u32                             vbi_out_seq_count;
 445         bool                            vbi_out_streaming;
 446         bool                            stream_sliced_vbi_out;
 447
 448         /* SDR capture */
 449         struct vb2_queue                vb_sdr_cap_q;
 450         struct list_head                sdr_cap_active;
 451         u32                             sdr_pixelformat; /* v4l2 format id */
 452         unsigned                        sdr_buffersize;
 453         unsigned                        sdr_adc_freq;
 454         unsigned                        sdr_fm_freq;
 455         unsigned                        sdr_fm_deviation;
 456         int                             sdr_fixp_src_phase;
 457         int                             sdr_fixp_mod_phase;
 458
 459         bool                            tstamp_src_is_soe;
 460         bool                            has_crop_cap;
 461         bool                            has_compose_cap;
 462         bool                            has_scaler_cap;
 463         bool                            has_crop_out;
 464         bool                            has_compose_out;
 465         bool                            has_scaler_out;
 466
 467         /* thread for generating SDR stream */
 468         struct task_struct              *kthread_sdr_cap;
 469         unsigned long                   jiffies_sdr_cap;
 470         u32                             sdr_cap_seq_offset;
 471         u32                             sdr_cap_seq_count;
 472         bool                            sdr_cap_seq_resync;
 473
 474         /* RDS generator */
 475         struct vivid_rds_gen            rds_gen;
 476
 477         /* Radio receiver */
 478         unsigned                        radio_rx_freq;
 479         unsigned                        radio_rx_audmode;
 480         int                             radio_rx_sig_qual;
 481         unsigned                        radio_rx_hw_seek_mode;
 482         bool                            radio_rx_hw_seek_prog_lim;
 483         bool                            radio_rx_rds_controls;
 484         bool                            radio_rx_rds_enabled;
 485         unsigned                        radio_rx_rds_use_alternates;
 486         unsigned                        radio_rx_rds_last_block;
 487         struct v4l2_fh                  *radio_rx_rds_owner;
 488
 489         /* Radio transmitter */
 490         unsigned                        radio_tx_freq;
 491         unsigned                        radio_tx_subchans;
 492         bool                            radio_tx_rds_controls;
 493         unsigned                        radio_tx_rds_last_block;
 494         struct v4l2_fh                  *radio_tx_rds_owner;
 495
 496         /* Shared between radio receiver and transmitter */
 497         bool                            radio_rds_loop;
 498         struct timespec                 radio_rds_init_ts;
 499 };
 500
 501 static inline bool vivid_is_webcam(const struct vivid_dev *dev)
 502 {
 503         return dev->input_type[dev->input] == WEBCAM;
 504 }
 505
 506 static inline bool vivid_is_tv_cap(const struct vivid_dev *dev)
 507 {
 508         return dev->input_type[dev->input] == TV;
 509 }
 510
 511 static inline bool vivid_is_svid_cap(const struct vivid_dev *dev)
 512 {
 513         return dev->input_type[dev->input] == SVID;
 514 }
 515
 516 static inline bool vivid_is_hdmi_cap(const struct vivid_dev *dev)
 517 {
 518         return dev->input_type[dev->input] == HDMI;
 519 }
 520
 521 static inline bool vivid_is_sdtv_cap(const struct vivid_dev *dev)
 522 {
 523         return vivid_is_tv_cap(dev) || vivid_is_svid_cap(dev);
 524 }
 525
 526 static inline bool vivid_is_svid_out(const struct vivid_dev *dev)
 527 {
 528         return dev->output_type[dev->output] == SVID;
 529 }
 530
 531 static inline bool vivid_is_hdmi_out(const struct vivid_dev *dev)
 532 {
 533         return dev->output_type[dev->output] == HDMI;
 534 }
 535
 536 #endif