1 // SPDX-License-Identifier: GPL-2.0-only
2
3 /*
4 * vivid-core.c - A Virtual Video Test Driver, core initialization
5 *
6 * Copyright 2014 Cisco Systems, Inc. and/or its affiliates. All rights reserved.
7 */
8
9 #include <linux/module.h>
10 #include <linux/errno.h>
11 #include <linux/kernel.h>
12 #include <linux/init.h>
13 #include <linux/sched.h>
14 #include <linux/slab.h>
15 #include <linux/vmalloc.h>
16 #include <linux/font.h>
17 #include <linux/mutex.h>
18 #include <linux/platform_device.h>
19 #include <linux/videodev2.h>
20 #include <linux/v4l2-dv-timings.h>
21 #include <media/videobuf2-vmalloc.h>
22 #include <media/videobuf2-dma-contig.h>
23 #include <media/v4l2-dv-timings.h>
24 #include <media/v4l2-ioctl.h>
25 #include <media/v4l2-fh.h>
26 #include <media/v4l2-event.h>
27
28 #include "vivid-core.h"
29 #include "vivid-vid-common.h"
30 #include "vivid-vid-cap.h"
31 #include "vivid-vid-out.h"
32 #include "vivid-radio-common.h"
33 #include "vivid-radio-rx.h"
34 #include "vivid-radio-tx.h"
35 #include "vivid-sdr-cap.h"
36 #include "vivid-vbi-cap.h"
37 #include "vivid-vbi-out.h"
38 #include "vivid-osd.h"
39 #include "vivid-cec.h"
40 #include "vivid-ctrls.h"
41 #include "vivid-meta-cap.h"
42 #include "vivid-meta-out.h"
43 #include "vivid-touch-cap.h"
44
45 #define VIVID_MODULE_NAME "vivid"
46 #define MAX_STRING_LENGTH 23
47
48 MODULE_DESCRIPTION("Virtual Video Test Driver");
49 MODULE_AUTHOR("Hans Verkuil");
50 MODULE_LICENSE("GPL");
51
52 unsigned int n_devs = 1;
53 module_param(n_devs, uint, 0444);
54 MODULE_PARM_DESC(n_devs, " number of driver instances to create");
55
56 static int vid_cap_nr[VIVID_MAX_DEVS] = { [0 ... (VIVID_MAX_DEVS - 1)] = -1 };
57 module_param_array(vid_cap_nr, int, NULL, 0444);
58 MODULE_PARM_DESC(vid_cap_nr, " videoX start number, -1 is autodetect");
59
60 static int vid_out_nr[VIVID_MAX_DEVS] = { [0 ... (VIVID_MAX_DEVS - 1)] = -1 };
61 module_param_array(vid_out_nr, int, NULL, 0444);
62 MODULE_PARM_DESC(vid_out_nr, " videoX start number, -1 is autodetect");
63
64 static int vbi_cap_nr[VIVID_MAX_DEVS] = { [0 ... (VIVID_MAX_DEVS - 1)] = -1 };
65 module_param_array(vbi_cap_nr, int, NULL, 0444);
66 MODULE_PARM_DESC(vbi_cap_nr, " vbiX start number, -1 is autodetect");
67
68 static int vbi_out_nr[VIVID_MAX_DEVS] = { [0 ... (VIVID_MAX_DEVS - 1)] = -1 };
69 module_param_array(vbi_out_nr, int, NULL, 0444);
70 MODULE_PARM_DESC(vbi_out_nr, " vbiX start number, -1 is autodetect");
71
72 static int sdr_cap_nr[VIVID_MAX_DEVS] = { [0 ... (VIVID_MAX_DEVS - 1)] = -1 };
73 module_param_array(sdr_cap_nr, int, NULL, 0444);
74 MODULE_PARM_DESC(sdr_cap_nr, " swradioX start number, -1 is autodetect");
75
76 static int radio_rx_nr[VIVID_MAX_DEVS] = { [0 ... (VIVID_MAX_DEVS - 1)] = -1 };
77 module_param_array(radio_rx_nr, int, NULL, 0444);
78 MODULE_PARM_DESC(radio_rx_nr, " radioX start number, -1 is autodetect");
79
80 static int radio_tx_nr[VIVID_MAX_DEVS] = { [0 ... (VIVID_MAX_DEVS - 1)] = -1 };
81 module_param_array(radio_tx_nr, int, NULL, 0444);
82 MODULE_PARM_DESC(radio_tx_nr, " radioX start number, -1 is autodetect");
83
84 static int meta_cap_nr[VIVID_MAX_DEVS] = { [0 ... (VIVID_MAX_DEVS - 1)] = -1 };
85 module_param_array(meta_cap_nr, int, NULL, 0444);
86 MODULE_PARM_DESC(meta_cap_nr, " videoX start number, -1 is autodetect");
87
88 static int meta_out_nr[VIVID_MAX_DEVS] = { [0 ... (VIVID_MAX_DEVS - 1)] = -1 };
89 module_param_array(meta_out_nr, int, NULL, 0444);
90 MODULE_PARM_DESC(meta_out_nr, " videoX start number, -1 is autodetect");
91
92 static int touch_cap_nr[VIVID_MAX_DEVS] = { [0 ... (VIVID_MAX_DEVS - 1)] = -1 };
93 module_param_array(touch_cap_nr, int, NULL, 0444);
94 MODULE_PARM_DESC(touch_cap_nr, " v4l-touchX start number, -1 is autodetect");
95
96 static int ccs_cap_mode[VIVID_MAX_DEVS] = { [0 ... (VIVID_MAX_DEVS - 1)] = -1 };
97 module_param_array(ccs_cap_mode, int, NULL, 0444);
98 MODULE_PARM_DESC(ccs_cap_mode, " capture crop/compose/scale mode:\n"
99 "\t\t bit 0=crop, 1=compose, 2=scale,\n"
100 "\t\t -1=user-controlled (default)");
101
102 static int ccs_out_mode[VIVID_MAX_DEVS] = { [0 ... (VIVID_MAX_DEVS - 1)] = -1 };
103 module_param_array(ccs_out_mode, int, NULL, 0444);
104 MODULE_PARM_DESC(ccs_out_mode, " output crop/compose/scale mode:\n"
105 "\t\t bit 0=crop, 1=compose, 2=scale,\n"
106 "\t\t -1=user-controlled (default)");
107
108 static unsigned multiplanar[VIVID_MAX_DEVS] = { [0 ... (VIVID_MAX_DEVS - 1)] = 1 };
109 module_param_array(multiplanar, uint, NULL, 0444);
110 MODULE_PARM_DESC(multiplanar, " 1 (default) creates a single planar device, 2 creates a multiplanar device.");
111
112 /*
113 * Default: video + vbi-cap (raw and sliced) + radio rx + radio tx + sdr +
114 * vbi-out + vid-out + meta-cap
115 */
116 static unsigned int node_types[VIVID_MAX_DEVS] = {
117 [0 ... (VIVID_MAX_DEVS - 1)] = 0xe1d3d
118 };
119 module_param_array(node_types, uint, NULL, 0444);
120 MODULE_PARM_DESC(node_types, " node types, default is 0xe1d3d. Bitmask with the following meaning:\n"
121 "\t\t bit 0: Video Capture node\n"
122 "\t\t bit 2-3: VBI Capture node: 0 = none, 1 = raw vbi, 2 = sliced vbi, 3 = both\n"
123 "\t\t bit 4: Radio Receiver node\n"
124 "\t\t bit 5: Software Defined Radio Receiver node\n"
125 "\t\t bit 8: Video Output node\n"
126 "\t\t bit 10-11: VBI Output node: 0 = none, 1 = raw vbi, 2 = sliced vbi, 3 = both\n"
127 "\t\t bit 12: Radio Transmitter node\n"
128 #ifdef CONFIG_VIDEO_VIVID_OSD
129 "\t\t bit 16: Framebuffer for testing output overlays\n"
130 #endif
131 "\t\t bit 17: Metadata Capture node\n"
132 "\t\t bit 18: Metadata Output node\n"
133 "\t\t bit 19: Touch Capture node\n");
134
135 /* Default: 4 inputs */
136 static unsigned num_inputs[VIVID_MAX_DEVS] = { [0 ... (VIVID_MAX_DEVS - 1)] = 4 };
137 module_param_array(num_inputs, uint, NULL, 0444);
138 MODULE_PARM_DESC(num_inputs, " number of inputs, default is 4");
139
140 /* Default: input 0 = WEBCAM, 1 = TV, 2 = SVID, 3 = HDMI */
141 static unsigned input_types[VIVID_MAX_DEVS] = { [0 ... (VIVID_MAX_DEVS - 1)] = 0xe4 };
142 module_param_array(input_types, uint, NULL, 0444);
143 MODULE_PARM_DESC(input_types, " input types, default is 0xe4. Two bits per input,\n"
144 "\t\t bits 0-1 == input 0, bits 31-30 == input 15.\n"
145 "\t\t Type 0 == webcam, 1 == TV, 2 == S-Video, 3 == HDMI");
146
147 /* Default: 2 outputs */
148 static unsigned num_outputs[VIVID_MAX_DEVS] = { [0 ... (VIVID_MAX_DEVS - 1)] = 2 };
149 module_param_array(num_outputs, uint, NULL, 0444);
150 MODULE_PARM_DESC(num_outputs, " number of outputs, default is 2");
151
152 /* Default: output 0 = SVID, 1 = HDMI */
153 static unsigned output_types[VIVID_MAX_DEVS] = { [0 ... (VIVID_MAX_DEVS - 1)] = 2 };
154 module_param_array(output_types, uint, NULL, 0444);
155 MODULE_PARM_DESC(output_types, " output types, default is 0x02. One bit per output,\n"
156 "\t\t bit 0 == output 0, bit 15 == output 15.\n"
157 "\t\t Type 0 == S-Video, 1 == HDMI");
158
159 unsigned vivid_debug;
160 module_param(vivid_debug, uint, 0644);
161 MODULE_PARM_DESC(vivid_debug, " activates debug info");
162
163 static bool no_error_inj;
164 module_param(no_error_inj, bool, 0444);
165 MODULE_PARM_DESC(no_error_inj, " if set disable the error injecting controls");
166
167 static unsigned int allocators[VIVID_MAX_DEVS] = { [0 ... (VIVID_MAX_DEVS - 1)] = 0 };
168 module_param_array(allocators, uint, NULL, 0444);
169 MODULE_PARM_DESC(allocators, " memory allocator selection, default is 0.\n"
170 "\t\t 0 == vmalloc\n"
171 "\t\t 1 == dma-contig");
172
173 static unsigned int cache_hints[VIVID_MAX_DEVS] = {
174 [0 ... (VIVID_MAX_DEVS - 1)] = 0
175 };
176 module_param_array(cache_hints, uint, NULL, 0444);
177 MODULE_PARM_DESC(cache_hints, " user-space cache hints, default is 0.\n"
178 "\t\t 0 == forbid\n"
179 "\t\t 1 == allow");
180
181 static unsigned int supports_requests[VIVID_MAX_DEVS] = {
182 [0 ... (VIVID_MAX_DEVS - 1)] = 1
183 };
184 module_param_array(supports_requests, uint, NULL, 0444);
185 MODULE_PARM_DESC(supports_requests, " support for requests, default is 1.\n"
186 "\t\t 0 == no support\n"
187 "\t\t 1 == supports requests\n"
188 "\t\t 2 == requires requests");
189
190 struct vivid_dev *vivid_devs[VIVID_MAX_DEVS];
191
192 DEFINE_SPINLOCK(hdmi_output_skip_mask_lock);
193 struct workqueue_struct *update_hdmi_ctrls_workqueue;
194 u64 hdmi_to_output_menu_skip_mask;
195 u64 hdmi_input_update_outputs_mask;
196
197 struct vivid_dev *vivid_ctrl_hdmi_to_output_instance[MAX_MENU_ITEMS];
198 unsigned int vivid_ctrl_hdmi_to_output_index[MAX_MENU_ITEMS];
199
200 char *vivid_ctrl_hdmi_to_output_strings[MAX_MENU_ITEMS + 1] = {
201 "Test Pattern Generator",
202 "None"
203 };
204
205 DEFINE_SPINLOCK(svid_output_skip_mask_lock);
206 struct workqueue_struct *update_svid_ctrls_workqueue;
207 u64 svid_to_output_menu_skip_mask;
208
209 struct vivid_dev *vivid_ctrl_svid_to_output_instance[MAX_MENU_ITEMS];
210 unsigned int vivid_ctrl_svid_to_output_index[MAX_MENU_ITEMS];
211
212 char *vivid_ctrl_svid_to_output_strings[MAX_MENU_ITEMS + 1] = {
213 "Test Pattern Generator",
214 "None"
215 };
216
217 const struct v4l2_rect vivid_min_rect = {
218 0, 0, MIN_WIDTH, MIN_HEIGHT
219 };
220
221 const struct v4l2_rect vivid_max_rect = {
222 0, 0, MAX_WIDTH * MAX_ZOOM, MAX_HEIGHT * MAX_ZOOM
223 };
224
225 static const u8 vivid_hdmi_edid[256] = {
226 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00,
227 0x31, 0xd8, 0x34, 0x12, 0x00, 0x00, 0x00, 0x00,
228 0x22, 0x1a, 0x01, 0x03, 0x80, 0x60, 0x36, 0x78,
229 0x0f, 0xee, 0x91, 0xa3, 0x54, 0x4c, 0x99, 0x26,
230 0x0f, 0x50, 0x54, 0x2f, 0xcf, 0x00, 0x31, 0x59,
231 0x45, 0x59, 0x81, 0x80, 0x81, 0x40, 0x90, 0x40,
232 0x95, 0x00, 0xa9, 0x40, 0xb3, 0x00, 0x08, 0xe8,
233 0x00, 0x30, 0xf2, 0x70, 0x5a, 0x80, 0xb0, 0x58,
234 0x8a, 0x00, 0xc0, 0x1c, 0x32, 0x00, 0x00, 0x1e,
235 0x00, 0x00, 0x00, 0xfd, 0x00, 0x18, 0x55, 0x18,
236 0x87, 0x3c, 0x00, 0x0a, 0x20, 0x20, 0x20, 0x20,
237 0x20, 0x20, 0x00, 0x00, 0x00, 0xfc, 0x00, 0x76,
238 0x69, 0x76, 0x69, 0x64, 0x0a, 0x20, 0x20, 0x20,
239 0x20, 0x20, 0x20, 0x20, 0x00, 0x00, 0x00, 0x10,
240 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
241 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x7b,
242
243 0x02, 0x03, 0x3f, 0xf1, 0x51, 0x61, 0x60, 0x5f,
244 0x5e, 0x5d, 0x10, 0x1f, 0x04, 0x13, 0x22, 0x21,
245 0x20, 0x05, 0x14, 0x02, 0x11, 0x01, 0x23, 0x09,
246 0x07, 0x07, 0x83, 0x01, 0x00, 0x00, 0x6d, 0x03,
247 0x0c, 0x00, 0x00, 0x00, 0x00, 0x3c, 0x21, 0x00,
248 0x60, 0x01, 0x02, 0x03, 0x67, 0xd8, 0x5d, 0xc4,
249 0x01, 0x78, 0x00, 0x00, 0xe2, 0x00, 0xca, 0xe3,
250 0x05, 0x00, 0x00, 0xe3, 0x06, 0x01, 0x00, 0x4d,
251 0xd0, 0x00, 0xa0, 0xf0, 0x70, 0x3e, 0x80, 0x30,
252 0x20, 0x35, 0x00, 0xc0, 0x1c, 0x32, 0x00, 0x00,
253 0x1e, 0x1a, 0x36, 0x80, 0xa0, 0x70, 0x38, 0x1f,
254 0x40, 0x30, 0x20, 0x35, 0x00, 0xc0, 0x1c, 0x32,
255 0x00, 0x00, 0x1a, 0x1a, 0x1d, 0x00, 0x80, 0x51,
256 0xd0, 0x1c, 0x20, 0x40, 0x80, 0x35, 0x00, 0xc0,
257 0x1c, 0x32, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00,
258 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x92,
259 };
260
vidioc_querycap(struct file * file,void * priv,struct v4l2_capability * cap)261 static int vidioc_querycap(struct file *file, void *priv,
262 struct v4l2_capability *cap)
263 {
264 struct vivid_dev *dev = video_drvdata(file);
265
266 strscpy(cap->driver, "vivid", sizeof(cap->driver));
267 strscpy(cap->card, "vivid", sizeof(cap->card));
268 snprintf(cap->bus_info, sizeof(cap->bus_info),
269 "platform:%s-%03d", VIVID_MODULE_NAME, dev->inst);
270
271 cap->capabilities = dev->vid_cap_caps | dev->vid_out_caps |
272 dev->vbi_cap_caps | dev->vbi_out_caps |
273 dev->radio_rx_caps | dev->radio_tx_caps |
274 dev->sdr_cap_caps | dev->meta_cap_caps |
275 dev->meta_out_caps | dev->touch_cap_caps |
276 V4L2_CAP_DEVICE_CAPS;
277 return 0;
278 }
279
vidioc_s_hw_freq_seek(struct file * file,void * fh,const struct v4l2_hw_freq_seek * a)280 static int vidioc_s_hw_freq_seek(struct file *file, void *fh, const struct v4l2_hw_freq_seek *a)
281 {
282 struct video_device *vdev = video_devdata(file);
283
284 if (vdev->vfl_type == VFL_TYPE_RADIO)
285 return vivid_radio_rx_s_hw_freq_seek(file, fh, a);
286 return -ENOTTY;
287 }
288
vidioc_enum_freq_bands(struct file * file,void * fh,struct v4l2_frequency_band * band)289 static int vidioc_enum_freq_bands(struct file *file, void *fh, struct v4l2_frequency_band *band)
290 {
291 struct video_device *vdev = video_devdata(file);
292
293 if (vdev->vfl_type == VFL_TYPE_RADIO)
294 return vivid_radio_rx_enum_freq_bands(file, fh, band);
295 if (vdev->vfl_type == VFL_TYPE_SDR)
296 return vivid_sdr_enum_freq_bands(file, fh, band);
297 return -ENOTTY;
298 }
299
vidioc_g_tuner(struct file * file,void * fh,struct v4l2_tuner * vt)300 static int vidioc_g_tuner(struct file *file, void *fh, struct v4l2_tuner *vt)
301 {
302 struct video_device *vdev = video_devdata(file);
303
304 if (vdev->vfl_type == VFL_TYPE_RADIO)
305 return vivid_radio_rx_g_tuner(file, fh, vt);
306 if (vdev->vfl_type == VFL_TYPE_SDR)
307 return vivid_sdr_g_tuner(file, fh, vt);
308 return vivid_video_g_tuner(file, fh, vt);
309 }
310
vidioc_s_tuner(struct file * file,void * fh,const struct v4l2_tuner * vt)311 static int vidioc_s_tuner(struct file *file, void *fh, const struct v4l2_tuner *vt)
312 {
313 struct video_device *vdev = video_devdata(file);
314
315 if (vdev->vfl_type == VFL_TYPE_RADIO)
316 return vivid_radio_rx_s_tuner(file, fh, vt);
317 if (vdev->vfl_type == VFL_TYPE_SDR)
318 return vivid_sdr_s_tuner(file, fh, vt);
319 return vivid_video_s_tuner(file, fh, vt);
320 }
321
vidioc_g_frequency(struct file * file,void * fh,struct v4l2_frequency * vf)322 static int vidioc_g_frequency(struct file *file, void *fh, struct v4l2_frequency *vf)
323 {
324 struct vivid_dev *dev = video_drvdata(file);
325 struct video_device *vdev = video_devdata(file);
326
327 if (vdev->vfl_type == VFL_TYPE_RADIO)
328 return vivid_radio_g_frequency(file,
329 vdev->vfl_dir == VFL_DIR_RX ?
330 &dev->radio_rx_freq : &dev->radio_tx_freq, vf);
331 if (vdev->vfl_type == VFL_TYPE_SDR)
332 return vivid_sdr_g_frequency(file, fh, vf);
333 return vivid_video_g_frequency(file, fh, vf);
334 }
335
vidioc_s_frequency(struct file * file,void * fh,const struct v4l2_frequency * vf)336 static int vidioc_s_frequency(struct file *file, void *fh, const struct v4l2_frequency *vf)
337 {
338 struct vivid_dev *dev = video_drvdata(file);
339 struct video_device *vdev = video_devdata(file);
340
341 if (vdev->vfl_type == VFL_TYPE_RADIO)
342 return vivid_radio_s_frequency(file,
343 vdev->vfl_dir == VFL_DIR_RX ?
344 &dev->radio_rx_freq : &dev->radio_tx_freq, vf);
345 if (vdev->vfl_type == VFL_TYPE_SDR)
346 return vivid_sdr_s_frequency(file, fh, vf);
347 return vivid_video_s_frequency(file, fh, vf);
348 }
349
vidioc_overlay(struct file * file,void * fh,unsigned i)350 static int vidioc_overlay(struct file *file, void *fh, unsigned i)
351 {
352 struct video_device *vdev = video_devdata(file);
353
354 if (vdev->vfl_dir == VFL_DIR_RX)
355 return -ENOTTY;
356 return vivid_vid_out_overlay(file, fh, i);
357 }
358
vidioc_g_fbuf(struct file * file,void * fh,struct v4l2_framebuffer * a)359 static int vidioc_g_fbuf(struct file *file, void *fh, struct v4l2_framebuffer *a)
360 {
361 struct video_device *vdev = video_devdata(file);
362
363 if (vdev->vfl_dir == VFL_DIR_RX)
364 return -ENOTTY;
365 return vivid_vid_out_g_fbuf(file, fh, a);
366 }
367
vidioc_s_fbuf(struct file * file,void * fh,const struct v4l2_framebuffer * a)368 static int vidioc_s_fbuf(struct file *file, void *fh, const struct v4l2_framebuffer *a)
369 {
370 struct video_device *vdev = video_devdata(file);
371
372 if (vdev->vfl_dir == VFL_DIR_RX)
373 return -ENOTTY;
374 return vivid_vid_out_s_fbuf(file, fh, a);
375 }
376
vidioc_s_std(struct file * file,void * fh,v4l2_std_id id)377 static int vidioc_s_std(struct file *file, void *fh, v4l2_std_id id)
378 {
379 struct video_device *vdev = video_devdata(file);
380
381 if (vdev->vfl_dir == VFL_DIR_RX)
382 return vivid_vid_cap_s_std(file, fh, id);
383 return vivid_vid_out_s_std(file, fh, id);
384 }
385
vidioc_s_dv_timings(struct file * file,void * fh,struct v4l2_dv_timings * timings)386 static int vidioc_s_dv_timings(struct file *file, void *fh, struct v4l2_dv_timings *timings)
387 {
388 struct video_device *vdev = video_devdata(file);
389
390 if (vdev->vfl_dir == VFL_DIR_RX)
391 return vivid_vid_cap_s_dv_timings(file, fh, timings);
392 return vivid_vid_out_s_dv_timings(file, fh, timings);
393 }
394
vidioc_g_pixelaspect(struct file * file,void * fh,int type,struct v4l2_fract * f)395 static int vidioc_g_pixelaspect(struct file *file, void *fh,
396 int type, struct v4l2_fract *f)
397 {
398 struct video_device *vdev = video_devdata(file);
399
400 if (vdev->vfl_dir == VFL_DIR_RX)
401 return vivid_vid_cap_g_pixelaspect(file, fh, type, f);
402 return vivid_vid_out_g_pixelaspect(file, fh, type, f);
403 }
404
vidioc_g_selection(struct file * file,void * fh,struct v4l2_selection * sel)405 static int vidioc_g_selection(struct file *file, void *fh,
406 struct v4l2_selection *sel)
407 {
408 struct video_device *vdev = video_devdata(file);
409
410 if (vdev->vfl_dir == VFL_DIR_RX)
411 return vivid_vid_cap_g_selection(file, fh, sel);
412 return vivid_vid_out_g_selection(file, fh, sel);
413 }
414
vidioc_s_selection(struct file * file,void * fh,struct v4l2_selection * sel)415 static int vidioc_s_selection(struct file *file, void *fh,
416 struct v4l2_selection *sel)
417 {
418 struct video_device *vdev = video_devdata(file);
419
420 if (vdev->vfl_dir == VFL_DIR_RX)
421 return vivid_vid_cap_s_selection(file, fh, sel);
422 return vivid_vid_out_s_selection(file, fh, sel);
423 }
424
vidioc_g_parm(struct file * file,void * fh,struct v4l2_streamparm * parm)425 static int vidioc_g_parm(struct file *file, void *fh,
426 struct v4l2_streamparm *parm)
427 {
428 struct video_device *vdev = video_devdata(file);
429
430 if (vdev->vfl_type == VFL_TYPE_TOUCH)
431 return vivid_g_parm_tch(file, fh, parm);
432 if (vdev->vfl_dir == VFL_DIR_RX)
433 return vivid_vid_cap_g_parm(file, fh, parm);
434 return vivid_vid_out_g_parm(file, fh, parm);
435 }
436
vidioc_s_parm(struct file * file,void * fh,struct v4l2_streamparm * parm)437 static int vidioc_s_parm(struct file *file, void *fh,
438 struct v4l2_streamparm *parm)
439 {
440 struct video_device *vdev = video_devdata(file);
441
442 if (vdev->vfl_dir == VFL_DIR_RX)
443 return vivid_vid_cap_s_parm(file, fh, parm);
444 return -ENOTTY;
445 }
446
vidioc_log_status(struct file * file,void * fh)447 static int vidioc_log_status(struct file *file, void *fh)
448 {
449 struct vivid_dev *dev = video_drvdata(file);
450 struct video_device *vdev = video_devdata(file);
451
452 v4l2_ctrl_log_status(file, fh);
453 if (vdev->vfl_dir == VFL_DIR_RX && vdev->vfl_type == VFL_TYPE_VIDEO)
454 tpg_log_status(&dev->tpg);
455 return 0;
456 }
457
vivid_radio_read(struct file * file,char __user * buf,size_t size,loff_t * offset)458 static ssize_t vivid_radio_read(struct file *file, char __user *buf,
459 size_t size, loff_t *offset)
460 {
461 struct video_device *vdev = video_devdata(file);
462
463 if (vdev->vfl_dir == VFL_DIR_TX)
464 return -EINVAL;
465 return vivid_radio_rx_read(file, buf, size, offset);
466 }
467
vivid_radio_write(struct file * file,const char __user * buf,size_t size,loff_t * offset)468 static ssize_t vivid_radio_write(struct file *file, const char __user *buf,
469 size_t size, loff_t *offset)
470 {
471 struct video_device *vdev = video_devdata(file);
472
473 if (vdev->vfl_dir == VFL_DIR_RX)
474 return -EINVAL;
475 return vivid_radio_tx_write(file, buf, size, offset);
476 }
477
vivid_radio_poll(struct file * file,struct poll_table_struct * wait)478 static __poll_t vivid_radio_poll(struct file *file, struct poll_table_struct *wait)
479 {
480 struct video_device *vdev = video_devdata(file);
481
482 if (vdev->vfl_dir == VFL_DIR_RX)
483 return vivid_radio_rx_poll(file, wait);
484 return vivid_radio_tx_poll(file, wait);
485 }
486
vivid_enum_input(struct file * file,void * priv,struct v4l2_input * inp)487 static int vivid_enum_input(struct file *file, void *priv,
488 struct v4l2_input *inp)
489 {
490 struct video_device *vdev = video_devdata(file);
491
492 if (vdev->vfl_type == VFL_TYPE_TOUCH)
493 return vivid_enum_input_tch(file, priv, inp);
494 return vidioc_enum_input(file, priv, inp);
495 }
496
vivid_g_input(struct file * file,void * priv,unsigned int * i)497 static int vivid_g_input(struct file *file, void *priv, unsigned int *i)
498 {
499 struct video_device *vdev = video_devdata(file);
500
501 if (vdev->vfl_type == VFL_TYPE_TOUCH)
502 return vivid_g_input_tch(file, priv, i);
503 return vidioc_g_input(file, priv, i);
504 }
505
vivid_s_input(struct file * file,void * priv,unsigned int i)506 static int vivid_s_input(struct file *file, void *priv, unsigned int i)
507 {
508 struct video_device *vdev = video_devdata(file);
509
510 if (vdev->vfl_type == VFL_TYPE_TOUCH)
511 return vivid_s_input_tch(file, priv, i);
512 return vidioc_s_input(file, priv, i);
513 }
514
vivid_enum_fmt_cap(struct file * file,void * priv,struct v4l2_fmtdesc * f)515 static int vivid_enum_fmt_cap(struct file *file, void *priv,
516 struct v4l2_fmtdesc *f)
517 {
518 struct video_device *vdev = video_devdata(file);
519
520 if (vdev->vfl_type == VFL_TYPE_TOUCH)
521 return vivid_enum_fmt_tch(file, priv, f);
522 return vivid_enum_fmt_vid(file, priv, f);
523 }
524
vivid_g_fmt_cap(struct file * file,void * priv,struct v4l2_format * f)525 static int vivid_g_fmt_cap(struct file *file, void *priv,
526 struct v4l2_format *f)
527 {
528 struct video_device *vdev = video_devdata(file);
529
530 if (vdev->vfl_type == VFL_TYPE_TOUCH)
531 return vivid_g_fmt_tch(file, priv, f);
532 return vidioc_g_fmt_vid_cap(file, priv, f);
533 }
534
vivid_try_fmt_cap(struct file * file,void * priv,struct v4l2_format * f)535 static int vivid_try_fmt_cap(struct file *file, void *priv,
536 struct v4l2_format *f)
537 {
538 struct video_device *vdev = video_devdata(file);
539
540 if (vdev->vfl_type == VFL_TYPE_TOUCH)
541 return vivid_g_fmt_tch(file, priv, f);
542 return vidioc_try_fmt_vid_cap(file, priv, f);
543 }
544
vivid_s_fmt_cap(struct file * file,void * priv,struct v4l2_format * f)545 static int vivid_s_fmt_cap(struct file *file, void *priv,
546 struct v4l2_format *f)
547 {
548 struct video_device *vdev = video_devdata(file);
549
550 if (vdev->vfl_type == VFL_TYPE_TOUCH)
551 return vivid_g_fmt_tch(file, priv, f);
552 return vidioc_s_fmt_vid_cap(file, priv, f);
553 }
554
vivid_g_fmt_cap_mplane(struct file * file,void * priv,struct v4l2_format * f)555 static int vivid_g_fmt_cap_mplane(struct file *file, void *priv,
556 struct v4l2_format *f)
557 {
558 struct video_device *vdev = video_devdata(file);
559
560 if (vdev->vfl_type == VFL_TYPE_TOUCH)
561 return vivid_g_fmt_tch_mplane(file, priv, f);
562 return vidioc_g_fmt_vid_cap_mplane(file, priv, f);
563 }
564
vivid_try_fmt_cap_mplane(struct file * file,void * priv,struct v4l2_format * f)565 static int vivid_try_fmt_cap_mplane(struct file *file, void *priv,
566 struct v4l2_format *f)
567 {
568 struct video_device *vdev = video_devdata(file);
569
570 if (vdev->vfl_type == VFL_TYPE_TOUCH)
571 return vivid_g_fmt_tch_mplane(file, priv, f);
572 return vidioc_try_fmt_vid_cap_mplane(file, priv, f);
573 }
574
vivid_s_fmt_cap_mplane(struct file * file,void * priv,struct v4l2_format * f)575 static int vivid_s_fmt_cap_mplane(struct file *file, void *priv,
576 struct v4l2_format *f)
577 {
578 struct video_device *vdev = video_devdata(file);
579
580 if (vdev->vfl_type == VFL_TYPE_TOUCH)
581 return vivid_g_fmt_tch_mplane(file, priv, f);
582 return vidioc_s_fmt_vid_cap_mplane(file, priv, f);
583 }
584
vivid_is_in_use(bool valid,struct video_device * vdev)585 static bool vivid_is_in_use(bool valid, struct video_device *vdev)
586 {
587 unsigned long flags;
588 bool res;
589
590 if (!valid)
591 return false;
592 spin_lock_irqsave(&vdev->fh_lock, flags);
593 res = !list_empty(&vdev->fh_list);
594 spin_unlock_irqrestore(&vdev->fh_lock, flags);
595 return res;
596 }
597
vivid_is_last_user(struct vivid_dev * dev)598 static bool vivid_is_last_user(struct vivid_dev *dev)
599 {
600 unsigned int uses =
601 vivid_is_in_use(dev->has_vid_cap, &dev->vid_cap_dev) +
602 vivid_is_in_use(dev->has_vid_out, &dev->vid_out_dev) +
603 vivid_is_in_use(dev->has_vbi_cap, &dev->vbi_cap_dev) +
604 vivid_is_in_use(dev->has_vbi_out, &dev->vbi_out_dev) +
605 vivid_is_in_use(dev->has_radio_rx, &dev->radio_rx_dev) +
606 vivid_is_in_use(dev->has_radio_tx, &dev->radio_tx_dev) +
607 vivid_is_in_use(dev->has_sdr_cap, &dev->sdr_cap_dev) +
608 vivid_is_in_use(dev->has_meta_cap, &dev->meta_cap_dev) +
609 vivid_is_in_use(dev->has_meta_out, &dev->meta_out_dev) +
610 vivid_is_in_use(dev->has_touch_cap, &dev->touch_cap_dev);
611
612 return uses == 1;
613 }
614
vivid_reconnect(struct vivid_dev * dev)615 static void vivid_reconnect(struct vivid_dev *dev)
616 {
617 if (dev->has_vid_cap)
618 set_bit(V4L2_FL_REGISTERED, &dev->vid_cap_dev.flags);
619 if (dev->has_vid_out)
620 set_bit(V4L2_FL_REGISTERED, &dev->vid_out_dev.flags);
621 if (dev->has_vbi_cap)
622 set_bit(V4L2_FL_REGISTERED, &dev->vbi_cap_dev.flags);
623 if (dev->has_vbi_out)
624 set_bit(V4L2_FL_REGISTERED, &dev->vbi_out_dev.flags);
625 if (dev->has_radio_rx)
626 set_bit(V4L2_FL_REGISTERED, &dev->radio_rx_dev.flags);
627 if (dev->has_radio_tx)
628 set_bit(V4L2_FL_REGISTERED, &dev->radio_tx_dev.flags);
629 if (dev->has_sdr_cap)
630 set_bit(V4L2_FL_REGISTERED, &dev->sdr_cap_dev.flags);
631 if (dev->has_meta_cap)
632 set_bit(V4L2_FL_REGISTERED, &dev->meta_cap_dev.flags);
633 if (dev->has_meta_out)
634 set_bit(V4L2_FL_REGISTERED, &dev->meta_out_dev.flags);
635 if (dev->has_touch_cap)
636 set_bit(V4L2_FL_REGISTERED, &dev->touch_cap_dev.flags);
637 dev->disconnect_error = false;
638 }
639
vivid_fop_release(struct file * file)640 static int vivid_fop_release(struct file *file)
641 {
642 struct vivid_dev *dev = video_drvdata(file);
643 struct video_device *vdev = video_devdata(file);
644
645 mutex_lock(&dev->mutex);
646 if (!no_error_inj && v4l2_fh_is_singular_file(file) &&
647 dev->disconnect_error && !video_is_registered(vdev) &&
648 vivid_is_last_user(dev)) {
649 /*
650 * I am the last user of this driver, and a disconnect
651 * was forced (since this video_device is unregistered),
652 * so re-register all video_device's again.
653 */
654 v4l2_info(&dev->v4l2_dev, "reconnect\n");
655 vivid_reconnect(dev);
656 }
657 if (file->private_data == dev->radio_rx_rds_owner) {
658 dev->radio_rx_rds_last_block = 0;
659 dev->radio_rx_rds_owner = NULL;
660 }
661 if (file->private_data == dev->radio_tx_rds_owner) {
662 dev->radio_tx_rds_last_block = 0;
663 dev->radio_tx_rds_owner = NULL;
664 }
665 mutex_unlock(&dev->mutex);
666 if (vdev->queue)
667 return vb2_fop_release(file);
668 return v4l2_fh_release(file);
669 }
670
671 static const struct v4l2_file_operations vivid_fops = {
672 .owner = THIS_MODULE,
673 .open = v4l2_fh_open,
674 .release = vivid_fop_release,
675 .read = vb2_fop_read,
676 .write = vb2_fop_write,
677 .poll = vb2_fop_poll,
678 .unlocked_ioctl = video_ioctl2,
679 .mmap = vb2_fop_mmap,
680 };
681
682 static const struct v4l2_file_operations vivid_radio_fops = {
683 .owner = THIS_MODULE,
684 .open = v4l2_fh_open,
685 .release = vivid_fop_release,
686 .read = vivid_radio_read,
687 .write = vivid_radio_write,
688 .poll = vivid_radio_poll,
689 .unlocked_ioctl = video_ioctl2,
690 };
691
vidioc_reqbufs(struct file * file,void * priv,struct v4l2_requestbuffers * p)692 static int vidioc_reqbufs(struct file *file, void *priv,
693 struct v4l2_requestbuffers *p)
694 {
695 struct video_device *vdev = video_devdata(file);
696 int r;
697
698 /*
699 * Sliced and raw VBI capture share the same queue so we must
700 * change the type.
701 */
702 if (p->type == V4L2_BUF_TYPE_SLICED_VBI_CAPTURE ||
703 p->type == V4L2_BUF_TYPE_VBI_CAPTURE) {
704 r = vb2_queue_change_type(vdev->queue, p->type);
705 if (r)
706 return r;
707 }
708
709 return vb2_ioctl_reqbufs(file, priv, p);
710 }
711
vidioc_create_bufs(struct file * file,void * priv,struct v4l2_create_buffers * p)712 static int vidioc_create_bufs(struct file *file, void *priv,
713 struct v4l2_create_buffers *p)
714 {
715 struct video_device *vdev = video_devdata(file);
716 int r;
717
718 /*
719 * Sliced and raw VBI capture share the same queue so we must
720 * change the type.
721 */
722 if (p->format.type == V4L2_BUF_TYPE_SLICED_VBI_CAPTURE ||
723 p->format.type == V4L2_BUF_TYPE_VBI_CAPTURE) {
724 r = vb2_queue_change_type(vdev->queue, p->format.type);
725 if (r)
726 return r;
727 }
728
729 return vb2_ioctl_create_bufs(file, priv, p);
730 }
731
732 static const struct v4l2_ioctl_ops vivid_ioctl_ops = {
733 .vidioc_querycap = vidioc_querycap,
734
735 .vidioc_enum_fmt_vid_cap = vivid_enum_fmt_cap,
736 .vidioc_g_fmt_vid_cap = vivid_g_fmt_cap,
737 .vidioc_try_fmt_vid_cap = vivid_try_fmt_cap,
738 .vidioc_s_fmt_vid_cap = vivid_s_fmt_cap,
739 .vidioc_g_fmt_vid_cap_mplane = vivid_g_fmt_cap_mplane,
740 .vidioc_try_fmt_vid_cap_mplane = vivid_try_fmt_cap_mplane,
741 .vidioc_s_fmt_vid_cap_mplane = vivid_s_fmt_cap_mplane,
742
743 .vidioc_enum_fmt_vid_out = vivid_enum_fmt_vid,
744 .vidioc_g_fmt_vid_out = vidioc_g_fmt_vid_out,
745 .vidioc_try_fmt_vid_out = vidioc_try_fmt_vid_out,
746 .vidioc_s_fmt_vid_out = vidioc_s_fmt_vid_out,
747 .vidioc_g_fmt_vid_out_mplane = vidioc_g_fmt_vid_out_mplane,
748 .vidioc_try_fmt_vid_out_mplane = vidioc_try_fmt_vid_out_mplane,
749 .vidioc_s_fmt_vid_out_mplane = vidioc_s_fmt_vid_out_mplane,
750
751 .vidioc_g_selection = vidioc_g_selection,
752 .vidioc_s_selection = vidioc_s_selection,
753 .vidioc_g_pixelaspect = vidioc_g_pixelaspect,
754
755 .vidioc_g_fmt_vbi_cap = vidioc_g_fmt_vbi_cap,
756 .vidioc_try_fmt_vbi_cap = vidioc_g_fmt_vbi_cap,
757 .vidioc_s_fmt_vbi_cap = vidioc_s_fmt_vbi_cap,
758
759 .vidioc_g_fmt_sliced_vbi_cap = vidioc_g_fmt_sliced_vbi_cap,
760 .vidioc_try_fmt_sliced_vbi_cap = vidioc_try_fmt_sliced_vbi_cap,
761 .vidioc_s_fmt_sliced_vbi_cap = vidioc_s_fmt_sliced_vbi_cap,
762 .vidioc_g_sliced_vbi_cap = vidioc_g_sliced_vbi_cap,
763
764 .vidioc_g_fmt_vbi_out = vidioc_g_fmt_vbi_out,
765 .vidioc_try_fmt_vbi_out = vidioc_g_fmt_vbi_out,
766 .vidioc_s_fmt_vbi_out = vidioc_s_fmt_vbi_out,
767
768 .vidioc_g_fmt_sliced_vbi_out = vidioc_g_fmt_sliced_vbi_out,
769 .vidioc_try_fmt_sliced_vbi_out = vidioc_try_fmt_sliced_vbi_out,
770 .vidioc_s_fmt_sliced_vbi_out = vidioc_s_fmt_sliced_vbi_out,
771
772 .vidioc_enum_fmt_sdr_cap = vidioc_enum_fmt_sdr_cap,
773 .vidioc_g_fmt_sdr_cap = vidioc_g_fmt_sdr_cap,
774 .vidioc_try_fmt_sdr_cap = vidioc_try_fmt_sdr_cap,
775 .vidioc_s_fmt_sdr_cap = vidioc_s_fmt_sdr_cap,
776
777 .vidioc_overlay = vidioc_overlay,
778 .vidioc_enum_framesizes = vidioc_enum_framesizes,
779 .vidioc_enum_frameintervals = vidioc_enum_frameintervals,
780 .vidioc_g_parm = vidioc_g_parm,
781 .vidioc_s_parm = vidioc_s_parm,
782
783 .vidioc_g_fmt_vid_out_overlay = vidioc_g_fmt_vid_out_overlay,
784 .vidioc_try_fmt_vid_out_overlay = vidioc_try_fmt_vid_out_overlay,
785 .vidioc_s_fmt_vid_out_overlay = vidioc_s_fmt_vid_out_overlay,
786 .vidioc_g_fbuf = vidioc_g_fbuf,
787 .vidioc_s_fbuf = vidioc_s_fbuf,
788
789 .vidioc_reqbufs = vidioc_reqbufs,
790 .vidioc_create_bufs = vidioc_create_bufs,
791 .vidioc_prepare_buf = vb2_ioctl_prepare_buf,
792 .vidioc_querybuf = vb2_ioctl_querybuf,
793 .vidioc_qbuf = vb2_ioctl_qbuf,
794 .vidioc_dqbuf = vb2_ioctl_dqbuf,
795 .vidioc_expbuf = vb2_ioctl_expbuf,
796 .vidioc_streamon = vb2_ioctl_streamon,
797 .vidioc_streamoff = vb2_ioctl_streamoff,
798 .vidioc_remove_bufs = vb2_ioctl_remove_bufs,
799
800 .vidioc_enum_input = vivid_enum_input,
801 .vidioc_g_input = vivid_g_input,
802 .vidioc_s_input = vivid_s_input,
803 .vidioc_s_audio = vidioc_s_audio,
804 .vidioc_g_audio = vidioc_g_audio,
805 .vidioc_enumaudio = vidioc_enumaudio,
806 .vidioc_s_frequency = vidioc_s_frequency,
807 .vidioc_g_frequency = vidioc_g_frequency,
808 .vidioc_s_tuner = vidioc_s_tuner,
809 .vidioc_g_tuner = vidioc_g_tuner,
810 .vidioc_s_modulator = vidioc_s_modulator,
811 .vidioc_g_modulator = vidioc_g_modulator,
812 .vidioc_s_hw_freq_seek = vidioc_s_hw_freq_seek,
813 .vidioc_enum_freq_bands = vidioc_enum_freq_bands,
814
815 .vidioc_enum_output = vidioc_enum_output,
816 .vidioc_g_output = vidioc_g_output,
817 .vidioc_s_output = vidioc_s_output,
818 .vidioc_s_audout = vidioc_s_audout,
819 .vidioc_g_audout = vidioc_g_audout,
820 .vidioc_enumaudout = vidioc_enumaudout,
821
822 .vidioc_querystd = vidioc_querystd,
823 .vidioc_g_std = vidioc_g_std,
824 .vidioc_s_std = vidioc_s_std,
825 .vidioc_s_dv_timings = vidioc_s_dv_timings,
826 .vidioc_g_dv_timings = vidioc_g_dv_timings,
827 .vidioc_query_dv_timings = vidioc_query_dv_timings,
828 .vidioc_enum_dv_timings = vidioc_enum_dv_timings,
829 .vidioc_dv_timings_cap = vidioc_dv_timings_cap,
830 .vidioc_g_edid = vidioc_g_edid,
831 .vidioc_s_edid = vidioc_s_edid,
832
833 .vidioc_log_status = vidioc_log_status,
834 .vidioc_subscribe_event = vidioc_subscribe_event,
835 .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
836
837 .vidioc_enum_fmt_meta_cap = vidioc_enum_fmt_meta_cap,
838 .vidioc_g_fmt_meta_cap = vidioc_g_fmt_meta_cap,
839 .vidioc_s_fmt_meta_cap = vidioc_g_fmt_meta_cap,
840 .vidioc_try_fmt_meta_cap = vidioc_g_fmt_meta_cap,
841
842 .vidioc_enum_fmt_meta_out = vidioc_enum_fmt_meta_out,
843 .vidioc_g_fmt_meta_out = vidioc_g_fmt_meta_out,
844 .vidioc_s_fmt_meta_out = vidioc_g_fmt_meta_out,
845 .vidioc_try_fmt_meta_out = vidioc_g_fmt_meta_out,
846 };
847
848 /* -----------------------------------------------------------------
849 Initialization and module stuff
850 ------------------------------------------------------------------*/
851
vivid_dev_release(struct v4l2_device * v4l2_dev)852 static void vivid_dev_release(struct v4l2_device *v4l2_dev)
853 {
854 struct vivid_dev *dev = container_of(v4l2_dev, struct vivid_dev, v4l2_dev);
855
856 cancel_work_sync(&dev->update_hdmi_ctrl_work);
857 vivid_free_controls(dev);
858 v4l2_device_unregister(&dev->v4l2_dev);
859 #ifdef CONFIG_MEDIA_CONTROLLER
860 media_device_cleanup(&dev->mdev);
861 #endif
862 vfree(dev->scaled_line);
863 vfree(dev->blended_line);
864 vfree(dev->edid);
865 tpg_free(&dev->tpg);
866 kfree(dev->query_dv_timings_qmenu);
867 kfree(dev->query_dv_timings_qmenu_strings);
868 kfree(dev);
869 }
870
871 #ifdef CONFIG_MEDIA_CONTROLLER
vivid_req_validate(struct media_request * req)872 static int vivid_req_validate(struct media_request *req)
873 {
874 struct vivid_dev *dev = container_of(req->mdev, struct vivid_dev, mdev);
875
876 if (dev->req_validate_error) {
877 dev->req_validate_error = false;
878 return -EINVAL;
879 }
880 return vb2_request_validate(req);
881 }
882
883 static const struct media_device_ops vivid_media_ops = {
884 .req_validate = vivid_req_validate,
885 .req_queue = vb2_request_queue,
886 };
887 #endif
888
vivid_create_queue(struct vivid_dev * dev,struct vb2_queue * q,u32 buf_type,unsigned int min_reqbufs_allocation,const struct vb2_ops * ops)889 static int vivid_create_queue(struct vivid_dev *dev,
890 struct vb2_queue *q,
891 u32 buf_type,
892 unsigned int min_reqbufs_allocation,
893 const struct vb2_ops *ops)
894 {
895 if (buf_type == V4L2_BUF_TYPE_VIDEO_CAPTURE && dev->multiplanar)
896 buf_type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
897 else if (buf_type == V4L2_BUF_TYPE_VIDEO_OUTPUT && dev->multiplanar)
898 buf_type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
899 else if (buf_type == V4L2_BUF_TYPE_VBI_CAPTURE && !dev->has_raw_vbi_cap)
900 buf_type = V4L2_BUF_TYPE_SLICED_VBI_CAPTURE;
901 else if (buf_type == V4L2_BUF_TYPE_VBI_OUTPUT && !dev->has_raw_vbi_out)
902 buf_type = V4L2_BUF_TYPE_SLICED_VBI_OUTPUT;
903
904 q->type = buf_type;
905 q->io_modes = VB2_MMAP | VB2_DMABUF;
906 q->io_modes |= V4L2_TYPE_IS_OUTPUT(buf_type) ? VB2_WRITE : VB2_READ;
907
908 /*
909 * The maximum number of buffers is 32768 if PAGE_SHIFT == 12,
910 * see also MAX_BUFFER_INDEX in videobuf2-core.c. It will be less if
911 * PAGE_SHIFT > 12, but then max_num_buffers will be clamped by
912 * videobuf2-core.c to MAX_BUFFER_INDEX.
913 */
914 if (buf_type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
915 q->max_num_buffers = MAX_VID_CAP_BUFFERS;
916 if (buf_type == V4L2_BUF_TYPE_SDR_CAPTURE)
917 q->max_num_buffers = 1024;
918 if (buf_type == V4L2_BUF_TYPE_VBI_CAPTURE)
919 q->max_num_buffers = 32768;
920
921 if (allocators[dev->inst] != 1)
922 q->io_modes |= VB2_USERPTR;
923 q->drv_priv = dev;
924 q->buf_struct_size = sizeof(struct vivid_buffer);
925 q->ops = ops;
926 q->mem_ops = allocators[dev->inst] == 1 ? &vb2_dma_contig_memops :
927 &vb2_vmalloc_memops;
928 q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
929 q->min_reqbufs_allocation = min_reqbufs_allocation;
930 q->lock = &dev->mutex;
931 q->dev = dev->v4l2_dev.dev;
932 q->supports_requests = supports_requests[dev->inst];
933 q->requires_requests = supports_requests[dev->inst] >= 2;
934 q->allow_cache_hints = (cache_hints[dev->inst] == 1);
935
936 return vb2_queue_init(q);
937 }
938
vivid_detect_feature_set(struct vivid_dev * dev,int inst,unsigned node_type,bool * has_tuner,bool * has_modulator,int * ccs_cap,int * ccs_out,unsigned in_type_counter[4],unsigned out_type_counter[4])939 static int vivid_detect_feature_set(struct vivid_dev *dev, int inst,
940 unsigned node_type,
941 bool *has_tuner,
942 bool *has_modulator,
943 int *ccs_cap,
944 int *ccs_out,
945 unsigned in_type_counter[4],
946 unsigned out_type_counter[4])
947 {
948 int i;
949
950 /* do we use single- or multi-planar? */
951 dev->multiplanar = multiplanar[inst] > 1;
952 v4l2_info(&dev->v4l2_dev, "using %splanar format API\n",
953 dev->multiplanar ? "multi" : "single ");
954
955 /* how many inputs do we have and of what type? */
956 dev->num_inputs = num_inputs[inst];
957 if (node_type & 0x20007) {
958 if (dev->num_inputs < 1)
959 dev->num_inputs = 1;
960 } else {
961 dev->num_inputs = 0;
962 }
963 if (dev->num_inputs >= MAX_INPUTS)
964 dev->num_inputs = MAX_INPUTS;
965 for (i = 0; i < dev->num_inputs; i++) {
966 dev->input_type[i] = (input_types[inst] >> (i * 2)) & 0x3;
967 dev->input_name_counter[i] = in_type_counter[dev->input_type[i]]++;
968 }
969 dev->has_audio_inputs = in_type_counter[TV] && in_type_counter[SVID];
970 if (in_type_counter[HDMI] == 16) {
971 /* The CEC physical address only allows for max 15 inputs */
972 in_type_counter[HDMI]--;
973 dev->num_inputs--;
974 }
975 dev->num_hdmi_inputs = in_type_counter[HDMI];
976 dev->num_svid_inputs = in_type_counter[SVID];
977
978 /* how many outputs do we have and of what type? */
979 dev->num_outputs = num_outputs[inst];
980 if (node_type & 0x40300) {
981 if (dev->num_outputs < 1)
982 dev->num_outputs = 1;
983 } else {
984 dev->num_outputs = 0;
985 }
986 if (dev->num_outputs >= MAX_OUTPUTS)
987 dev->num_outputs = MAX_OUTPUTS;
988 for (i = 0; i < dev->num_outputs; i++) {
989 dev->output_type[i] = ((output_types[inst] >> i) & 1) ? HDMI : SVID;
990 dev->output_name_counter[i] = out_type_counter[dev->output_type[i]]++;
991 }
992 dev->has_audio_outputs = out_type_counter[SVID];
993 if (out_type_counter[HDMI] == 16) {
994 /*
995 * The CEC physical address only allows for max 15 inputs,
996 * so outputs are also limited to 15 to allow for easy
997 * CEC output to input mapping.
998 */
999 out_type_counter[HDMI]--;
1000 dev->num_outputs--;
1001 }
1002 dev->num_hdmi_outputs = out_type_counter[HDMI];
1003
1004 /* do we create a video capture device? */
1005 dev->has_vid_cap = node_type & 0x0001;
1006
1007 /* do we create a vbi capture device? */
1008 if (in_type_counter[TV] || in_type_counter[SVID]) {
1009 dev->has_raw_vbi_cap = node_type & 0x0004;
1010 dev->has_sliced_vbi_cap = node_type & 0x0008;
1011 dev->has_vbi_cap = dev->has_raw_vbi_cap | dev->has_sliced_vbi_cap;
1012 }
1013
1014 /* do we create a meta capture device */
1015 dev->has_meta_cap = node_type & 0x20000;
1016
1017 /* sanity checks */
1018 if ((in_type_counter[WEBCAM] || in_type_counter[HDMI]) &&
1019 !dev->has_vid_cap && !dev->has_meta_cap) {
1020 v4l2_warn(&dev->v4l2_dev,
1021 "Webcam or HDMI input without video or metadata nodes\n");
1022 return -EINVAL;
1023 }
1024 if ((in_type_counter[TV] || in_type_counter[SVID]) &&
1025 !dev->has_vid_cap && !dev->has_vbi_cap && !dev->has_meta_cap) {
1026 v4l2_warn(&dev->v4l2_dev,
1027 "TV or S-Video input without video, VBI or metadata nodes\n");
1028 return -EINVAL;
1029 }
1030
1031 /* do we create a video output device? */
1032 dev->has_vid_out = node_type & 0x0100;
1033
1034 /* do we create a vbi output device? */
1035 if (out_type_counter[SVID]) {
1036 dev->has_raw_vbi_out = node_type & 0x0400;
1037 dev->has_sliced_vbi_out = node_type & 0x0800;
1038 dev->has_vbi_out = dev->has_raw_vbi_out | dev->has_sliced_vbi_out;
1039 }
1040
1041 /* do we create a metadata output device */
1042 dev->has_meta_out = node_type & 0x40000;
1043
1044 /* sanity checks */
1045 if (out_type_counter[SVID] &&
1046 !dev->has_vid_out && !dev->has_vbi_out && !dev->has_meta_out) {
1047 v4l2_warn(&dev->v4l2_dev,
1048 "S-Video output without video, VBI or metadata nodes\n");
1049 return -EINVAL;
1050 }
1051 if (out_type_counter[HDMI] && !dev->has_vid_out && !dev->has_meta_out) {
1052 v4l2_warn(&dev->v4l2_dev,
1053 "HDMI output without video or metadata nodes\n");
1054 return -EINVAL;
1055 }
1056
1057 /* do we create a radio receiver device? */
1058 dev->has_radio_rx = node_type & 0x0010;
1059
1060 /* do we create a radio transmitter device? */
1061 dev->has_radio_tx = node_type & 0x1000;
1062
1063 /* do we create a software defined radio capture device? */
1064 dev->has_sdr_cap = node_type & 0x0020;
1065
1066 /* do we have a TV tuner? */
1067 dev->has_tv_tuner = in_type_counter[TV];
1068
1069 /* do we have a tuner? */
1070 *has_tuner = ((dev->has_vid_cap || dev->has_vbi_cap) && in_type_counter[TV]) ||
1071 dev->has_radio_rx || dev->has_sdr_cap;
1072
1073 /* do we have a modulator? */
1074 *has_modulator = dev->has_radio_tx;
1075
1076 #ifdef CONFIG_VIDEO_VIVID_OSD
1077 if (dev->has_vid_cap)
1078 /* do we have a framebuffer for overlay testing? */
1079 dev->has_fb = node_type & 0x10000;
1080 #endif
1081
1082 /* can we do crop/compose/scaling while capturing? */
1083 if (no_error_inj && *ccs_cap == -1)
1084 *ccs_cap = 7;
1085
1086 /* if ccs_cap == -1, then the user can select it using controls */
1087 if (*ccs_cap != -1) {
1088 dev->has_crop_cap = *ccs_cap & 1;
1089 dev->has_compose_cap = *ccs_cap & 2;
1090 dev->has_scaler_cap = *ccs_cap & 4;
1091 v4l2_info(&dev->v4l2_dev, "Capture Crop: %c Compose: %c Scaler: %c\n",
1092 dev->has_crop_cap ? 'Y' : 'N',
1093 dev->has_compose_cap ? 'Y' : 'N',
1094 dev->has_scaler_cap ? 'Y' : 'N');
1095 }
1096
1097 /* can we do crop/compose/scaling with video output? */
1098 if (no_error_inj && *ccs_out == -1)
1099 *ccs_out = 7;
1100
1101 /* if ccs_out == -1, then the user can select it using controls */
1102 if (*ccs_out != -1) {
1103 dev->has_crop_out = *ccs_out & 1;
1104 dev->has_compose_out = *ccs_out & 2;
1105 dev->has_scaler_out = *ccs_out & 4;
1106 v4l2_info(&dev->v4l2_dev, "Output Crop: %c Compose: %c Scaler: %c\n",
1107 dev->has_crop_out ? 'Y' : 'N',
1108 dev->has_compose_out ? 'Y' : 'N',
1109 dev->has_scaler_out ? 'Y' : 'N');
1110 }
1111
1112 /* do we create a touch capture device */
1113 dev->has_touch_cap = node_type & 0x80000;
1114
1115 return 0;
1116 }
1117
vivid_set_capabilities(struct vivid_dev * dev)1118 static void vivid_set_capabilities(struct vivid_dev *dev)
1119 {
1120 if (dev->has_vid_cap) {
1121 /* set up the capabilities of the video capture device */
1122 dev->vid_cap_caps = dev->multiplanar ?
1123 V4L2_CAP_VIDEO_CAPTURE_MPLANE :
1124 V4L2_CAP_VIDEO_CAPTURE;
1125 dev->vid_cap_caps |= V4L2_CAP_STREAMING | V4L2_CAP_READWRITE;
1126 if (dev->has_audio_inputs)
1127 dev->vid_cap_caps |= V4L2_CAP_AUDIO;
1128 if (dev->has_tv_tuner)
1129 dev->vid_cap_caps |= V4L2_CAP_TUNER;
1130 }
1131 if (dev->has_vid_out) {
1132 /* set up the capabilities of the video output device */
1133 dev->vid_out_caps = dev->multiplanar ?
1134 V4L2_CAP_VIDEO_OUTPUT_MPLANE :
1135 V4L2_CAP_VIDEO_OUTPUT;
1136 if (dev->has_fb)
1137 dev->vid_out_caps |= V4L2_CAP_VIDEO_OUTPUT_OVERLAY;
1138 dev->vid_out_caps |= V4L2_CAP_STREAMING | V4L2_CAP_READWRITE;
1139 if (dev->has_audio_outputs)
1140 dev->vid_out_caps |= V4L2_CAP_AUDIO;
1141 }
1142 if (dev->has_vbi_cap) {
1143 /* set up the capabilities of the vbi capture device */
1144 dev->vbi_cap_caps = (dev->has_raw_vbi_cap ? V4L2_CAP_VBI_CAPTURE : 0) |
1145 (dev->has_sliced_vbi_cap ? V4L2_CAP_SLICED_VBI_CAPTURE : 0);
1146 dev->vbi_cap_caps |= V4L2_CAP_STREAMING | V4L2_CAP_READWRITE;
1147 if (dev->has_audio_inputs)
1148 dev->vbi_cap_caps |= V4L2_CAP_AUDIO;
1149 if (dev->has_tv_tuner)
1150 dev->vbi_cap_caps |= V4L2_CAP_TUNER;
1151 }
1152 if (dev->has_vbi_out) {
1153 /* set up the capabilities of the vbi output device */
1154 dev->vbi_out_caps = (dev->has_raw_vbi_out ? V4L2_CAP_VBI_OUTPUT : 0) |
1155 (dev->has_sliced_vbi_out ? V4L2_CAP_SLICED_VBI_OUTPUT : 0);
1156 dev->vbi_out_caps |= V4L2_CAP_STREAMING | V4L2_CAP_READWRITE;
1157 if (dev->has_audio_outputs)
1158 dev->vbi_out_caps |= V4L2_CAP_AUDIO;
1159 }
1160 if (dev->has_sdr_cap) {
1161 /* set up the capabilities of the sdr capture device */
1162 dev->sdr_cap_caps = V4L2_CAP_SDR_CAPTURE | V4L2_CAP_TUNER;
1163 dev->sdr_cap_caps |= V4L2_CAP_STREAMING | V4L2_CAP_READWRITE;
1164 }
1165 /* set up the capabilities of the radio receiver device */
1166 if (dev->has_radio_rx)
1167 dev->radio_rx_caps = V4L2_CAP_RADIO | V4L2_CAP_RDS_CAPTURE |
1168 V4L2_CAP_HW_FREQ_SEEK | V4L2_CAP_TUNER |
1169 V4L2_CAP_READWRITE;
1170 /* set up the capabilities of the radio transmitter device */
1171 if (dev->has_radio_tx)
1172 dev->radio_tx_caps = V4L2_CAP_RDS_OUTPUT | V4L2_CAP_MODULATOR |
1173 V4L2_CAP_READWRITE;
1174
1175 /* set up the capabilities of meta capture device */
1176 if (dev->has_meta_cap) {
1177 dev->meta_cap_caps = V4L2_CAP_META_CAPTURE |
1178 V4L2_CAP_STREAMING | V4L2_CAP_READWRITE;
1179 if (dev->has_audio_inputs)
1180 dev->meta_cap_caps |= V4L2_CAP_AUDIO;
1181 if (dev->has_tv_tuner)
1182 dev->meta_cap_caps |= V4L2_CAP_TUNER;
1183 }
1184 /* set up the capabilities of meta output device */
1185 if (dev->has_meta_out) {
1186 dev->meta_out_caps = V4L2_CAP_META_OUTPUT |
1187 V4L2_CAP_STREAMING | V4L2_CAP_READWRITE;
1188 if (dev->has_audio_outputs)
1189 dev->meta_out_caps |= V4L2_CAP_AUDIO;
1190 }
1191 /* set up the capabilities of the touch capture device */
1192 if (dev->has_touch_cap) {
1193 dev->touch_cap_caps = V4L2_CAP_TOUCH | V4L2_CAP_STREAMING |
1194 V4L2_CAP_READWRITE;
1195 dev->touch_cap_caps |= dev->multiplanar ?
1196 V4L2_CAP_VIDEO_CAPTURE_MPLANE : V4L2_CAP_VIDEO_CAPTURE;
1197 }
1198 }
1199
vivid_disable_unused_ioctls(struct vivid_dev * dev,bool has_tuner,bool has_modulator,unsigned in_type_counter[4],unsigned out_type_counter[4])1200 static void vivid_disable_unused_ioctls(struct vivid_dev *dev,
1201 bool has_tuner,
1202 bool has_modulator,
1203 unsigned in_type_counter[4],
1204 unsigned out_type_counter[4])
1205 {
1206 /* disable invalid ioctls based on the feature set */
1207 if (!dev->has_audio_inputs) {
1208 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_S_AUDIO);
1209 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_G_AUDIO);
1210 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_ENUMAUDIO);
1211 v4l2_disable_ioctl(&dev->vbi_cap_dev, VIDIOC_S_AUDIO);
1212 v4l2_disable_ioctl(&dev->vbi_cap_dev, VIDIOC_G_AUDIO);
1213 v4l2_disable_ioctl(&dev->vbi_cap_dev, VIDIOC_ENUMAUDIO);
1214 v4l2_disable_ioctl(&dev->meta_cap_dev, VIDIOC_S_AUDIO);
1215 v4l2_disable_ioctl(&dev->meta_cap_dev, VIDIOC_G_AUDIO);
1216 v4l2_disable_ioctl(&dev->meta_cap_dev, VIDIOC_ENUMAUDIO);
1217 }
1218 if (!dev->has_audio_outputs) {
1219 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_S_AUDOUT);
1220 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_G_AUDOUT);
1221 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_ENUMAUDOUT);
1222 v4l2_disable_ioctl(&dev->vbi_out_dev, VIDIOC_S_AUDOUT);
1223 v4l2_disable_ioctl(&dev->vbi_out_dev, VIDIOC_G_AUDOUT);
1224 v4l2_disable_ioctl(&dev->vbi_out_dev, VIDIOC_ENUMAUDOUT);
1225 v4l2_disable_ioctl(&dev->meta_out_dev, VIDIOC_S_AUDOUT);
1226 v4l2_disable_ioctl(&dev->meta_out_dev, VIDIOC_G_AUDOUT);
1227 v4l2_disable_ioctl(&dev->meta_out_dev, VIDIOC_ENUMAUDOUT);
1228 }
1229 if (!in_type_counter[TV] && !in_type_counter[SVID]) {
1230 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_S_STD);
1231 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_G_STD);
1232 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_ENUMSTD);
1233 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_QUERYSTD);
1234 }
1235 if (!out_type_counter[SVID]) {
1236 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_S_STD);
1237 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_G_STD);
1238 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_ENUMSTD);
1239 }
1240 if (!has_tuner && !has_modulator) {
1241 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_S_FREQUENCY);
1242 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_G_FREQUENCY);
1243 v4l2_disable_ioctl(&dev->vbi_cap_dev, VIDIOC_S_FREQUENCY);
1244 v4l2_disable_ioctl(&dev->vbi_cap_dev, VIDIOC_G_FREQUENCY);
1245 v4l2_disable_ioctl(&dev->meta_cap_dev, VIDIOC_S_FREQUENCY);
1246 v4l2_disable_ioctl(&dev->meta_cap_dev, VIDIOC_G_FREQUENCY);
1247 }
1248 if (!has_tuner) {
1249 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_S_TUNER);
1250 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_G_TUNER);
1251 v4l2_disable_ioctl(&dev->vbi_cap_dev, VIDIOC_S_TUNER);
1252 v4l2_disable_ioctl(&dev->vbi_cap_dev, VIDIOC_G_TUNER);
1253 v4l2_disable_ioctl(&dev->meta_cap_dev, VIDIOC_S_TUNER);
1254 v4l2_disable_ioctl(&dev->meta_cap_dev, VIDIOC_G_TUNER);
1255 }
1256 if (in_type_counter[HDMI] == 0) {
1257 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_S_EDID);
1258 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_G_EDID);
1259 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_DV_TIMINGS_CAP);
1260 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_G_DV_TIMINGS);
1261 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_S_DV_TIMINGS);
1262 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_ENUM_DV_TIMINGS);
1263 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_QUERY_DV_TIMINGS);
1264 }
1265 if (out_type_counter[HDMI] == 0) {
1266 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_G_EDID);
1267 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_DV_TIMINGS_CAP);
1268 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_G_DV_TIMINGS);
1269 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_S_DV_TIMINGS);
1270 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_ENUM_DV_TIMINGS);
1271 }
1272 if (!dev->has_fb) {
1273 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_G_FBUF);
1274 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_S_FBUF);
1275 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_OVERLAY);
1276 }
1277 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_S_HW_FREQ_SEEK);
1278 v4l2_disable_ioctl(&dev->vbi_cap_dev, VIDIOC_S_HW_FREQ_SEEK);
1279 v4l2_disable_ioctl(&dev->sdr_cap_dev, VIDIOC_S_HW_FREQ_SEEK);
1280 v4l2_disable_ioctl(&dev->meta_cap_dev, VIDIOC_S_HW_FREQ_SEEK);
1281 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_S_FREQUENCY);
1282 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_G_FREQUENCY);
1283 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_ENUM_FRAMESIZES);
1284 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_ENUM_FRAMEINTERVALS);
1285 v4l2_disable_ioctl(&dev->vbi_out_dev, VIDIOC_S_FREQUENCY);
1286 v4l2_disable_ioctl(&dev->vbi_out_dev, VIDIOC_G_FREQUENCY);
1287 v4l2_disable_ioctl(&dev->meta_out_dev, VIDIOC_S_FREQUENCY);
1288 v4l2_disable_ioctl(&dev->meta_out_dev, VIDIOC_G_FREQUENCY);
1289 v4l2_disable_ioctl(&dev->touch_cap_dev, VIDIOC_S_PARM);
1290 v4l2_disable_ioctl(&dev->touch_cap_dev, VIDIOC_ENUM_FRAMESIZES);
1291 v4l2_disable_ioctl(&dev->touch_cap_dev, VIDIOC_ENUM_FRAMEINTERVALS);
1292 }
1293
vivid_init_dv_timings(struct vivid_dev * dev)1294 static int vivid_init_dv_timings(struct vivid_dev *dev)
1295 {
1296 int i;
1297
1298 while (v4l2_dv_timings_presets[dev->query_dv_timings_size].bt.width)
1299 dev->query_dv_timings_size++;
1300
1301 /*
1302 * Create a char pointer array that points to the names of all the
1303 * preset timings
1304 */
1305 dev->query_dv_timings_qmenu = kmalloc_array(dev->query_dv_timings_size,
1306 sizeof(char *), GFP_KERNEL);
1307 /*
1308 * Create a string array containing the names of all the preset
1309 * timings. Each name is max 31 chars long (+ terminating 0).
1310 */
1311 dev->query_dv_timings_qmenu_strings =
1312 kmalloc_array(dev->query_dv_timings_size, 32, GFP_KERNEL);
1313
1314 if (!dev->query_dv_timings_qmenu ||
1315 !dev->query_dv_timings_qmenu_strings)
1316 return -ENOMEM;
1317
1318 for (i = 0; i < dev->query_dv_timings_size; i++) {
1319 const struct v4l2_bt_timings *bt = &v4l2_dv_timings_presets[i].bt;
1320 char *p = dev->query_dv_timings_qmenu_strings + i * 32;
1321 u32 htot, vtot;
1322
1323 dev->query_dv_timings_qmenu[i] = p;
1324
1325 htot = V4L2_DV_BT_FRAME_WIDTH(bt);
1326 vtot = V4L2_DV_BT_FRAME_HEIGHT(bt);
1327 snprintf(p, 32, "%ux%u%s%u",
1328 bt->width, bt->height, bt->interlaced ? "i" : "p",
1329 (u32)bt->pixelclock / (htot * vtot));
1330 }
1331
1332 return 0;
1333 }
1334
vivid_create_queues(struct vivid_dev * dev)1335 static int vivid_create_queues(struct vivid_dev *dev)
1336 {
1337 int ret;
1338
1339 /* start creating the vb2 queues */
1340 if (dev->has_vid_cap) {
1341 /* initialize vid_cap queue */
1342 ret = vivid_create_queue(dev, &dev->vb_vid_cap_q,
1343 V4L2_BUF_TYPE_VIDEO_CAPTURE, 2,
1344 &vivid_vid_cap_qops);
1345 if (ret)
1346 return ret;
1347 }
1348
1349 if (dev->has_vid_out) {
1350 /* initialize vid_out queue */
1351 ret = vivid_create_queue(dev, &dev->vb_vid_out_q,
1352 V4L2_BUF_TYPE_VIDEO_OUTPUT, 2,
1353 &vivid_vid_out_qops);
1354 if (ret)
1355 return ret;
1356 }
1357
1358 if (dev->has_vbi_cap) {
1359 /* initialize vbi_cap queue */
1360 ret = vivid_create_queue(dev, &dev->vb_vbi_cap_q,
1361 V4L2_BUF_TYPE_VBI_CAPTURE, 2,
1362 &vivid_vbi_cap_qops);
1363 if (ret)
1364 return ret;
1365 }
1366
1367 if (dev->has_vbi_out) {
1368 /* initialize vbi_out queue */
1369 ret = vivid_create_queue(dev, &dev->vb_vbi_out_q,
1370 V4L2_BUF_TYPE_VBI_OUTPUT, 2,
1371 &vivid_vbi_out_qops);
1372 if (ret)
1373 return ret;
1374 }
1375
1376 if (dev->has_sdr_cap) {
1377 /* initialize sdr_cap queue */
1378 ret = vivid_create_queue(dev, &dev->vb_sdr_cap_q,
1379 V4L2_BUF_TYPE_SDR_CAPTURE, 8,
1380 &vivid_sdr_cap_qops);
1381 if (ret)
1382 return ret;
1383 }
1384
1385 if (dev->has_meta_cap) {
1386 /* initialize meta_cap queue */
1387 ret = vivid_create_queue(dev, &dev->vb_meta_cap_q,
1388 V4L2_BUF_TYPE_META_CAPTURE, 2,
1389 &vivid_meta_cap_qops);
1390 if (ret)
1391 return ret;
1392 }
1393
1394 if (dev->has_meta_out) {
1395 /* initialize meta_out queue */
1396 ret = vivid_create_queue(dev, &dev->vb_meta_out_q,
1397 V4L2_BUF_TYPE_META_OUTPUT, 2,
1398 &vivid_meta_out_qops);
1399 if (ret)
1400 return ret;
1401 }
1402
1403 if (dev->has_touch_cap) {
1404 /* initialize touch_cap queue */
1405 ret = vivid_create_queue(dev, &dev->vb_touch_cap_q,
1406 V4L2_BUF_TYPE_VIDEO_CAPTURE, 2,
1407 &vivid_touch_cap_qops);
1408 if (ret)
1409 return ret;
1410 }
1411
1412 if (dev->has_fb) {
1413 /* Create framebuffer for testing output overlay */
1414 ret = vivid_fb_init(dev);
1415 if (ret)
1416 return ret;
1417 }
1418 return 0;
1419 }
1420
vivid_create_devnodes(struct platform_device * pdev,struct vivid_dev * dev,int inst,v4l2_std_id tvnorms_cap,v4l2_std_id tvnorms_out,unsigned in_type_counter[4],unsigned out_type_counter[4])1421 static int vivid_create_devnodes(struct platform_device *pdev,
1422 struct vivid_dev *dev, int inst,
1423 v4l2_std_id tvnorms_cap,
1424 v4l2_std_id tvnorms_out,
1425 unsigned in_type_counter[4],
1426 unsigned out_type_counter[4])
1427 {
1428 struct video_device *vfd;
1429 int ret;
1430
1431 if (dev->has_vid_cap) {
1432 vfd = &dev->vid_cap_dev;
1433 snprintf(vfd->name, sizeof(vfd->name),
1434 "vivid-%03d-vid-cap", inst);
1435 vfd->fops = &vivid_fops;
1436 vfd->ioctl_ops = &vivid_ioctl_ops;
1437 vfd->device_caps = dev->vid_cap_caps;
1438 vfd->release = video_device_release_empty;
1439 vfd->v4l2_dev = &dev->v4l2_dev;
1440 vfd->queue = &dev->vb_vid_cap_q;
1441 vfd->tvnorms = tvnorms_cap;
1442
1443 /*
1444 * Provide a mutex to v4l2 core. It will be used to protect
1445 * all fops and v4l2 ioctls.
1446 */
1447 vfd->lock = &dev->mutex;
1448 video_set_drvdata(vfd, dev);
1449
1450 #ifdef CONFIG_MEDIA_CONTROLLER
1451 dev->vid_cap_pad.flags = MEDIA_PAD_FL_SINK;
1452 ret = media_entity_pads_init(&vfd->entity, 1, &dev->vid_cap_pad);
1453 if (ret)
1454 return ret;
1455 #endif
1456
1457 #ifdef CONFIG_VIDEO_VIVID_CEC
1458 if (in_type_counter[HDMI]) {
1459 ret = cec_register_adapter(dev->cec_rx_adap, &pdev->dev);
1460 if (ret < 0) {
1461 cec_delete_adapter(dev->cec_rx_adap);
1462 dev->cec_rx_adap = NULL;
1463 return ret;
1464 }
1465 cec_s_phys_addr(dev->cec_rx_adap, 0, false);
1466 v4l2_info(&dev->v4l2_dev, "CEC adapter %s registered for HDMI input\n",
1467 dev_name(&dev->cec_rx_adap->devnode.dev));
1468 }
1469 #endif
1470
1471 ret = video_register_device(vfd, VFL_TYPE_VIDEO, vid_cap_nr[inst]);
1472 if (ret < 0)
1473 return ret;
1474 v4l2_info(&dev->v4l2_dev, "V4L2 capture device registered as %s\n",
1475 video_device_node_name(vfd));
1476 }
1477
1478 if (dev->has_vid_out) {
1479 #ifdef CONFIG_VIDEO_VIVID_CEC
1480 int i;
1481 #endif
1482 vfd = &dev->vid_out_dev;
1483 snprintf(vfd->name, sizeof(vfd->name),
1484 "vivid-%03d-vid-out", inst);
1485 vfd->vfl_dir = VFL_DIR_TX;
1486 vfd->fops = &vivid_fops;
1487 vfd->ioctl_ops = &vivid_ioctl_ops;
1488 vfd->device_caps = dev->vid_out_caps;
1489 vfd->release = video_device_release_empty;
1490 vfd->v4l2_dev = &dev->v4l2_dev;
1491 vfd->queue = &dev->vb_vid_out_q;
1492 vfd->tvnorms = tvnorms_out;
1493
1494 /*
1495 * Provide a mutex to v4l2 core. It will be used to protect
1496 * all fops and v4l2 ioctls.
1497 */
1498 vfd->lock = &dev->mutex;
1499 video_set_drvdata(vfd, dev);
1500
1501 #ifdef CONFIG_MEDIA_CONTROLLER
1502 dev->vid_out_pad.flags = MEDIA_PAD_FL_SOURCE;
1503 ret = media_entity_pads_init(&vfd->entity, 1, &dev->vid_out_pad);
1504 if (ret)
1505 return ret;
1506 #endif
1507
1508 #ifdef CONFIG_VIDEO_VIVID_CEC
1509 for (i = 0; i < dev->num_hdmi_outputs; i++) {
1510 ret = cec_register_adapter(dev->cec_tx_adap[i], &pdev->dev);
1511 if (ret < 0) {
1512 for (; i >= 0; i--) {
1513 cec_delete_adapter(dev->cec_tx_adap[i]);
1514 dev->cec_tx_adap[i] = NULL;
1515 }
1516 return ret;
1517 }
1518 v4l2_info(&dev->v4l2_dev, "CEC adapter %s registered for HDMI output %d\n",
1519 dev_name(&dev->cec_tx_adap[i]->devnode.dev), i);
1520 }
1521 #endif
1522
1523 ret = video_register_device(vfd, VFL_TYPE_VIDEO, vid_out_nr[inst]);
1524 if (ret < 0)
1525 return ret;
1526 v4l2_info(&dev->v4l2_dev, "V4L2 output device registered as %s\n",
1527 video_device_node_name(vfd));
1528 }
1529
1530 if (dev->has_vbi_cap) {
1531 vfd = &dev->vbi_cap_dev;
1532 snprintf(vfd->name, sizeof(vfd->name),
1533 "vivid-%03d-vbi-cap", inst);
1534 vfd->fops = &vivid_fops;
1535 vfd->ioctl_ops = &vivid_ioctl_ops;
1536 vfd->device_caps = dev->vbi_cap_caps;
1537 vfd->release = video_device_release_empty;
1538 vfd->v4l2_dev = &dev->v4l2_dev;
1539 vfd->queue = &dev->vb_vbi_cap_q;
1540 vfd->lock = &dev->mutex;
1541 vfd->tvnorms = tvnorms_cap;
1542 video_set_drvdata(vfd, dev);
1543
1544 #ifdef CONFIG_MEDIA_CONTROLLER
1545 dev->vbi_cap_pad.flags = MEDIA_PAD_FL_SINK;
1546 ret = media_entity_pads_init(&vfd->entity, 1, &dev->vbi_cap_pad);
1547 if (ret)
1548 return ret;
1549 #endif
1550
1551 ret = video_register_device(vfd, VFL_TYPE_VBI, vbi_cap_nr[inst]);
1552 if (ret < 0)
1553 return ret;
1554 v4l2_info(&dev->v4l2_dev, "V4L2 capture device registered as %s, supports %s VBI\n",
1555 video_device_node_name(vfd),
1556 (dev->has_raw_vbi_cap && dev->has_sliced_vbi_cap) ?
1557 "raw and sliced" :
1558 (dev->has_raw_vbi_cap ? "raw" : "sliced"));
1559 }
1560
1561 if (dev->has_vbi_out) {
1562 vfd = &dev->vbi_out_dev;
1563 snprintf(vfd->name, sizeof(vfd->name),
1564 "vivid-%03d-vbi-out", inst);
1565 vfd->vfl_dir = VFL_DIR_TX;
1566 vfd->fops = &vivid_fops;
1567 vfd->ioctl_ops = &vivid_ioctl_ops;
1568 vfd->device_caps = dev->vbi_out_caps;
1569 vfd->release = video_device_release_empty;
1570 vfd->v4l2_dev = &dev->v4l2_dev;
1571 vfd->queue = &dev->vb_vbi_out_q;
1572 vfd->lock = &dev->mutex;
1573 vfd->tvnorms = tvnorms_out;
1574 video_set_drvdata(vfd, dev);
1575
1576 #ifdef CONFIG_MEDIA_CONTROLLER
1577 dev->vbi_out_pad.flags = MEDIA_PAD_FL_SOURCE;
1578 ret = media_entity_pads_init(&vfd->entity, 1, &dev->vbi_out_pad);
1579 if (ret)
1580 return ret;
1581 #endif
1582
1583 ret = video_register_device(vfd, VFL_TYPE_VBI, vbi_out_nr[inst]);
1584 if (ret < 0)
1585 return ret;
1586 v4l2_info(&dev->v4l2_dev, "V4L2 output device registered as %s, supports %s VBI\n",
1587 video_device_node_name(vfd),
1588 (dev->has_raw_vbi_out && dev->has_sliced_vbi_out) ?
1589 "raw and sliced" :
1590 (dev->has_raw_vbi_out ? "raw" : "sliced"));
1591 }
1592
1593 if (dev->has_sdr_cap) {
1594 vfd = &dev->sdr_cap_dev;
1595 snprintf(vfd->name, sizeof(vfd->name),
1596 "vivid-%03d-sdr-cap", inst);
1597 vfd->fops = &vivid_fops;
1598 vfd->ioctl_ops = &vivid_ioctl_ops;
1599 vfd->device_caps = dev->sdr_cap_caps;
1600 vfd->release = video_device_release_empty;
1601 vfd->v4l2_dev = &dev->v4l2_dev;
1602 vfd->queue = &dev->vb_sdr_cap_q;
1603 vfd->lock = &dev->mutex;
1604 video_set_drvdata(vfd, dev);
1605
1606 #ifdef CONFIG_MEDIA_CONTROLLER
1607 dev->sdr_cap_pad.flags = MEDIA_PAD_FL_SINK;
1608 ret = media_entity_pads_init(&vfd->entity, 1, &dev->sdr_cap_pad);
1609 if (ret)
1610 return ret;
1611 #endif
1612
1613 ret = video_register_device(vfd, VFL_TYPE_SDR, sdr_cap_nr[inst]);
1614 if (ret < 0)
1615 return ret;
1616 v4l2_info(&dev->v4l2_dev, "V4L2 capture device registered as %s\n",
1617 video_device_node_name(vfd));
1618 }
1619
1620 if (dev->has_radio_rx) {
1621 vfd = &dev->radio_rx_dev;
1622 snprintf(vfd->name, sizeof(vfd->name),
1623 "vivid-%03d-rad-rx", inst);
1624 vfd->fops = &vivid_radio_fops;
1625 vfd->ioctl_ops = &vivid_ioctl_ops;
1626 vfd->device_caps = dev->radio_rx_caps;
1627 vfd->release = video_device_release_empty;
1628 vfd->v4l2_dev = &dev->v4l2_dev;
1629 vfd->lock = &dev->mutex;
1630 video_set_drvdata(vfd, dev);
1631
1632 ret = video_register_device(vfd, VFL_TYPE_RADIO, radio_rx_nr[inst]);
1633 if (ret < 0)
1634 return ret;
1635 v4l2_info(&dev->v4l2_dev, "V4L2 receiver device registered as %s\n",
1636 video_device_node_name(vfd));
1637 }
1638
1639 if (dev->has_radio_tx) {
1640 vfd = &dev->radio_tx_dev;
1641 snprintf(vfd->name, sizeof(vfd->name),
1642 "vivid-%03d-rad-tx", inst);
1643 vfd->vfl_dir = VFL_DIR_TX;
1644 vfd->fops = &vivid_radio_fops;
1645 vfd->ioctl_ops = &vivid_ioctl_ops;
1646 vfd->device_caps = dev->radio_tx_caps;
1647 vfd->release = video_device_release_empty;
1648 vfd->v4l2_dev = &dev->v4l2_dev;
1649 vfd->lock = &dev->mutex;
1650 video_set_drvdata(vfd, dev);
1651
1652 ret = video_register_device(vfd, VFL_TYPE_RADIO, radio_tx_nr[inst]);
1653 if (ret < 0)
1654 return ret;
1655 v4l2_info(&dev->v4l2_dev, "V4L2 transmitter device registered as %s\n",
1656 video_device_node_name(vfd));
1657 }
1658
1659 if (dev->has_meta_cap) {
1660 vfd = &dev->meta_cap_dev;
1661 snprintf(vfd->name, sizeof(vfd->name),
1662 "vivid-%03d-meta-cap", inst);
1663 vfd->fops = &vivid_fops;
1664 vfd->ioctl_ops = &vivid_ioctl_ops;
1665 vfd->device_caps = dev->meta_cap_caps;
1666 vfd->release = video_device_release_empty;
1667 vfd->v4l2_dev = &dev->v4l2_dev;
1668 vfd->queue = &dev->vb_meta_cap_q;
1669 vfd->lock = &dev->mutex;
1670 vfd->tvnorms = tvnorms_cap;
1671 video_set_drvdata(vfd, dev);
1672 #ifdef CONFIG_MEDIA_CONTROLLER
1673 dev->meta_cap_pad.flags = MEDIA_PAD_FL_SINK;
1674 ret = media_entity_pads_init(&vfd->entity, 1,
1675 &dev->meta_cap_pad);
1676 if (ret)
1677 return ret;
1678 #endif
1679 ret = video_register_device(vfd, VFL_TYPE_VIDEO,
1680 meta_cap_nr[inst]);
1681 if (ret < 0)
1682 return ret;
1683 v4l2_info(&dev->v4l2_dev,
1684 "V4L2 metadata capture device registered as %s\n",
1685 video_device_node_name(vfd));
1686 }
1687
1688 if (dev->has_meta_out) {
1689 vfd = &dev->meta_out_dev;
1690 snprintf(vfd->name, sizeof(vfd->name),
1691 "vivid-%03d-meta-out", inst);
1692 vfd->vfl_dir = VFL_DIR_TX;
1693 vfd->fops = &vivid_fops;
1694 vfd->ioctl_ops = &vivid_ioctl_ops;
1695 vfd->device_caps = dev->meta_out_caps;
1696 vfd->release = video_device_release_empty;
1697 vfd->v4l2_dev = &dev->v4l2_dev;
1698 vfd->queue = &dev->vb_meta_out_q;
1699 vfd->lock = &dev->mutex;
1700 vfd->tvnorms = tvnorms_out;
1701 video_set_drvdata(vfd, dev);
1702 #ifdef CONFIG_MEDIA_CONTROLLER
1703 dev->meta_out_pad.flags = MEDIA_PAD_FL_SOURCE;
1704 ret = media_entity_pads_init(&vfd->entity, 1,
1705 &dev->meta_out_pad);
1706 if (ret)
1707 return ret;
1708 #endif
1709 ret = video_register_device(vfd, VFL_TYPE_VIDEO,
1710 meta_out_nr[inst]);
1711 if (ret < 0)
1712 return ret;
1713 v4l2_info(&dev->v4l2_dev,
1714 "V4L2 metadata output device registered as %s\n",
1715 video_device_node_name(vfd));
1716 }
1717
1718 if (dev->has_touch_cap) {
1719 vfd = &dev->touch_cap_dev;
1720 snprintf(vfd->name, sizeof(vfd->name),
1721 "vivid-%03d-touch-cap", inst);
1722 vfd->fops = &vivid_fops;
1723 vfd->ioctl_ops = &vivid_ioctl_ops;
1724 vfd->device_caps = dev->touch_cap_caps;
1725 vfd->release = video_device_release_empty;
1726 vfd->v4l2_dev = &dev->v4l2_dev;
1727 vfd->queue = &dev->vb_touch_cap_q;
1728 vfd->tvnorms = tvnorms_cap;
1729 vfd->lock = &dev->mutex;
1730 video_set_drvdata(vfd, dev);
1731 #ifdef CONFIG_MEDIA_CONTROLLER
1732 dev->touch_cap_pad.flags = MEDIA_PAD_FL_SINK;
1733 ret = media_entity_pads_init(&vfd->entity, 1,
1734 &dev->touch_cap_pad);
1735 if (ret)
1736 return ret;
1737 #endif
1738 ret = video_register_device(vfd, VFL_TYPE_TOUCH,
1739 touch_cap_nr[inst]);
1740 if (ret < 0)
1741 return ret;
1742 v4l2_info(&dev->v4l2_dev,
1743 "V4L2 touch capture device registered as %s\n",
1744 video_device_node_name(vfd));
1745 }
1746
1747 #ifdef CONFIG_MEDIA_CONTROLLER
1748 /* Register the media device */
1749 ret = media_device_register(&dev->mdev);
1750 if (ret) {
1751 dev_err(dev->mdev.dev,
1752 "media device register failed (err=%d)\n", ret);
1753 return ret;
1754 }
1755 #endif
1756 return 0;
1757 }
1758
update_hdmi_ctrls_work_handler(struct work_struct * work)1759 static void update_hdmi_ctrls_work_handler(struct work_struct *work)
1760 {
1761 u64 skip_mask;
1762 u64 update_mask;
1763
1764 spin_lock(&hdmi_output_skip_mask_lock);
1765 skip_mask = hdmi_to_output_menu_skip_mask;
1766 update_mask = hdmi_input_update_outputs_mask;
1767 hdmi_input_update_outputs_mask = 0;
1768 spin_unlock(&hdmi_output_skip_mask_lock);
1769 for (int i = 0; i < n_devs && vivid_devs[i]; i++) {
1770 if (update_mask & (1 << i))
1771 vivid_update_connected_outputs(vivid_devs[i]);
1772 for (int j = 0; j < vivid_devs[i]->num_hdmi_inputs; j++) {
1773 struct v4l2_ctrl *c = vivid_devs[i]->ctrl_hdmi_to_output[j];
1774
1775 v4l2_ctrl_modify_range(c, c->minimum, c->maximum,
1776 skip_mask & ~(1ULL << c->cur.val),
1777 c->default_value);
1778 }
1779 }
1780 }
1781
update_svid_ctrls_work_handler(struct work_struct * work)1782 static void update_svid_ctrls_work_handler(struct work_struct *work)
1783 {
1784 u64 skip_mask;
1785
1786 spin_lock(&svid_output_skip_mask_lock);
1787 skip_mask = svid_to_output_menu_skip_mask;
1788 spin_unlock(&svid_output_skip_mask_lock);
1789 for (int i = 0; i < n_devs && vivid_devs[i]; i++) {
1790 for (int j = 0; j < vivid_devs[i]->num_svid_inputs; j++) {
1791 struct v4l2_ctrl *c = vivid_devs[i]->ctrl_svid_to_output[j];
1792
1793 v4l2_ctrl_modify_range(c, c->minimum, c->maximum,
1794 skip_mask & ~(1ULL << c->cur.val),
1795 c->default_value);
1796 }
1797 }
1798 }
1799
vivid_create_instance(struct platform_device * pdev,int inst)1800 static int vivid_create_instance(struct platform_device *pdev, int inst)
1801 {
1802 static const struct v4l2_dv_timings def_dv_timings =
1803 V4L2_DV_BT_CEA_1280X720P60;
1804 unsigned in_type_counter[4] = { 0, 0, 0, 0 };
1805 unsigned out_type_counter[4] = { 0, 0, 0, 0 };
1806 int ccs_cap = ccs_cap_mode[inst];
1807 int ccs_out = ccs_out_mode[inst];
1808 bool has_tuner;
1809 bool has_modulator;
1810 struct vivid_dev *dev;
1811 unsigned node_type = node_types[inst];
1812 v4l2_std_id tvnorms_cap = 0, tvnorms_out = 0;
1813 int ret;
1814 int i;
1815
1816 /* allocate main vivid state structure */
1817 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
1818 if (!dev)
1819 return -ENOMEM;
1820
1821 dev->inst = inst;
1822
1823 #ifdef CONFIG_MEDIA_CONTROLLER
1824 dev->v4l2_dev.mdev = &dev->mdev;
1825
1826 /* Initialize media device */
1827 strscpy(dev->mdev.model, VIVID_MODULE_NAME, sizeof(dev->mdev.model));
1828 snprintf(dev->mdev.bus_info, sizeof(dev->mdev.bus_info),
1829 "platform:%s-%03d", VIVID_MODULE_NAME, inst);
1830 dev->mdev.dev = &pdev->dev;
1831 media_device_init(&dev->mdev);
1832 dev->mdev.ops = &vivid_media_ops;
1833 #endif
1834
1835 /* register v4l2_device */
1836 snprintf(dev->v4l2_dev.name, sizeof(dev->v4l2_dev.name),
1837 "%s-%03d", VIVID_MODULE_NAME, inst);
1838 ret = v4l2_device_register(&pdev->dev, &dev->v4l2_dev);
1839 if (ret) {
1840 kfree(dev);
1841 return ret;
1842 }
1843 dev->v4l2_dev.release = vivid_dev_release;
1844
1845 ret = vivid_detect_feature_set(dev, inst, node_type,
1846 &has_tuner, &has_modulator,
1847 &ccs_cap, &ccs_out,
1848 in_type_counter, out_type_counter);
1849 if (ret)
1850 goto free_dev;
1851
1852 vivid_set_capabilities(dev);
1853
1854 ret = -ENOMEM;
1855 /* initialize the test pattern generator */
1856 tpg_init(&dev->tpg, 640, 360);
1857 if (tpg_alloc(&dev->tpg, array_size(MAX_WIDTH, MAX_ZOOM)))
1858 goto free_dev;
1859 dev->scaled_line = vzalloc(array_size(MAX_WIDTH, MAX_ZOOM));
1860 if (!dev->scaled_line)
1861 goto free_dev;
1862 dev->blended_line = vzalloc(array_size(MAX_WIDTH, MAX_ZOOM));
1863 if (!dev->blended_line)
1864 goto free_dev;
1865
1866 /* load the edid */
1867 dev->edid = vmalloc(array_size(256, 128));
1868 if (!dev->edid)
1869 goto free_dev;
1870
1871 ret = vivid_init_dv_timings(dev);
1872 if (ret < 0)
1873 goto free_dev;
1874
1875 vivid_disable_unused_ioctls(dev, has_tuner, has_modulator,
1876 in_type_counter, out_type_counter);
1877
1878 /* configure internal data */
1879 dev->fmt_cap = &vivid_formats[0];
1880 dev->fmt_out = &vivid_formats[0];
1881 if (!dev->multiplanar)
1882 vivid_formats[0].data_offset[0] = 0;
1883 dev->webcam_size_idx = 1;
1884 dev->webcam_ival_idx = 3;
1885 tpg_s_fourcc(&dev->tpg, dev->fmt_cap->fourcc);
1886 dev->std_out = V4L2_STD_PAL;
1887 if (dev->input_type[0] == TV || dev->input_type[0] == SVID)
1888 tvnorms_cap = V4L2_STD_ALL;
1889 if (dev->output_type[0] == SVID)
1890 tvnorms_out = V4L2_STD_ALL;
1891 for (i = 0; i < MAX_INPUTS; i++) {
1892 dev->dv_timings_cap[i] = def_dv_timings;
1893 dev->std_cap[i] = V4L2_STD_PAL;
1894 }
1895 dev->dv_timings_out = def_dv_timings;
1896 dev->tv_freq = 2804 /* 175.25 * 16 */;
1897 dev->tv_audmode = V4L2_TUNER_MODE_STEREO;
1898 dev->tv_field_cap = V4L2_FIELD_INTERLACED;
1899 dev->tv_field_out = V4L2_FIELD_INTERLACED;
1900 dev->radio_rx_freq = 95000 * 16;
1901 dev->radio_rx_audmode = V4L2_TUNER_MODE_STEREO;
1902 if (dev->has_radio_tx) {
1903 dev->radio_tx_freq = 95500 * 16;
1904 dev->radio_rds_loop = false;
1905 }
1906 dev->radio_tx_subchans = V4L2_TUNER_SUB_STEREO | V4L2_TUNER_SUB_RDS;
1907 dev->sdr_adc_freq = 300000;
1908 dev->sdr_fm_freq = 50000000;
1909 dev->sdr_pixelformat = V4L2_SDR_FMT_CU8;
1910 dev->sdr_buffersize = SDR_CAP_SAMPLES_PER_BUF * 2;
1911
1912 dev->edid_max_blocks = dev->edid_blocks = 2;
1913 memcpy(dev->edid, vivid_hdmi_edid, sizeof(vivid_hdmi_edid));
1914 dev->radio_rds_init_time = ktime_get();
1915 INIT_WORK(&dev->update_hdmi_ctrl_work, update_hdmi_ctrls_work_handler);
1916 INIT_WORK(&dev->update_svid_ctrl_work, update_svid_ctrls_work_handler);
1917 for (int j = 0, k = 0; j < dev->num_inputs; ++j)
1918 if (dev->input_type[j] == HDMI)
1919 dev->hdmi_index_to_input_index[k++] = j;
1920 for (int j = 0, k = 0; j < dev->num_outputs; ++j)
1921 if (dev->output_type[j] == HDMI) {
1922 dev->output_to_iface_index[j] = k;
1923 dev->hdmi_index_to_output_index[k++] = j;
1924 }
1925 for (int j = 0, k = 0; j < dev->num_inputs; ++j)
1926 if (dev->input_type[j] == SVID)
1927 dev->svid_index_to_input_index[k++] = j;
1928 for (int j = 0, k = 0; j < dev->num_outputs; ++j)
1929 if (dev->output_type[j] == SVID)
1930 dev->output_to_iface_index[j] = k++;
1931
1932 /* create all controls */
1933 ret = vivid_create_controls(dev, ccs_cap == -1, ccs_out == -1, no_error_inj,
1934 in_type_counter[TV] || in_type_counter[SVID] ||
1935 out_type_counter[SVID],
1936 in_type_counter[HDMI] || out_type_counter[HDMI]);
1937 if (ret)
1938 goto unreg_dev;
1939
1940 /* enable/disable interface specific controls */
1941 if (dev->num_inputs && dev->input_type[0] != HDMI) {
1942 v4l2_ctrl_activate(dev->ctrl_dv_timings_signal_mode, false);
1943 v4l2_ctrl_activate(dev->ctrl_dv_timings, false);
1944 } else if (dev->num_inputs && dev->input_type[0] == HDMI) {
1945 v4l2_ctrl_activate(dev->ctrl_std_signal_mode, false);
1946 v4l2_ctrl_activate(dev->ctrl_standard, false);
1947 }
1948
1949 /*
1950 * update the capture and output formats to do a proper initial
1951 * configuration.
1952 */
1953 vivid_update_format_cap(dev, false);
1954 vivid_update_format_out(dev);
1955
1956 /* update touch configuration */
1957 dev->timeperframe_tch_cap.numerator = 1;
1958 dev->timeperframe_tch_cap.denominator = 10;
1959 vivid_set_touch(dev, 0);
1960
1961 /* initialize locks */
1962 spin_lock_init(&dev->slock);
1963 mutex_init(&dev->mutex);
1964
1965 /* init dma queues */
1966 INIT_LIST_HEAD(&dev->vid_cap_active);
1967 INIT_LIST_HEAD(&dev->vid_out_active);
1968 INIT_LIST_HEAD(&dev->vbi_cap_active);
1969 INIT_LIST_HEAD(&dev->vbi_out_active);
1970 INIT_LIST_HEAD(&dev->sdr_cap_active);
1971 INIT_LIST_HEAD(&dev->meta_cap_active);
1972 INIT_LIST_HEAD(&dev->meta_out_active);
1973 INIT_LIST_HEAD(&dev->touch_cap_active);
1974
1975 spin_lock_init(&dev->cec_xfers_slock);
1976
1977 if (allocators[inst] == 1)
1978 dma_coerce_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32));
1979
1980 ret = vivid_create_queues(dev);
1981 if (ret)
1982 goto unreg_dev;
1983
1984 #ifdef CONFIG_VIDEO_VIVID_CEC
1985 if (dev->has_vid_cap && in_type_counter[HDMI]) {
1986 struct cec_adapter *adap;
1987
1988 adap = vivid_cec_alloc_adap(dev, 0, false);
1989 ret = PTR_ERR_OR_ZERO(adap);
1990 if (ret < 0)
1991 goto unreg_dev;
1992 dev->cec_rx_adap = adap;
1993 }
1994
1995 if (dev->has_vid_out) {
1996 int j;
1997
1998 for (i = j = 0; i < dev->num_outputs; i++) {
1999 struct cec_adapter *adap;
2000
2001 if (dev->output_type[i] != HDMI)
2002 continue;
2003
2004 adap = vivid_cec_alloc_adap(dev, j, true);
2005 ret = PTR_ERR_OR_ZERO(adap);
2006 if (ret < 0) {
2007 while (j--)
2008 cec_delete_adapter(dev->cec_tx_adap[j]);
2009 goto unreg_dev;
2010 }
2011
2012 dev->cec_tx_adap[j++] = adap;
2013 }
2014 }
2015
2016 if (dev->cec_rx_adap || dev->num_hdmi_outputs) {
2017 init_waitqueue_head(&dev->kthread_waitq_cec);
2018 dev->kthread_cec = kthread_run(vivid_cec_bus_thread, dev,
2019 "vivid_cec-%s", dev->v4l2_dev.name);
2020 if (IS_ERR(dev->kthread_cec)) {
2021 ret = PTR_ERR(dev->kthread_cec);
2022 dev->kthread_cec = NULL;
2023 v4l2_err(&dev->v4l2_dev, "kernel_thread() failed\n");
2024 goto unreg_dev;
2025 }
2026 }
2027
2028 #endif
2029
2030 v4l2_ctrl_handler_setup(&dev->ctrl_hdl_vid_cap);
2031 v4l2_ctrl_handler_setup(&dev->ctrl_hdl_vid_out);
2032 v4l2_ctrl_handler_setup(&dev->ctrl_hdl_vbi_cap);
2033 v4l2_ctrl_handler_setup(&dev->ctrl_hdl_vbi_out);
2034 v4l2_ctrl_handler_setup(&dev->ctrl_hdl_radio_rx);
2035 v4l2_ctrl_handler_setup(&dev->ctrl_hdl_radio_tx);
2036 v4l2_ctrl_handler_setup(&dev->ctrl_hdl_sdr_cap);
2037 v4l2_ctrl_handler_setup(&dev->ctrl_hdl_meta_cap);
2038 v4l2_ctrl_handler_setup(&dev->ctrl_hdl_meta_out);
2039 v4l2_ctrl_handler_setup(&dev->ctrl_hdl_touch_cap);
2040
2041 /* finally start creating the device nodes */
2042 ret = vivid_create_devnodes(pdev, dev, inst,
2043 tvnorms_cap, tvnorms_out,
2044 in_type_counter, out_type_counter);
2045 if (ret)
2046 goto unreg_dev;
2047
2048 /* Now that everything is fine, let's add it to device list */
2049 vivid_devs[inst] = dev;
2050
2051 return 0;
2052
2053 unreg_dev:
2054 vb2_video_unregister_device(&dev->touch_cap_dev);
2055 vb2_video_unregister_device(&dev->meta_out_dev);
2056 vb2_video_unregister_device(&dev->meta_cap_dev);
2057 video_unregister_device(&dev->radio_tx_dev);
2058 video_unregister_device(&dev->radio_rx_dev);
2059 vb2_video_unregister_device(&dev->sdr_cap_dev);
2060 vb2_video_unregister_device(&dev->vbi_out_dev);
2061 vb2_video_unregister_device(&dev->vbi_cap_dev);
2062 vb2_video_unregister_device(&dev->vid_out_dev);
2063 vb2_video_unregister_device(&dev->vid_cap_dev);
2064 cec_unregister_adapter(dev->cec_rx_adap);
2065 for (i = 0; i < MAX_HDMI_OUTPUTS; i++)
2066 cec_unregister_adapter(dev->cec_tx_adap[i]);
2067 if (dev->kthread_cec)
2068 kthread_stop(dev->kthread_cec);
2069 free_dev:
2070 v4l2_device_put(&dev->v4l2_dev);
2071 return ret;
2072 }
2073
2074 /* This routine allocates from 1 to n_devs virtual drivers.
2075
2076 The real maximum number of virtual drivers will depend on how many drivers
2077 will succeed. This is limited to the maximum number of devices that
2078 videodev supports, which is equal to VIDEO_NUM_DEVICES.
2079 */
vivid_probe(struct platform_device * pdev)2080 static int vivid_probe(struct platform_device *pdev)
2081 {
2082 const struct font_desc *font = find_font("VGA8x16");
2083 int ret = 0, i;
2084
2085 if (font == NULL) {
2086 pr_err("vivid: could not find font\n");
2087 return -ENODEV;
2088 }
2089
2090 tpg_set_font(font->data);
2091
2092 n_devs = clamp_t(unsigned, n_devs, 1, VIVID_MAX_DEVS);
2093
2094 for (i = 0; i < n_devs; i++) {
2095 ret = vivid_create_instance(pdev, i);
2096 if (ret) {
2097 /* If some instantiations succeeded, keep driver */
2098 if (i)
2099 ret = 0;
2100 break;
2101 }
2102 }
2103
2104 if (ret < 0) {
2105 pr_err("vivid: error %d while loading driver\n", ret);
2106 return ret;
2107 }
2108
2109 /* n_devs will reflect the actual number of allocated devices */
2110 n_devs = i;
2111
2112 /* Determine qmenu items actually in use */
2113 int hdmi_count = FIXED_MENU_ITEMS;
2114 int svid_count = FIXED_MENU_ITEMS;
2115
2116 for (int i = 0; i < n_devs; i++) {
2117 struct vivid_dev *dev = vivid_devs[i];
2118
2119 if (!dev->has_vid_out)
2120 continue;
2121 for (int j = 0; j < dev->num_outputs && hdmi_count < MAX_MENU_ITEMS; ++j) {
2122 if (dev->output_type[j] == HDMI) {
2123 vivid_ctrl_hdmi_to_output_instance[hdmi_count] = vivid_devs[i];
2124 vivid_ctrl_hdmi_to_output_index[hdmi_count++] = j;
2125 }
2126 }
2127 for (int j = 0; j < dev->num_outputs && svid_count < MAX_MENU_ITEMS; ++j) {
2128 if (dev->output_type[j] == SVID) {
2129 vivid_ctrl_svid_to_output_instance[svid_count] = vivid_devs[i];
2130 vivid_ctrl_svid_to_output_index[svid_count++] = j;
2131 }
2132 }
2133 }
2134 hdmi_count = min(hdmi_count, MAX_MENU_ITEMS);
2135 svid_count = min(svid_count, MAX_MENU_ITEMS);
2136 for (int i = 0; i < n_devs; i++) {
2137 for (int j = 0; j < vivid_devs[i]->num_hdmi_inputs; j++) {
2138 struct v4l2_ctrl *c = vivid_devs[i]->ctrl_hdmi_to_output[j];
2139
2140 v4l2_ctrl_modify_range(c, c->minimum, hdmi_count - 1, 0, c->default_value);
2141 }
2142 for (int j = 0; j < vivid_devs[i]->num_svid_inputs; j++) {
2143 struct v4l2_ctrl *c = vivid_devs[i]->ctrl_svid_to_output[j];
2144
2145 v4l2_ctrl_modify_range(c, c->minimum, svid_count - 1, 0, c->default_value);
2146 }
2147 }
2148 return ret;
2149 }
2150
vivid_remove(struct platform_device * pdev)2151 static void vivid_remove(struct platform_device *pdev)
2152 {
2153 struct vivid_dev *dev;
2154 unsigned int i, j;
2155
2156 for (i = 0; i < n_devs; i++) {
2157 dev = vivid_devs[i];
2158 if (!dev)
2159 continue;
2160
2161 if (dev->disconnect_error)
2162 vivid_reconnect(dev);
2163 #ifdef CONFIG_MEDIA_CONTROLLER
2164 media_device_unregister(&dev->mdev);
2165 #endif
2166
2167 if (dev->has_vid_cap) {
2168 v4l2_info(&dev->v4l2_dev, "unregistering %s\n",
2169 video_device_node_name(&dev->vid_cap_dev));
2170 vb2_video_unregister_device(&dev->vid_cap_dev);
2171 }
2172 if (dev->has_vid_out) {
2173 v4l2_info(&dev->v4l2_dev, "unregistering %s\n",
2174 video_device_node_name(&dev->vid_out_dev));
2175 vb2_video_unregister_device(&dev->vid_out_dev);
2176 }
2177 if (dev->has_vbi_cap) {
2178 v4l2_info(&dev->v4l2_dev, "unregistering %s\n",
2179 video_device_node_name(&dev->vbi_cap_dev));
2180 vb2_video_unregister_device(&dev->vbi_cap_dev);
2181 }
2182 if (dev->has_vbi_out) {
2183 v4l2_info(&dev->v4l2_dev, "unregistering %s\n",
2184 video_device_node_name(&dev->vbi_out_dev));
2185 vb2_video_unregister_device(&dev->vbi_out_dev);
2186 }
2187 if (dev->has_sdr_cap) {
2188 v4l2_info(&dev->v4l2_dev, "unregistering %s\n",
2189 video_device_node_name(&dev->sdr_cap_dev));
2190 vb2_video_unregister_device(&dev->sdr_cap_dev);
2191 }
2192 if (dev->has_radio_rx) {
2193 v4l2_info(&dev->v4l2_dev, "unregistering %s\n",
2194 video_device_node_name(&dev->radio_rx_dev));
2195 video_unregister_device(&dev->radio_rx_dev);
2196 }
2197 if (dev->has_radio_tx) {
2198 v4l2_info(&dev->v4l2_dev, "unregistering %s\n",
2199 video_device_node_name(&dev->radio_tx_dev));
2200 video_unregister_device(&dev->radio_tx_dev);
2201 }
2202 if (dev->has_fb)
2203 vivid_fb_deinit(dev);
2204 if (dev->has_meta_cap) {
2205 v4l2_info(&dev->v4l2_dev, "unregistering %s\n",
2206 video_device_node_name(&dev->meta_cap_dev));
2207 vb2_video_unregister_device(&dev->meta_cap_dev);
2208 }
2209 if (dev->has_meta_out) {
2210 v4l2_info(&dev->v4l2_dev, "unregistering %s\n",
2211 video_device_node_name(&dev->meta_out_dev));
2212 vb2_video_unregister_device(&dev->meta_out_dev);
2213 }
2214 if (dev->has_touch_cap) {
2215 v4l2_info(&dev->v4l2_dev, "unregistering %s\n",
2216 video_device_node_name(&dev->touch_cap_dev));
2217 vb2_video_unregister_device(&dev->touch_cap_dev);
2218 }
2219 cec_unregister_adapter(dev->cec_rx_adap);
2220 for (j = 0; j < MAX_HDMI_OUTPUTS; j++)
2221 cec_unregister_adapter(dev->cec_tx_adap[j]);
2222 if (dev->kthread_cec)
2223 kthread_stop(dev->kthread_cec);
2224 v4l2_device_put(&dev->v4l2_dev);
2225 vivid_devs[i] = NULL;
2226 }
2227 }
2228
vivid_pdev_release(struct device * dev)2229 static void vivid_pdev_release(struct device *dev)
2230 {
2231 }
2232
2233 static struct platform_device vivid_pdev = {
2234 .name = "vivid",
2235 .dev.release = vivid_pdev_release,
2236 };
2237
2238 static struct platform_driver vivid_pdrv = {
2239 .probe = vivid_probe,
2240 .remove = vivid_remove,
2241 .driver = {
2242 .name = "vivid",
2243 },
2244 };
2245
vivid_init(void)2246 static int __init vivid_init(void)
2247 {
2248 int hdmi_count = FIXED_MENU_ITEMS;
2249 int svid_count = FIXED_MENU_ITEMS;
2250 int ret = -ENOMEM;
2251 unsigned int ndevs;
2252
2253 /* Sanity check, prevent insane number of vivid instances */
2254 if (n_devs > 64)
2255 n_devs = 64;
2256 ndevs = clamp_t(unsigned int, n_devs, 1, VIVID_MAX_DEVS);
2257
2258 for (unsigned int i = 0; i < ndevs; i++) {
2259 if (!(node_types[i] & (1 << 8)))
2260 continue;
2261 unsigned int n_outputs = min(num_outputs[i], MAX_OUTPUTS);
2262
2263 for (u8 j = 0, k = 0; j < n_outputs && hdmi_count < MAX_MENU_ITEMS &&
2264 k < MAX_HDMI_OUTPUTS; ++j) {
2265 if (output_types[i] & BIT(j)) {
2266 vivid_ctrl_hdmi_to_output_strings[hdmi_count] =
2267 kmalloc(MAX_STRING_LENGTH, GFP_KERNEL);
2268 if (!vivid_ctrl_hdmi_to_output_strings[hdmi_count])
2269 goto free_output_strings;
2270 snprintf(vivid_ctrl_hdmi_to_output_strings[hdmi_count],
2271 MAX_STRING_LENGTH, "Output HDMI %03d-%d",
2272 i & 0xff, k);
2273 k++;
2274 hdmi_count++;
2275 }
2276 }
2277 for (u8 j = 0, k = 0; j < n_outputs && svid_count < MAX_MENU_ITEMS; ++j) {
2278 if (!(output_types[i] & BIT(j))) {
2279 vivid_ctrl_svid_to_output_strings[svid_count] =
2280 kmalloc(MAX_STRING_LENGTH, GFP_KERNEL);
2281 if (!vivid_ctrl_svid_to_output_strings[svid_count])
2282 goto free_output_strings;
2283 snprintf(vivid_ctrl_svid_to_output_strings[svid_count],
2284 MAX_STRING_LENGTH, "Output S-Video %03d-%d",
2285 i & 0xff, k);
2286 k++;
2287 svid_count++;
2288 }
2289 }
2290 }
2291 ret = platform_device_register(&vivid_pdev);
2292 if (ret)
2293 goto free_output_strings;
2294 ret = platform_driver_register(&vivid_pdrv);
2295 if (ret)
2296 goto unreg_device;
2297
2298 /* Initialize workqueue before module is loaded */
2299 update_hdmi_ctrls_workqueue = create_workqueue("update_hdmi_ctrls_wq");
2300 if (!update_hdmi_ctrls_workqueue) {
2301 ret = -ENOMEM;
2302 goto unreg_driver;
2303 }
2304 update_svid_ctrls_workqueue = create_workqueue("update_svid_ctrls_wq");
2305 if (!update_svid_ctrls_workqueue) {
2306 ret = -ENOMEM;
2307 goto destroy_hdmi_wq;
2308 }
2309 return ret;
2310
2311 destroy_hdmi_wq:
2312 destroy_workqueue(update_hdmi_ctrls_workqueue);
2313 unreg_driver:
2314 platform_driver_register(&vivid_pdrv);
2315 unreg_device:
2316 platform_device_unregister(&vivid_pdev);
2317 free_output_strings:
2318 for (int i = FIXED_MENU_ITEMS; i < MAX_MENU_ITEMS; i++) {
2319 kfree(vivid_ctrl_hdmi_to_output_strings[i]);
2320 kfree(vivid_ctrl_svid_to_output_strings[i]);
2321 }
2322 return ret;
2323 }
2324
vivid_exit(void)2325 static void __exit vivid_exit(void)
2326 {
2327 for (int i = FIXED_MENU_ITEMS; i < MAX_MENU_ITEMS; i++) {
2328 kfree(vivid_ctrl_hdmi_to_output_strings[i]);
2329 kfree(vivid_ctrl_svid_to_output_strings[i]);
2330 }
2331 destroy_workqueue(update_svid_ctrls_workqueue);
2332 destroy_workqueue(update_hdmi_ctrls_workqueue);
2333 platform_driver_unregister(&vivid_pdrv);
2334 platform_device_unregister(&vivid_pdev);
2335 }
2336
2337 module_init(vivid_init);
2338 module_exit(vivid_exit);
2339