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