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