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

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