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
vivid_is_webcam(const struct vivid_dev * dev)501 static inline bool vivid_is_webcam(const struct vivid_dev *dev)
502 {
503 return dev->input_type[dev->input] == WEBCAM;
504 }
505
vivid_is_tv_cap(const struct vivid_dev * dev)506 static inline bool vivid_is_tv_cap(const struct vivid_dev *dev)
507 {
508 return dev->input_type[dev->input] == TV;
509 }
510
vivid_is_svid_cap(const struct vivid_dev * dev)511 static inline bool vivid_is_svid_cap(const struct vivid_dev *dev)
512 {
513 return dev->input_type[dev->input] == SVID;
514 }
515
vivid_is_hdmi_cap(const struct vivid_dev * dev)516 static inline bool vivid_is_hdmi_cap(const struct vivid_dev *dev)
517 {
518 return dev->input_type[dev->input] == HDMI;
519 }
520
vivid_is_sdtv_cap(const struct vivid_dev * dev)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
vivid_is_svid_out(const struct vivid_dev * dev)526 static inline bool vivid_is_svid_out(const struct vivid_dev *dev)
527 {
528 return dev->output_type[dev->output] == SVID;
529 }
530
vivid_is_hdmi_out(const struct vivid_dev * dev)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
537