/* SPDX-License-Identifier: GPL-2.0-only */
/*
 * vivid-core.h - core datastructures
 *
 * Copyright 2014 Cisco Systems, Inc. and/or its affiliates. All rights reserved.
 */

#ifndef _VIVID_CORE_H_
#define _VIVID_CORE_H_

#include <linux/fb.h>
#include <linux/workqueue.h>
#include <media/cec.h>
#include <media/videobuf2-v4l2.h>
#include <media/v4l2-device.h>
#include <media/v4l2-dev.h>
#include <media/v4l2-ctrls.h>
#include <media/tpg/v4l2-tpg.h>
#include "vivid-rds-gen.h"
#include "vivid-vbi-gen.h"

#define dprintk(dev, level, fmt, arg...) \
        v4l2_dbg(level, vivid_debug, &dev->v4l2_dev, fmt, ## arg)

/* The maximum number of inputs */
#define MAX_INPUTS 16
/* The maximum number of outputs */
#define MAX_OUTPUTS 16
/* The maximum number of video capture buffers */
#define MAX_VID_CAP_BUFFERS 64
/* The maximum up or down scaling factor is 4 */
#define MAX_ZOOM  4
/* The maximum image width/height are set to 4K DMT */
#define MAX_WIDTH  4096
#define MAX_HEIGHT 2160
/* The minimum image width/height */
#define MIN_WIDTH  16
#define MIN_HEIGHT MIN_WIDTH
/* Pixel Array control divider */
#define PIXEL_ARRAY_DIV MIN_WIDTH
/* The data_offset of plane 0 for the multiplanar formats */
#define PLANE0_DATA_OFFSET 128

/* The supported TV frequency range in MHz */
#define MIN_TV_FREQ (44U * 16U)
#define MAX_TV_FREQ (958U * 16U)

/* The number of samples returned in every SDR buffer */
#define SDR_CAP_SAMPLES_PER_BUF 0x4000

/* used by the threads to know when to resync internal counters */
#define JIFFIES_PER_DAY (3600U * 24U * HZ)
#define JIFFIES_RESYNC (JIFFIES_PER_DAY * (0xf0000000U / JIFFIES_PER_DAY))

/*
 * Maximum number of HDMI inputs allowed by vivid, due to limitations
 * of the Physical Address in the EDID and used by CEC we stop at 15
 * inputs and outputs.
 */
#define MAX_HDMI_INPUTS 15
#define MAX_HDMI_OUTPUTS 15

/* Maximum number of S-Video inputs allowed by vivid */
#define MAX_SVID_INPUTS 16

/* The maximum number of items in a menu control */
#define MAX_MENU_ITEMS BITS_PER_LONG_LONG

/* Number of fixed menu items in the 'Connected To' menu controls */
#define FIXED_MENU_ITEMS 2

/* The maximum number of vivid devices */
#define VIVID_MAX_DEVS CONFIG_VIDEO_VIVID_MAX_DEVS

extern const struct v4l2_rect vivid_min_rect;
extern const struct v4l2_rect vivid_max_rect;
extern unsigned vivid_debug;

/*
 * NULL-terminated string array for the HDMI 'Connected To' menu controls
 * with the list of possible HDMI outputs.
 *
 * The first two items are fixed ("TPG" and "None").
 */
extern char *vivid_ctrl_hdmi_to_output_strings[1 + MAX_MENU_ITEMS];
/* Menu control skip mask of all HDMI outputs that are in use */
extern u64 hdmi_to_output_menu_skip_mask;
/*
 * Bitmask of which vivid instances need to update any connected
 * HDMI outputs.
 */
extern u64 hdmi_input_update_outputs_mask;
/*
 * Spinlock for access to hdmi_to_output_menu_skip_mask and
 * hdmi_input_update_outputs_mask.
 */
extern spinlock_t hdmi_output_skip_mask_lock;
/*
 * Workqueue that updates the menu controls whenever the HDMI menu skip mask
 * changes.
 */
extern struct workqueue_struct *update_hdmi_ctrls_workqueue;

/*
 * The HDMI menu control value (index in the menu list) maps to an HDMI
 * output that is part of the given vivid_dev instance and has the given
 * output index (as returned by VIDIOC_G_OUTPUT).
 *
 * NULL/0 if not available.
 */
extern struct vivid_dev *vivid_ctrl_hdmi_to_output_instance[MAX_MENU_ITEMS];
extern unsigned int vivid_ctrl_hdmi_to_output_index[MAX_MENU_ITEMS];

/*
 * NULL-terminated string array for the S-Video 'Connected To' menu controls
 * with the list of possible S-Video outputs.
 *
 * The first two items are fixed ("TPG" and "None").
 */
extern char *vivid_ctrl_svid_to_output_strings[1 + MAX_MENU_ITEMS];
/* Menu control skip mask of all S-Video outputs that are in use */
extern u64 svid_to_output_menu_skip_mask;
/* Spinlock for access to svid_to_output_menu_skip_mask */
extern spinlock_t svid_output_skip_mask_lock;
/*
 * Workqueue that updates the menu controls whenever the S-Video menu skip mask
 * changes.
 */
extern struct workqueue_struct *update_svid_ctrls_workqueue;

/*
 * The S-Video menu control value (index in the menu list) maps to an S-Video
 * output that is part of the given vivid_dev instance and has the given
 * output index (as returned by VIDIOC_G_OUTPUT).
 *
 * NULL/0 if not available.
 */
extern struct vivid_dev *vivid_ctrl_svid_to_output_instance[MAX_MENU_ITEMS];
extern unsigned int vivid_ctrl_svid_to_output_index[MAX_MENU_ITEMS];

extern struct vivid_dev *vivid_devs[VIVID_MAX_DEVS];
extern unsigned int n_devs;

struct vivid_fmt {
        u32     fourcc;          /* v4l2 format id */
        enum    tgp_color_enc color_enc;
        bool    can_do_overlay;
        u8      vdownsampling[TPG_MAX_PLANES];
        u32     alpha_mask;
        u8      planes;
        u8      buffers;
        u32     data_offset[TPG_MAX_PLANES];
        u32     bit_depth[TPG_MAX_PLANES];
};

extern struct vivid_fmt vivid_formats[];

/* buffer for one video frame */
struct vivid_buffer {
        /* common v4l buffer stuff -- must be first */
        struct vb2_v4l2_buffer vb;
        struct list_head        list;
};

enum vivid_input {
        WEBCAM,
        TV,
        SVID,
        HDMI,
};

enum vivid_signal_mode {
        CURRENT_DV_TIMINGS,
        CURRENT_STD = CURRENT_DV_TIMINGS,
        NO_SIGNAL,
        NO_LOCK,
        OUT_OF_RANGE,
        SELECTED_DV_TIMINGS,
        SELECTED_STD = SELECTED_DV_TIMINGS,
        CYCLE_DV_TIMINGS,
        CYCLE_STD = CYCLE_DV_TIMINGS,
        CUSTOM_DV_TIMINGS,
};

enum vivid_colorspace {
        VIVID_CS_170M,
        VIVID_CS_709,
        VIVID_CS_SRGB,
        VIVID_CS_OPRGB,
        VIVID_CS_2020,
        VIVID_CS_DCI_P3,
        VIVID_CS_240M,
        VIVID_CS_SYS_M,
        VIVID_CS_SYS_BG,
};

#define VIVID_INVALID_SIGNAL(mode) \
        ((mode) == NO_SIGNAL || (mode) == NO_LOCK || (mode) == OUT_OF_RANGE)

struct vivid_cec_xfer {
        struct cec_adapter      *adap;
        u8                      msg[CEC_MAX_MSG_SIZE];
        u32                     len;
        u32                     sft;
};

struct vivid_dev {
        u8                              inst;
        struct v4l2_device              v4l2_dev;
#ifdef CONFIG_MEDIA_CONTROLLER
        struct media_device             mdev;
        struct media_pad                vid_cap_pad;
        struct media_pad                vid_out_pad;
        struct media_pad                vbi_cap_pad;
        struct media_pad                vbi_out_pad;
        struct media_pad                sdr_cap_pad;
        struct media_pad                meta_cap_pad;
        struct media_pad                meta_out_pad;
        struct media_pad                touch_cap_pad;
#endif
        struct v4l2_ctrl_handler        ctrl_hdl_user_gen;
        struct v4l2_ctrl_handler        ctrl_hdl_user_vid;
        struct v4l2_ctrl_handler        ctrl_hdl_user_aud;
        struct v4l2_ctrl_handler        ctrl_hdl_streaming;
        struct v4l2_ctrl_handler        ctrl_hdl_sdtv_cap;
        struct v4l2_ctrl_handler        ctrl_hdl_loop_cap;
        struct v4l2_ctrl_handler        ctrl_hdl_fb;
        struct video_device             vid_cap_dev;
        struct v4l2_ctrl_handler        ctrl_hdl_vid_cap;
        struct video_device             vid_out_dev;
        struct v4l2_ctrl_handler        ctrl_hdl_vid_out;
        struct video_device             vbi_cap_dev;
        struct v4l2_ctrl_handler        ctrl_hdl_vbi_cap;
        struct video_device             vbi_out_dev;
        struct v4l2_ctrl_handler        ctrl_hdl_vbi_out;
        struct video_device             radio_rx_dev;
        struct v4l2_ctrl_handler        ctrl_hdl_radio_rx;
        struct video_device             radio_tx_dev;
        struct v4l2_ctrl_handler        ctrl_hdl_radio_tx;
        struct video_device             sdr_cap_dev;
        struct v4l2_ctrl_handler        ctrl_hdl_sdr_cap;
        struct video_device             meta_cap_dev;
        struct v4l2_ctrl_handler        ctrl_hdl_meta_cap;
        struct video_device             meta_out_dev;
        struct v4l2_ctrl_handler        ctrl_hdl_meta_out;
        struct video_device             touch_cap_dev;
        struct v4l2_ctrl_handler        ctrl_hdl_touch_cap;

        spinlock_t                      slock;
        struct mutex                    mutex;
        struct work_struct              update_hdmi_ctrl_work;
        struct work_struct              update_svid_ctrl_work;

        /* capabilities */
        u32                             vid_cap_caps;
        u32                             vid_out_caps;
        u32                             vbi_cap_caps;
        u32                             vbi_out_caps;
        u32                             sdr_cap_caps;
        u32                             radio_rx_caps;
        u32                             radio_tx_caps;
        u32                             meta_cap_caps;
        u32                             meta_out_caps;
        u32                             touch_cap_caps;

        /* supported features */
        bool                            multiplanar;
        u8                              num_inputs;
        u8                              num_hdmi_inputs;
        u8                              num_svid_inputs;
        u8                              input_type[MAX_INPUTS];
        u8                              input_name_counter[MAX_INPUTS];
        u8                              num_outputs;
        u8                              num_hdmi_outputs;
        u8                              output_type[MAX_OUTPUTS];
        u8                              output_name_counter[MAX_OUTPUTS];
        bool                            has_audio_inputs;
        bool                            has_audio_outputs;
        bool                            has_vid_cap;
        bool                            has_vid_out;
        bool                            has_vbi_cap;
        bool                            has_raw_vbi_cap;
        bool                            has_sliced_vbi_cap;
        bool                            has_vbi_out;
        bool                            has_raw_vbi_out;
        bool                            has_sliced_vbi_out;
        bool                            has_radio_rx;
        bool                            has_radio_tx;
        bool                            has_sdr_cap;
        bool                            has_fb;
        bool                            has_meta_cap;
        bool                            has_meta_out;
        bool                            has_tv_tuner;
        bool                            has_touch_cap;

        /* Output index (0-MAX_OUTPUTS) to vivid instance of connected input */
        struct vivid_dev                *output_to_input_instance[MAX_OUTPUTS];
        /* Output index (0-MAX_OUTPUTS) to input index (0-MAX_INPUTS) of connected input */
        u8                              output_to_input_index[MAX_OUTPUTS];
        /* Output index (0-MAX_OUTPUTS) to HDMI or S-Video output index (0-MAX_HDMI/SVID_OUTPUTS) */
        u8                              output_to_iface_index[MAX_OUTPUTS];
        /* ctrl_hdmi_to_output or ctrl_svid_to_output control value for each input */
        s32                             input_is_connected_to_output[MAX_INPUTS];
        /* HDMI index (0-MAX_HDMI_OUTPUTS) to output index (0-MAX_OUTPUTS) */
        u8                              hdmi_index_to_output_index[MAX_HDMI_OUTPUTS];
        /* HDMI index (0-MAX_HDMI_INPUTS) to input index (0-MAX_INPUTS) */
        u8                              hdmi_index_to_input_index[MAX_HDMI_INPUTS];
        /* S-Video index (0-MAX_SVID_INPUTS) to input index (0-MAX_INPUTS) */
        u8                              svid_index_to_input_index[MAX_SVID_INPUTS];

        /* controls */
        struct v4l2_ctrl                *brightness;
        struct v4l2_ctrl                *contrast;
        struct v4l2_ctrl                *saturation;
        struct v4l2_ctrl                *hue;
        struct {
                /* autogain/gain cluster */
                struct v4l2_ctrl        *autogain;
                struct v4l2_ctrl        *gain;
        };
        struct v4l2_ctrl                *volume;
        struct v4l2_ctrl                *mute;
        struct v4l2_ctrl                *alpha;
        struct v4l2_ctrl                *button;
        struct v4l2_ctrl                *boolean;
        struct v4l2_ctrl                *int32;
        struct v4l2_ctrl                *int64;
        struct v4l2_ctrl                *menu;
        struct v4l2_ctrl                *string;
        struct v4l2_ctrl                *bitmask;
        struct v4l2_ctrl                *int_menu;
        struct v4l2_ctrl                *ro_int32;
        struct v4l2_ctrl                *pixel_array;
        struct v4l2_ctrl                *test_pattern;
        struct v4l2_ctrl                *colorspace;
        struct v4l2_ctrl                *rgb_range_cap;
        struct v4l2_ctrl                *real_rgb_range_cap;
        struct {
                /* std_signal_mode/standard cluster */
                struct v4l2_ctrl        *ctrl_std_signal_mode;
                struct v4l2_ctrl        *ctrl_standard;
        };
        struct {
                /* dv_timings_signal_mode/timings cluster */
                struct v4l2_ctrl        *ctrl_dv_timings_signal_mode;
                struct v4l2_ctrl        *ctrl_dv_timings;
        };
        struct v4l2_ctrl                *ctrl_has_crop_cap;
        struct v4l2_ctrl                *ctrl_has_compose_cap;
        struct v4l2_ctrl                *ctrl_has_scaler_cap;
        struct v4l2_ctrl                *ctrl_has_crop_out;
        struct v4l2_ctrl                *ctrl_has_compose_out;
        struct v4l2_ctrl                *ctrl_has_scaler_out;
        struct v4l2_ctrl                *ctrl_tx_mode;
        struct v4l2_ctrl                *ctrl_tx_rgb_range;
        struct v4l2_ctrl                *ctrl_tx_edid_present;
        struct v4l2_ctrl                *ctrl_tx_hotplug;
        struct v4l2_ctrl                *ctrl_tx_rxsense;

        struct v4l2_ctrl                *ctrl_rx_power_present;

        struct v4l2_ctrl                *radio_tx_rds_pi;
        struct v4l2_ctrl                *radio_tx_rds_pty;
        struct v4l2_ctrl                *radio_tx_rds_mono_stereo;
        struct v4l2_ctrl                *radio_tx_rds_art_head;
        struct v4l2_ctrl                *radio_tx_rds_compressed;
        struct v4l2_ctrl                *radio_tx_rds_dyn_pty;
        struct v4l2_ctrl                *radio_tx_rds_ta;
        struct v4l2_ctrl                *radio_tx_rds_tp;
        struct v4l2_ctrl                *radio_tx_rds_ms;
        struct v4l2_ctrl                *radio_tx_rds_psname;
        struct v4l2_ctrl                *radio_tx_rds_radiotext;

        struct v4l2_ctrl                *radio_rx_rds_pty;
        struct v4l2_ctrl                *radio_rx_rds_ta;
        struct v4l2_ctrl                *radio_rx_rds_tp;
        struct v4l2_ctrl                *radio_rx_rds_ms;
        struct v4l2_ctrl                *radio_rx_rds_psname;
        struct v4l2_ctrl                *radio_rx_rds_radiotext;

        struct v4l2_ctrl                *ctrl_hdmi_to_output[MAX_HDMI_INPUTS];
        char                            ctrl_hdmi_to_output_names[MAX_HDMI_INPUTS][32];
        struct v4l2_ctrl                *ctrl_svid_to_output[MAX_SVID_INPUTS];
        char                            ctrl_svid_to_output_names[MAX_SVID_INPUTS][32];

        unsigned                        input_brightness[MAX_INPUTS];
        unsigned                        osd_mode;
        unsigned                        button_pressed;
        bool                            sensor_hflip;
        bool                            sensor_vflip;
        bool                            hflip;
        bool                            vflip;
        bool                            vbi_cap_interlaced;
        bool                            loop_video;
        bool                            reduced_fps;

        /* Framebuffer */
        unsigned long                   video_pbase;
        void                            *video_vbase;
        u32                             video_buffer_size;
        int                             display_width;
        int                             display_height;
        int                             display_byte_stride;
        int                             bits_per_pixel;
        int                             bytes_per_pixel;
#ifdef CONFIG_VIDEO_VIVID_OSD
        struct fb_info                  fb_info;
        struct fb_var_screeninfo        fb_defined;
        struct fb_fix_screeninfo        fb_fix;
#endif

        /* Error injection */
        bool                            disconnect_error;
        bool                            queue_setup_error;
        bool                            buf_prepare_error;
        bool                            start_streaming_error;
        bool                            dqbuf_error;
        bool                            req_validate_error;
        bool                            seq_wrap;
        u64                             time_wrap;
        u64                             time_wrap_offset;
        unsigned                        perc_dropped_buffers;
        enum vivid_signal_mode          std_signal_mode[MAX_INPUTS];
        unsigned int                    query_std_last[MAX_INPUTS];
        v4l2_std_id                     query_std[MAX_INPUTS];
        enum tpg_video_aspect           std_aspect_ratio[MAX_INPUTS];

        enum vivid_signal_mode          dv_timings_signal_mode[MAX_INPUTS];
        char                            **query_dv_timings_qmenu;
        char                            *query_dv_timings_qmenu_strings;
        unsigned                        query_dv_timings_size;
        unsigned int                    query_dv_timings_last[MAX_INPUTS];
        unsigned int                    query_dv_timings[MAX_INPUTS];
        enum tpg_video_aspect           dv_timings_aspect_ratio[MAX_INPUTS];

        /* Input */
        unsigned                        input;
        v4l2_std_id                     std_cap[MAX_INPUTS];
        struct v4l2_dv_timings          dv_timings_cap[MAX_INPUTS];
        int                             dv_timings_cap_sel[MAX_INPUTS];
        u32                             service_set_cap;
        struct vivid_vbi_gen_data       vbi_gen;
        u8                              *edid;
        unsigned                        edid_blocks;
        unsigned                        edid_max_blocks;
        unsigned                        webcam_size_idx;
        unsigned                        webcam_ival_idx;
        unsigned                        tv_freq;
        unsigned                        tv_audmode;
        unsigned                        tv_field_cap;
        unsigned                        tv_audio_input;

        u32                             power_present;

        /* Output */
        unsigned                        output;
        v4l2_std_id                     std_out;
        struct v4l2_dv_timings          dv_timings_out;
        u32                             colorspace_out;
        u32                             ycbcr_enc_out;
        u32                             hsv_enc_out;
        u32                             quantization_out;
        u32                             xfer_func_out;
        u32                             service_set_out;
        unsigned                        bytesperline_out[TPG_MAX_PLANES];
        unsigned                        tv_field_out;
        unsigned                        tv_audio_output;
        bool                            vbi_out_have_wss;
        u8                              vbi_out_wss[2];
        bool                            vbi_out_have_cc[2];
        u8                              vbi_out_cc[2][2];
        bool                            dvi_d_out;
        u8                              *scaled_line;
        u8                              *blended_line;
        unsigned                        cur_scaled_line;

        /* Output Overlay */
        void                            *fb_vbase_out;
        bool                            overlay_out_enabled;
        int                             overlay_out_top, overlay_out_left;
        unsigned                        fbuf_out_flags;
        u32                             chromakey_out;
        u8                              global_alpha_out;

        /* video capture */
        struct tpg_data                 tpg;
        unsigned                        ms_vid_cap;
        bool                            must_blank[MAX_VID_CAP_BUFFERS];

        const struct vivid_fmt          *fmt_cap;
        struct v4l2_fract               timeperframe_vid_cap;
        enum v4l2_field                 field_cap;
        struct v4l2_rect                src_rect;
        struct v4l2_rect                fmt_cap_rect;
        struct v4l2_rect                crop_cap;
        struct v4l2_rect                compose_cap;
        struct v4l2_rect                crop_bounds_cap;
        struct vb2_queue                vb_vid_cap_q;
        struct list_head                vid_cap_active;
        struct vb2_queue                vb_vbi_cap_q;
        struct list_head                vbi_cap_active;
        struct vb2_queue                vb_meta_cap_q;
        struct list_head                meta_cap_active;
        struct vb2_queue                vb_touch_cap_q;
        struct list_head                touch_cap_active;

        /* thread for generating video capture stream */
        struct task_struct              *kthread_vid_cap;
        unsigned long                   jiffies_vid_cap;
        u64                             cap_stream_start;
        u64                             cap_frame_period;
        u64                             cap_frame_eof_offset;
        u32                             cap_seq_offset;
        u32                             cap_seq_count;
        bool                            cap_seq_resync;
        u32                             vid_cap_seq_start;
        u32                             vid_cap_seq_count;
        bool                            vid_cap_streaming;
        u32                             vbi_cap_seq_start;
        u32                             vbi_cap_seq_count;
        bool                            vbi_cap_streaming;
        u32                             meta_cap_seq_start;
        u32                             meta_cap_seq_count;
        bool                            meta_cap_streaming;

        /* Touch capture */
        struct task_struct              *kthread_touch_cap;
        unsigned long                   jiffies_touch_cap;
        u64                             touch_cap_stream_start;
        u32                             touch_cap_seq_offset;
        bool                            touch_cap_seq_resync;
        u32                             touch_cap_seq_start;
        u32                             touch_cap_seq_count;
        u32                             touch_cap_with_seq_wrap_count;
        bool                            touch_cap_streaming;
        struct v4l2_fract               timeperframe_tch_cap;
        struct v4l2_pix_format          tch_format;
        int                             tch_pat_random;

        /* video output */
        const struct vivid_fmt          *fmt_out;
        struct v4l2_fract               timeperframe_vid_out;
        enum v4l2_field                 field_out;
        struct v4l2_rect                sink_rect;
        struct v4l2_rect                fmt_out_rect;
        struct v4l2_rect                crop_out;
        struct v4l2_rect                compose_out;
        struct v4l2_rect                compose_bounds_out;
        struct vb2_queue                vb_vid_out_q;
        struct list_head                vid_out_active;
        struct vb2_queue                vb_vbi_out_q;
        struct list_head                vbi_out_active;
        struct vb2_queue                vb_meta_out_q;
        struct list_head                meta_out_active;

        /* video loop precalculated rectangles */

        /*
         * Intersection between what the output side composes and the capture side
         * crops. I.e., what actually needs to be copied from the output buffer to
         * the capture buffer.
         */
        struct v4l2_rect                loop_vid_copy;
        /* The part of the output buffer that (after scaling) corresponds to loop_vid_copy. */
        struct v4l2_rect                loop_vid_out;
        /* The part of the capture buffer that (after scaling) corresponds to loop_vid_copy. */
        struct v4l2_rect                loop_vid_cap;
        /*
         * The intersection of the framebuffer, the overlay output window and
         * loop_vid_copy. I.e., the part of the framebuffer that actually should be
         * blended with the compose_out rectangle. This uses the framebuffer origin.
         */
        struct v4l2_rect                loop_fb_copy;
        /* The same as loop_fb_copy but with compose_out origin. */
        struct v4l2_rect                loop_vid_overlay;
        /*
         * The part of the capture buffer that (after scaling) corresponds
         * to loop_vid_overlay.
         */
        struct v4l2_rect                loop_vid_overlay_cap;

        /* thread for generating video output stream */
        struct task_struct              *kthread_vid_out;
        unsigned long                   jiffies_vid_out;
        u32                             out_seq_offset;
        u32                             out_seq_count;
        bool                            out_seq_resync;
        u32                             vid_out_seq_start;
        u32                             vid_out_seq_count;
        bool                            vid_out_streaming;
        u32                             vbi_out_seq_start;
        u32                             vbi_out_seq_count;
        bool                            vbi_out_streaming;
        bool                            stream_sliced_vbi_out;
        u32                             meta_out_seq_start;
        u32                             meta_out_seq_count;
        bool                            meta_out_streaming;

        /* SDR capture */
        struct vb2_queue                vb_sdr_cap_q;
        struct list_head                sdr_cap_active;
        u32                             sdr_pixelformat; /* v4l2 format id */
        unsigned                        sdr_buffersize;
        unsigned                        sdr_adc_freq;
        unsigned                        sdr_fm_freq;
        unsigned                        sdr_fm_deviation;
        int                             sdr_fixp_src_phase;
        int                             sdr_fixp_mod_phase;

        bool                            tstamp_src_is_soe;
        bool                            has_crop_cap;
        bool                            has_compose_cap;
        bool                            has_scaler_cap;
        bool                            has_crop_out;
        bool                            has_compose_out;
        bool                            has_scaler_out;

        /* thread for generating SDR stream */
        struct task_struct              *kthread_sdr_cap;
        unsigned long                   jiffies_sdr_cap;
        u32                             sdr_cap_seq_offset;
        u32                             sdr_cap_seq_start;
        u32                             sdr_cap_seq_count;
        u32                             sdr_cap_with_seq_wrap_count;
        bool                            sdr_cap_seq_resync;

        /* RDS generator */
        struct vivid_rds_gen            rds_gen;

        /* Radio receiver */
        unsigned                        radio_rx_freq;
        unsigned                        radio_rx_audmode;
        int                             radio_rx_sig_qual;
        unsigned                        radio_rx_hw_seek_mode;
        bool                            radio_rx_hw_seek_prog_lim;
        bool                            radio_rx_rds_controls;
        bool                            radio_rx_rds_enabled;
        unsigned                        radio_rx_rds_use_alternates;
        unsigned                        radio_rx_rds_last_block;
        struct v4l2_fh                  *radio_rx_rds_owner;

        /* Radio transmitter */
        unsigned                        radio_tx_freq;
        unsigned                        radio_tx_subchans;
        bool                            radio_tx_rds_controls;
        unsigned                        radio_tx_rds_last_block;
        struct v4l2_fh                  *radio_tx_rds_owner;

        /* Shared between radio receiver and transmitter */
        bool                            radio_rds_loop;
        ktime_t                         radio_rds_init_time;

        /* CEC */
        struct cec_adapter              *cec_rx_adap;
        struct cec_adapter              *cec_tx_adap[MAX_HDMI_OUTPUTS];
        struct task_struct              *kthread_cec;
        wait_queue_head_t               kthread_waitq_cec;
        struct vivid_cec_xfer           xfers[MAX_OUTPUTS];
        spinlock_t                      cec_xfers_slock; /* read and write cec messages */
        u32                             cec_sft; /* bus signal free time, in bit periods */
        u8                              last_initiator;

        /* CEC OSD String */
        char                            osd[14];
        unsigned long                   osd_jiffies;

        bool                            meta_pts;
        bool                            meta_scr;
};

static inline bool vivid_is_webcam(const struct vivid_dev *dev)
{
        return dev->input_type[dev->input] == WEBCAM;
}

static inline bool vivid_is_tv_cap(const struct vivid_dev *dev)
{
        return dev->input_type[dev->input] == TV;
}

static inline bool vivid_is_svid_cap(const struct vivid_dev *dev)
{
        return dev->input_type[dev->input] == SVID;
}

static inline bool vivid_is_hdmi_cap(const struct vivid_dev *dev)
{
        return dev->input_type[dev->input] == HDMI;
}

static inline bool vivid_is_sdtv_cap(const struct vivid_dev *dev)
{
        return vivid_is_tv_cap(dev) || vivid_is_svid_cap(dev);
}

static inline bool vivid_is_svid_out(const struct vivid_dev *dev)
{
        return dev->output_type[dev->output] == SVID;
}

static inline bool vivid_is_hdmi_out(const struct vivid_dev *dev)
{
        return dev->output_type[dev->output] == HDMI;
}

#endif