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