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