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