600 lines
16 KiB
C
600 lines
16 KiB
C
/* 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 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))
|
|
|
|
extern const struct v4l2_rect vivid_min_rect;
|
|
extern const struct v4l2_rect vivid_max_rect;
|
|
extern unsigned vivid_debug;
|
|
|
|
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 {
|
|
unsigned 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;
|
|
|
|
/* 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;
|
|
unsigned num_inputs;
|
|
unsigned int num_hdmi_inputs;
|
|
u8 input_type[MAX_INPUTS];
|
|
u8 input_name_counter[MAX_INPUTS];
|
|
unsigned num_outputs;
|
|
unsigned int 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;
|
|
|
|
bool can_loop_video;
|
|
|
|
/* 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_display_present;
|
|
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;
|
|
|
|
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;
|
|
struct fb_info fb_info;
|
|
struct fb_var_screeninfo fb_defined;
|
|
struct fb_fix_screeninfo fb_fix;
|
|
|
|
/* 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;
|
|
bool display_present[MAX_OUTPUTS];
|
|
|
|
/* 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[VIDEO_MAX_FRAME];
|
|
|
|
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_OUTPUTS];
|
|
u8 cec_output2bus_map[MAX_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
|