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