?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge tag 'for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mst/vhost
[cris-mirror.git] / drivers / media / platform / vivid / vivid-core.c
blob9f036c5f51b09ecced19273e62761fb9f6670369
1 /*
2 * vivid-core.c - A Virtual Video Test Driver, core initialization
3 *
4 * Copyright 2014 Cisco Systems, Inc. and/or its affiliates. All rights reserved.
5 *
6 * This program is free software; you may redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; version 2 of the License.
9 *
10 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
11 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
12 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
13 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
14 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
15 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
16 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
17 * SOFTWARE.
18 */
19
20 #include <linux/module.h>
21 #include <linux/errno.h>
22 #include <linux/kernel.h>
23 #include <linux/init.h>
24 #include <linux/sched.h>
25 #include <linux/slab.h>
26 #include <linux/vmalloc.h>
27 #include <linux/font.h>
28 #include <linux/mutex.h>
29 #include <linux/platform_device.h>
30 #include <linux/videodev2.h>
31 #include <linux/v4l2-dv-timings.h>
32 #include <media/videobuf2-vmalloc.h>
33 #include <media/videobuf2-dma-contig.h>
34 #include <media/v4l2-dv-timings.h>
35 #include <media/v4l2-ioctl.h>
36 #include <media/v4l2-fh.h>
37 #include <media/v4l2-event.h>
38
39 #include "vivid-core.h"
40 #include "vivid-vid-common.h"
41 #include "vivid-vid-cap.h"
42 #include "vivid-vid-out.h"
43 #include "vivid-radio-common.h"
44 #include "vivid-radio-rx.h"
45 #include "vivid-radio-tx.h"
46 #include "vivid-sdr-cap.h"
47 #include "vivid-vbi-cap.h"
48 #include "vivid-vbi-out.h"
49 #include "vivid-osd.h"
50 #include "vivid-cec.h"
51 #include "vivid-ctrls.h"
52
53 #define VIVID_MODULE_NAME "vivid"
54
55 /* The maximum number of vivid devices */
56 #define VIVID_MAX_DEVS CONFIG_VIDEO_VIVID_MAX_DEVS
57
58 MODULE_DESCRIPTION("Virtual Video Test Driver");
59 MODULE_AUTHOR("Hans Verkuil");
60 MODULE_LICENSE("GPL");
61
62 static unsigned n_devs = 1;
63 module_param(n_devs, uint, 0444);
64 MODULE_PARM_DESC(n_devs, " number of driver instances to create");
65
66 static int vid_cap_nr[VIVID_MAX_DEVS] = { [0 ... (VIVID_MAX_DEVS - 1)] = -1 };
67 module_param_array(vid_cap_nr, int, NULL, 0444);
68 MODULE_PARM_DESC(vid_cap_nr, " videoX start number, -1 is autodetect");
69
70 static int vid_out_nr[VIVID_MAX_DEVS] = { [0 ... (VIVID_MAX_DEVS - 1)] = -1 };
71 module_param_array(vid_out_nr, int, NULL, 0444);
72 MODULE_PARM_DESC(vid_out_nr, " videoX start number, -1 is autodetect");
73
74 static int vbi_cap_nr[VIVID_MAX_DEVS] = { [0 ... (VIVID_MAX_DEVS - 1)] = -1 };
75 module_param_array(vbi_cap_nr, int, NULL, 0444);
76 MODULE_PARM_DESC(vbi_cap_nr, " vbiX start number, -1 is autodetect");
77
78 static int vbi_out_nr[VIVID_MAX_DEVS] = { [0 ... (VIVID_MAX_DEVS - 1)] = -1 };
79 module_param_array(vbi_out_nr, int, NULL, 0444);
80 MODULE_PARM_DESC(vbi_out_nr, " vbiX start number, -1 is autodetect");
81
82 static int sdr_cap_nr[VIVID_MAX_DEVS] = { [0 ... (VIVID_MAX_DEVS - 1)] = -1 };
83 module_param_array(sdr_cap_nr, int, NULL, 0444);
84 MODULE_PARM_DESC(sdr_cap_nr, " swradioX start number, -1 is autodetect");
85
86 static int radio_rx_nr[VIVID_MAX_DEVS] = { [0 ... (VIVID_MAX_DEVS - 1)] = -1 };
87 module_param_array(radio_rx_nr, int, NULL, 0444);
88 MODULE_PARM_DESC(radio_rx_nr, " radioX start number, -1 is autodetect");
89
90 static int radio_tx_nr[VIVID_MAX_DEVS] = { [0 ... (VIVID_MAX_DEVS - 1)] = -1 };
91 module_param_array(radio_tx_nr, int, NULL, 0444);
92 MODULE_PARM_DESC(radio_tx_nr, " radioX start number, -1 is autodetect");
93
94 static int ccs_cap_mode[VIVID_MAX_DEVS] = { [0 ... (VIVID_MAX_DEVS - 1)] = -1 };
95 module_param_array(ccs_cap_mode, int, NULL, 0444);
96 MODULE_PARM_DESC(ccs_cap_mode, " capture crop/compose/scale mode:\n"
97 "\t\t bit 0=crop, 1=compose, 2=scale,\n"
98 "\t\t -1=user-controlled (default)");
99
100 static int ccs_out_mode[VIVID_MAX_DEVS] = { [0 ... (VIVID_MAX_DEVS - 1)] = -1 };
101 module_param_array(ccs_out_mode, int, NULL, 0444);
102 MODULE_PARM_DESC(ccs_out_mode, " output crop/compose/scale mode:\n"
103 "\t\t bit 0=crop, 1=compose, 2=scale,\n"
104 "\t\t -1=user-controlled (default)");
105
106 static unsigned multiplanar[VIVID_MAX_DEVS] = { [0 ... (VIVID_MAX_DEVS - 1)] = 1 };
107 module_param_array(multiplanar, uint, NULL, 0444);
108 MODULE_PARM_DESC(multiplanar, " 1 (default) creates a single planar device, 2 creates a multiplanar device.");
109
110 /* Default: video + vbi-cap (raw and sliced) + radio rx + radio tx + sdr + vbi-out + vid-out */
111 static unsigned node_types[VIVID_MAX_DEVS] = { [0 ... (VIVID_MAX_DEVS - 1)] = 0x1d3d };
112 module_param_array(node_types, uint, NULL, 0444);
113 MODULE_PARM_DESC(node_types, " node types, default is 0x1d3d. Bitmask with the following meaning:\n"
114 "\t\t bit 0: Video Capture node\n"
115 "\t\t bit 2-3: VBI Capture node: 0 = none, 1 = raw vbi, 2 = sliced vbi, 3 = both\n"
116 "\t\t bit 4: Radio Receiver node\n"
117 "\t\t bit 5: Software Defined Radio Receiver node\n"
118 "\t\t bit 8: Video Output node\n"
119 "\t\t bit 10-11: VBI Output node: 0 = none, 1 = raw vbi, 2 = sliced vbi, 3 = both\n"
120 "\t\t bit 12: Radio Transmitter node\n"
121 "\t\t bit 16: Framebuffer for testing overlays");
122
123 /* Default: 4 inputs */
124 static unsigned num_inputs[VIVID_MAX_DEVS] = { [0 ... (VIVID_MAX_DEVS - 1)] = 4 };
125 module_param_array(num_inputs, uint, NULL, 0444);
126 MODULE_PARM_DESC(num_inputs, " number of inputs, default is 4");
127
128 /* Default: input 0 = WEBCAM, 1 = TV, 2 = SVID, 3 = HDMI */
129 static unsigned input_types[VIVID_MAX_DEVS] = { [0 ... (VIVID_MAX_DEVS - 1)] = 0xe4 };
130 module_param_array(input_types, uint, NULL, 0444);
131 MODULE_PARM_DESC(input_types, " input types, default is 0xe4. Two bits per input,\n"
132 "\t\t bits 0-1 == input 0, bits 31-30 == input 15.\n"
133 "\t\t Type 0 == webcam, 1 == TV, 2 == S-Video, 3 == HDMI");
134
135 /* Default: 2 outputs */
136 static unsigned num_outputs[VIVID_MAX_DEVS] = { [0 ... (VIVID_MAX_DEVS - 1)] = 2 };
137 module_param_array(num_outputs, uint, NULL, 0444);
138 MODULE_PARM_DESC(num_outputs, " number of outputs, default is 2");
139
140 /* Default: output 0 = SVID, 1 = HDMI */
141 static unsigned output_types[VIVID_MAX_DEVS] = { [0 ... (VIVID_MAX_DEVS - 1)] = 2 };
142 module_param_array(output_types, uint, NULL, 0444);
143 MODULE_PARM_DESC(output_types, " output types, default is 0x02. One bit per output,\n"
144 "\t\t bit 0 == output 0, bit 15 == output 15.\n"
145 "\t\t Type 0 == S-Video, 1 == HDMI");
146
147 unsigned vivid_debug;
148 module_param(vivid_debug, uint, 0644);
149 MODULE_PARM_DESC(vivid_debug, " activates debug info");
150
151 static bool no_error_inj;
152 module_param(no_error_inj, bool, 0444);
153 MODULE_PARM_DESC(no_error_inj, " if set disable the error injecting controls");
154
155 static unsigned int allocators[VIVID_MAX_DEVS] = { [0 ... (VIVID_MAX_DEVS - 1)] = 0 };
156 module_param_array(allocators, uint, NULL, 0444);
157 MODULE_PARM_DESC(allocators, " memory allocator selection, default is 0.\n"
158 "\t\t 0 == vmalloc\n"
159 "\t\t 1 == dma-contig");
160
161 static struct vivid_dev *vivid_devs[VIVID_MAX_DEVS];
162
163 const struct v4l2_rect vivid_min_rect = {
164 0, 0, MIN_WIDTH, MIN_HEIGHT
165 };
166
167 const struct v4l2_rect vivid_max_rect = {
168 0, 0, MAX_WIDTH * MAX_ZOOM, MAX_HEIGHT * MAX_ZOOM
169 };
170
171 static const u8 vivid_hdmi_edid[256] = {
172 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00,
173 0x31, 0xd8, 0x34, 0x12, 0x00, 0x00, 0x00, 0x00,
174 0x22, 0x1a, 0x01, 0x03, 0x80, 0x60, 0x36, 0x78,
175 0x0f, 0xee, 0x91, 0xa3, 0x54, 0x4c, 0x99, 0x26,
176 0x0f, 0x50, 0x54, 0x2f, 0xcf, 0x00, 0x31, 0x59,
177 0x45, 0x59, 0x81, 0x80, 0x81, 0x40, 0x90, 0x40,
178 0x95, 0x00, 0xa9, 0x40, 0xb3, 0x00, 0x08, 0xe8,
179 0x00, 0x30, 0xf2, 0x70, 0x5a, 0x80, 0xb0, 0x58,
180 0x8a, 0x00, 0xc0, 0x1c, 0x32, 0x00, 0x00, 0x1e,
181 0x00, 0x00, 0x00, 0xfd, 0x00, 0x18, 0x55, 0x18,
182 0x87, 0x3c, 0x00, 0x0a, 0x20, 0x20, 0x20, 0x20,
183 0x20, 0x20, 0x00, 0x00, 0x00, 0xfc, 0x00, 0x76,
184 0x69, 0x76, 0x69, 0x64, 0x0a, 0x20, 0x20, 0x20,
185 0x20, 0x20, 0x20, 0x20, 0x00, 0x00, 0x00, 0x10,
186 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
187 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x7b,
188
189 0x02, 0x03, 0x3f, 0xf0, 0x51, 0x61, 0x60, 0x5f,
190 0x5e, 0x5d, 0x10, 0x1f, 0x04, 0x13, 0x22, 0x21,
191 0x20, 0x05, 0x14, 0x02, 0x11, 0x01, 0x23, 0x09,
192 0x07, 0x07, 0x83, 0x01, 0x00, 0x00, 0x6d, 0x03,
193 0x0c, 0x00, 0x10, 0x00, 0x00, 0x3c, 0x21, 0x00,
194 0x60, 0x01, 0x02, 0x03, 0x67, 0xd8, 0x5d, 0xc4,
195 0x01, 0x78, 0x00, 0x00, 0xe2, 0x00, 0xea, 0xe3,
196 0x05, 0x00, 0x00, 0xe3, 0x06, 0x01, 0x00, 0x4d,
197 0xd0, 0x00, 0xa0, 0xf0, 0x70, 0x3e, 0x80, 0x30,
198 0x20, 0x35, 0x00, 0xc0, 0x1c, 0x32, 0x00, 0x00,
199 0x1e, 0x1a, 0x36, 0x80, 0xa0, 0x70, 0x38, 0x1f,
200 0x40, 0x30, 0x20, 0x35, 0x00, 0xc0, 0x1c, 0x32,
201 0x00, 0x00, 0x1a, 0x1a, 0x1d, 0x00, 0x80, 0x51,
202 0xd0, 0x1c, 0x20, 0x40, 0x80, 0x35, 0x00, 0xc0,
203 0x1c, 0x32, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00,
204 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x63,
205 };
206
207 static int vidioc_querycap(struct file *file, void *priv,
208 struct v4l2_capability *cap)
209 {
210 struct vivid_dev *dev = video_drvdata(file);
211
212 strcpy(cap->driver, "vivid");
213 strcpy(cap->card, "vivid");
214 snprintf(cap->bus_info, sizeof(cap->bus_info),
215 "platform:%s", dev->v4l2_dev.name);
216
217 cap->capabilities = dev->vid_cap_caps | dev->vid_out_caps |
218 dev->vbi_cap_caps | dev->vbi_out_caps |
219 dev->radio_rx_caps | dev->radio_tx_caps |
220 dev->sdr_cap_caps | V4L2_CAP_DEVICE_CAPS;
221 return 0;
222 }
223
224 static int vidioc_s_hw_freq_seek(struct file *file, void *fh, const struct v4l2_hw_freq_seek *a)
225 {
226 struct video_device *vdev = video_devdata(file);
227
228 if (vdev->vfl_type == VFL_TYPE_RADIO)
229 return vivid_radio_rx_s_hw_freq_seek(file, fh, a);
230 return -ENOTTY;
231 }
232
233 static int vidioc_enum_freq_bands(struct file *file, void *fh, struct v4l2_frequency_band *band)
234 {
235 struct video_device *vdev = video_devdata(file);
236
237 if (vdev->vfl_type == VFL_TYPE_RADIO)
238 return vivid_radio_rx_enum_freq_bands(file, fh, band);
239 if (vdev->vfl_type == VFL_TYPE_SDR)
240 return vivid_sdr_enum_freq_bands(file, fh, band);
241 return -ENOTTY;
242 }
243
244 static int vidioc_g_tuner(struct file *file, void *fh, struct v4l2_tuner *vt)
245 {
246 struct video_device *vdev = video_devdata(file);
247
248 if (vdev->vfl_type == VFL_TYPE_RADIO)
249 return vivid_radio_rx_g_tuner(file, fh, vt);
250 if (vdev->vfl_type == VFL_TYPE_SDR)
251 return vivid_sdr_g_tuner(file, fh, vt);
252 return vivid_video_g_tuner(file, fh, vt);
253 }
254
255 static int vidioc_s_tuner(struct file *file, void *fh, const struct v4l2_tuner *vt)
256 {
257 struct video_device *vdev = video_devdata(file);
258
259 if (vdev->vfl_type == VFL_TYPE_RADIO)
260 return vivid_radio_rx_s_tuner(file, fh, vt);
261 if (vdev->vfl_type == VFL_TYPE_SDR)
262 return vivid_sdr_s_tuner(file, fh, vt);
263 return vivid_video_s_tuner(file, fh, vt);
264 }
265
266 static int vidioc_g_frequency(struct file *file, void *fh, struct v4l2_frequency *vf)
267 {
268 struct vivid_dev *dev = video_drvdata(file);
269 struct video_device *vdev = video_devdata(file);
270
271 if (vdev->vfl_type == VFL_TYPE_RADIO)
272 return vivid_radio_g_frequency(file,
273 vdev->vfl_dir == VFL_DIR_RX ?
274 &dev->radio_rx_freq : &dev->radio_tx_freq, vf);
275 if (vdev->vfl_type == VFL_TYPE_SDR)
276 return vivid_sdr_g_frequency(file, fh, vf);
277 return vivid_video_g_frequency(file, fh, vf);
278 }
279
280 static int vidioc_s_frequency(struct file *file, void *fh, const struct v4l2_frequency *vf)
281 {
282 struct vivid_dev *dev = video_drvdata(file);
283 struct video_device *vdev = video_devdata(file);
284
285 if (vdev->vfl_type == VFL_TYPE_RADIO)
286 return vivid_radio_s_frequency(file,
287 vdev->vfl_dir == VFL_DIR_RX ?
288 &dev->radio_rx_freq : &dev->radio_tx_freq, vf);
289 if (vdev->vfl_type == VFL_TYPE_SDR)
290 return vivid_sdr_s_frequency(file, fh, vf);
291 return vivid_video_s_frequency(file, fh, vf);
292 }
293
294 static int vidioc_overlay(struct file *file, void *fh, unsigned i)
295 {
296 struct video_device *vdev = video_devdata(file);
297
298 if (vdev->vfl_dir == VFL_DIR_RX)
299 return vivid_vid_cap_overlay(file, fh, i);
300 return vivid_vid_out_overlay(file, fh, i);
301 }
302
303 static int vidioc_g_fbuf(struct file *file, void *fh, struct v4l2_framebuffer *a)
304 {
305 struct video_device *vdev = video_devdata(file);
306
307 if (vdev->vfl_dir == VFL_DIR_RX)
308 return vivid_vid_cap_g_fbuf(file, fh, a);
309 return vivid_vid_out_g_fbuf(file, fh, a);
310 }
311
312 static int vidioc_s_fbuf(struct file *file, void *fh, const struct v4l2_framebuffer *a)
313 {
314 struct video_device *vdev = video_devdata(file);
315
316 if (vdev->vfl_dir == VFL_DIR_RX)
317 return vivid_vid_cap_s_fbuf(file, fh, a);
318 return vivid_vid_out_s_fbuf(file, fh, a);
319 }
320
321 static int vidioc_s_std(struct file *file, void *fh, v4l2_std_id id)
322 {
323 struct video_device *vdev = video_devdata(file);
324
325 if (vdev->vfl_dir == VFL_DIR_RX)
326 return vivid_vid_cap_s_std(file, fh, id);
327 return vivid_vid_out_s_std(file, fh, id);
328 }
329
330 static int vidioc_s_dv_timings(struct file *file, void *fh, struct v4l2_dv_timings *timings)
331 {
332 struct video_device *vdev = video_devdata(file);
333
334 if (vdev->vfl_dir == VFL_DIR_RX)
335 return vivid_vid_cap_s_dv_timings(file, fh, timings);
336 return vivid_vid_out_s_dv_timings(file, fh, timings);
337 }
338
339 static int vidioc_cropcap(struct file *file, void *fh, struct v4l2_cropcap *cc)
340 {
341 struct video_device *vdev = video_devdata(file);
342
343 if (vdev->vfl_dir == VFL_DIR_RX)
344 return vivid_vid_cap_cropcap(file, fh, cc);
345 return vivid_vid_out_cropcap(file, fh, cc);
346 }
347
348 static int vidioc_g_selection(struct file *file, void *fh,
349 struct v4l2_selection *sel)
350 {
351 struct video_device *vdev = video_devdata(file);
352
353 if (vdev->vfl_dir == VFL_DIR_RX)
354 return vivid_vid_cap_g_selection(file, fh, sel);
355 return vivid_vid_out_g_selection(file, fh, sel);
356 }
357
358 static int vidioc_s_selection(struct file *file, void *fh,
359 struct v4l2_selection *sel)
360 {
361 struct video_device *vdev = video_devdata(file);
362
363 if (vdev->vfl_dir == VFL_DIR_RX)
364 return vivid_vid_cap_s_selection(file, fh, sel);
365 return vivid_vid_out_s_selection(file, fh, sel);
366 }
367
368 static int vidioc_g_parm(struct file *file, void *fh,
369 struct v4l2_streamparm *parm)
370 {
371 struct video_device *vdev = video_devdata(file);
372
373 if (vdev->vfl_dir == VFL_DIR_RX)
374 return vivid_vid_cap_g_parm(file, fh, parm);
375 return vivid_vid_out_g_parm(file, fh, parm);
376 }
377
378 static int vidioc_s_parm(struct file *file, void *fh,
379 struct v4l2_streamparm *parm)
380 {
381 struct video_device *vdev = video_devdata(file);
382
383 if (vdev->vfl_dir == VFL_DIR_RX)
384 return vivid_vid_cap_s_parm(file, fh, parm);
385 return vivid_vid_out_g_parm(file, fh, parm);
386 }
387
388 static int vidioc_log_status(struct file *file, void *fh)
389 {
390 struct vivid_dev *dev = video_drvdata(file);
391 struct video_device *vdev = video_devdata(file);
392
393 v4l2_ctrl_log_status(file, fh);
394 if (vdev->vfl_dir == VFL_DIR_RX && vdev->vfl_type == VFL_TYPE_GRABBER)
395 tpg_log_status(&dev->tpg);
396 return 0;
397 }
398
399 static ssize_t vivid_radio_read(struct file *file, char __user *buf,
400 size_t size, loff_t *offset)
401 {
402 struct video_device *vdev = video_devdata(file);
403
404 if (vdev->vfl_dir == VFL_DIR_TX)
405 return -EINVAL;
406 return vivid_radio_rx_read(file, buf, size, offset);
407 }
408
409 static ssize_t vivid_radio_write(struct file *file, const char __user *buf,
410 size_t size, loff_t *offset)
411 {
412 struct video_device *vdev = video_devdata(file);
413
414 if (vdev->vfl_dir == VFL_DIR_RX)
415 return -EINVAL;
416 return vivid_radio_tx_write(file, buf, size, offset);
417 }
418
419 static __poll_t vivid_radio_poll(struct file *file, struct poll_table_struct *wait)
420 {
421 struct video_device *vdev = video_devdata(file);
422
423 if (vdev->vfl_dir == VFL_DIR_RX)
424 return vivid_radio_rx_poll(file, wait);
425 return vivid_radio_tx_poll(file, wait);
426 }
427
428 static bool vivid_is_in_use(struct video_device *vdev)
429 {
430 unsigned long flags;
431 bool res;
432
433 spin_lock_irqsave(&vdev->fh_lock, flags);
434 res = !list_empty(&vdev->fh_list);
435 spin_unlock_irqrestore(&vdev->fh_lock, flags);
436 return res;
437 }
438
439 static bool vivid_is_last_user(struct vivid_dev *dev)
440 {
441 unsigned uses = vivid_is_in_use(&dev->vid_cap_dev) +
442 vivid_is_in_use(&dev->vid_out_dev) +
443 vivid_is_in_use(&dev->vbi_cap_dev) +
444 vivid_is_in_use(&dev->vbi_out_dev) +
445 vivid_is_in_use(&dev->sdr_cap_dev) +
446 vivid_is_in_use(&dev->radio_rx_dev) +
447 vivid_is_in_use(&dev->radio_tx_dev);
448
449 return uses == 1;
450 }
451
452 static int vivid_fop_release(struct file *file)
453 {
454 struct vivid_dev *dev = video_drvdata(file);
455 struct video_device *vdev = video_devdata(file);
456
457 mutex_lock(&dev->mutex);
458 if (!no_error_inj && v4l2_fh_is_singular_file(file) &&
459 !video_is_registered(vdev) && vivid_is_last_user(dev)) {
460 /*
461 * I am the last user of this driver, and a disconnect
462 * was forced (since this video_device is unregistered),
463 * so re-register all video_device's again.
464 */
465 v4l2_info(&dev->v4l2_dev, "reconnect\n");
466 set_bit(V4L2_FL_REGISTERED, &dev->vid_cap_dev.flags);
467 set_bit(V4L2_FL_REGISTERED, &dev->vid_out_dev.flags);
468 set_bit(V4L2_FL_REGISTERED, &dev->vbi_cap_dev.flags);
469 set_bit(V4L2_FL_REGISTERED, &dev->vbi_out_dev.flags);
470 set_bit(V4L2_FL_REGISTERED, &dev->sdr_cap_dev.flags);
471 set_bit(V4L2_FL_REGISTERED, &dev->radio_rx_dev.flags);
472 set_bit(V4L2_FL_REGISTERED, &dev->radio_tx_dev.flags);
473 }
474 mutex_unlock(&dev->mutex);
475 if (file->private_data == dev->overlay_cap_owner)
476 dev->overlay_cap_owner = NULL;
477 if (file->private_data == dev->radio_rx_rds_owner) {
478 dev->radio_rx_rds_last_block = 0;
479 dev->radio_rx_rds_owner = NULL;
480 }
481 if (file->private_data == dev->radio_tx_rds_owner) {
482 dev->radio_tx_rds_last_block = 0;
483 dev->radio_tx_rds_owner = NULL;
484 }
485 if (vdev->queue)
486 return vb2_fop_release(file);
487 return v4l2_fh_release(file);
488 }
489
490 static const struct v4l2_file_operations vivid_fops = {
491 .owner = THIS_MODULE,
492 .open = v4l2_fh_open,
493 .release = vivid_fop_release,
494 .read = vb2_fop_read,
495 .write = vb2_fop_write,
496 .poll = vb2_fop_poll,
497 .unlocked_ioctl = video_ioctl2,
498 .mmap = vb2_fop_mmap,
499 };
500
501 static const struct v4l2_file_operations vivid_radio_fops = {
502 .owner = THIS_MODULE,
503 .open = v4l2_fh_open,
504 .release = vivid_fop_release,
505 .read = vivid_radio_read,
506 .write = vivid_radio_write,
507 .poll = vivid_radio_poll,
508 .unlocked_ioctl = video_ioctl2,
509 };
510
511 static const struct v4l2_ioctl_ops vivid_ioctl_ops = {
512 .vidioc_querycap = vidioc_querycap,
513
514 .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid,
515 .vidioc_g_fmt_vid_cap = vidioc_g_fmt_vid_cap,
516 .vidioc_try_fmt_vid_cap = vidioc_try_fmt_vid_cap,
517 .vidioc_s_fmt_vid_cap = vidioc_s_fmt_vid_cap,
518 .vidioc_enum_fmt_vid_cap_mplane = vidioc_enum_fmt_vid_mplane,
519 .vidioc_g_fmt_vid_cap_mplane = vidioc_g_fmt_vid_cap_mplane,
520 .vidioc_try_fmt_vid_cap_mplane = vidioc_try_fmt_vid_cap_mplane,
521 .vidioc_s_fmt_vid_cap_mplane = vidioc_s_fmt_vid_cap_mplane,
522
523 .vidioc_enum_fmt_vid_out = vidioc_enum_fmt_vid,
524 .vidioc_g_fmt_vid_out = vidioc_g_fmt_vid_out,
525 .vidioc_try_fmt_vid_out = vidioc_try_fmt_vid_out,
526 .vidioc_s_fmt_vid_out = vidioc_s_fmt_vid_out,
527 .vidioc_enum_fmt_vid_out_mplane = vidioc_enum_fmt_vid_mplane,
528 .vidioc_g_fmt_vid_out_mplane = vidioc_g_fmt_vid_out_mplane,
529 .vidioc_try_fmt_vid_out_mplane = vidioc_try_fmt_vid_out_mplane,
530 .vidioc_s_fmt_vid_out_mplane = vidioc_s_fmt_vid_out_mplane,
531
532 .vidioc_g_selection = vidioc_g_selection,
533 .vidioc_s_selection = vidioc_s_selection,
534 .vidioc_cropcap = vidioc_cropcap,
535
536 .vidioc_g_fmt_vbi_cap = vidioc_g_fmt_vbi_cap,
537 .vidioc_try_fmt_vbi_cap = vidioc_g_fmt_vbi_cap,
538 .vidioc_s_fmt_vbi_cap = vidioc_s_fmt_vbi_cap,
539
540 .vidioc_g_fmt_sliced_vbi_cap = vidioc_g_fmt_sliced_vbi_cap,
541 .vidioc_try_fmt_sliced_vbi_cap = vidioc_try_fmt_sliced_vbi_cap,
542 .vidioc_s_fmt_sliced_vbi_cap = vidioc_s_fmt_sliced_vbi_cap,
543 .vidioc_g_sliced_vbi_cap = vidioc_g_sliced_vbi_cap,
544
545 .vidioc_g_fmt_vbi_out = vidioc_g_fmt_vbi_out,
546 .vidioc_try_fmt_vbi_out = vidioc_g_fmt_vbi_out,
547 .vidioc_s_fmt_vbi_out = vidioc_s_fmt_vbi_out,
548
549 .vidioc_g_fmt_sliced_vbi_out = vidioc_g_fmt_sliced_vbi_out,
550 .vidioc_try_fmt_sliced_vbi_out = vidioc_try_fmt_sliced_vbi_out,
551 .vidioc_s_fmt_sliced_vbi_out = vidioc_s_fmt_sliced_vbi_out,
552
553 .vidioc_enum_fmt_sdr_cap = vidioc_enum_fmt_sdr_cap,
554 .vidioc_g_fmt_sdr_cap = vidioc_g_fmt_sdr_cap,
555 .vidioc_try_fmt_sdr_cap = vidioc_try_fmt_sdr_cap,
556 .vidioc_s_fmt_sdr_cap = vidioc_s_fmt_sdr_cap,
557
558 .vidioc_overlay = vidioc_overlay,
559 .vidioc_enum_framesizes = vidioc_enum_framesizes,
560 .vidioc_enum_frameintervals = vidioc_enum_frameintervals,
561 .vidioc_g_parm = vidioc_g_parm,
562 .vidioc_s_parm = vidioc_s_parm,
563
564 .vidioc_enum_fmt_vid_overlay = vidioc_enum_fmt_vid_overlay,
565 .vidioc_g_fmt_vid_overlay = vidioc_g_fmt_vid_overlay,
566 .vidioc_try_fmt_vid_overlay = vidioc_try_fmt_vid_overlay,
567 .vidioc_s_fmt_vid_overlay = vidioc_s_fmt_vid_overlay,
568 .vidioc_g_fmt_vid_out_overlay = vidioc_g_fmt_vid_out_overlay,
569 .vidioc_try_fmt_vid_out_overlay = vidioc_try_fmt_vid_out_overlay,
570 .vidioc_s_fmt_vid_out_overlay = vidioc_s_fmt_vid_out_overlay,
571 .vidioc_g_fbuf = vidioc_g_fbuf,
572 .vidioc_s_fbuf = vidioc_s_fbuf,
573
574 .vidioc_reqbufs = vb2_ioctl_reqbufs,
575 .vidioc_create_bufs = vb2_ioctl_create_bufs,
576 .vidioc_prepare_buf = vb2_ioctl_prepare_buf,
577 .vidioc_querybuf = vb2_ioctl_querybuf,
578 .vidioc_qbuf = vb2_ioctl_qbuf,
579 .vidioc_dqbuf = vb2_ioctl_dqbuf,
580 .vidioc_expbuf = vb2_ioctl_expbuf,
581 .vidioc_streamon = vb2_ioctl_streamon,
582 .vidioc_streamoff = vb2_ioctl_streamoff,
583
584 .vidioc_enum_input = vidioc_enum_input,
585 .vidioc_g_input = vidioc_g_input,
586 .vidioc_s_input = vidioc_s_input,
587 .vidioc_s_audio = vidioc_s_audio,
588 .vidioc_g_audio = vidioc_g_audio,
589 .vidioc_enumaudio = vidioc_enumaudio,
590 .vidioc_s_frequency = vidioc_s_frequency,
591 .vidioc_g_frequency = vidioc_g_frequency,
592 .vidioc_s_tuner = vidioc_s_tuner,
593 .vidioc_g_tuner = vidioc_g_tuner,
594 .vidioc_s_modulator = vidioc_s_modulator,
595 .vidioc_g_modulator = vidioc_g_modulator,
596 .vidioc_s_hw_freq_seek = vidioc_s_hw_freq_seek,
597 .vidioc_enum_freq_bands = vidioc_enum_freq_bands,
598
599 .vidioc_enum_output = vidioc_enum_output,
600 .vidioc_g_output = vidioc_g_output,
601 .vidioc_s_output = vidioc_s_output,
602 .vidioc_s_audout = vidioc_s_audout,
603 .vidioc_g_audout = vidioc_g_audout,
604 .vidioc_enumaudout = vidioc_enumaudout,
605
606 .vidioc_querystd = vidioc_querystd,
607 .vidioc_g_std = vidioc_g_std,
608 .vidioc_s_std = vidioc_s_std,
609 .vidioc_s_dv_timings = vidioc_s_dv_timings,
610 .vidioc_g_dv_timings = vidioc_g_dv_timings,
611 .vidioc_query_dv_timings = vidioc_query_dv_timings,
612 .vidioc_enum_dv_timings = vidioc_enum_dv_timings,
613 .vidioc_dv_timings_cap = vidioc_dv_timings_cap,
614 .vidioc_g_edid = vidioc_g_edid,
615 .vidioc_s_edid = vidioc_s_edid,
616
617 .vidioc_log_status = vidioc_log_status,
618 .vidioc_subscribe_event = vidioc_subscribe_event,
619 .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
620 };
621
622 /* -----------------------------------------------------------------
623 Initialization and module stuff
624 ------------------------------------------------------------------*/
625
626 static void vivid_dev_release(struct v4l2_device *v4l2_dev)
627 {
628 struct vivid_dev *dev = container_of(v4l2_dev, struct vivid_dev, v4l2_dev);
629
630 vivid_free_controls(dev);
631 v4l2_device_unregister(&dev->v4l2_dev);
632 vfree(dev->scaled_line);
633 vfree(dev->blended_line);
634 vfree(dev->edid);
635 vfree(dev->bitmap_cap);
636 vfree(dev->bitmap_out);
637 tpg_free(&dev->tpg);
638 kfree(dev->query_dv_timings_qmenu);
639 kfree(dev);
640 }
641
642 static int vivid_create_instance(struct platform_device *pdev, int inst)
643 {
644 static const struct v4l2_dv_timings def_dv_timings =
645 V4L2_DV_BT_CEA_1280X720P60;
646 static const struct vb2_mem_ops * const vivid_mem_ops[2] = {
647 &vb2_vmalloc_memops,
648 &vb2_dma_contig_memops,
649 };
650 unsigned in_type_counter[4] = { 0, 0, 0, 0 };
651 unsigned out_type_counter[4] = { 0, 0, 0, 0 };
652 int ccs_cap = ccs_cap_mode[inst];
653 int ccs_out = ccs_out_mode[inst];
654 bool has_tuner;
655 bool has_modulator;
656 struct vivid_dev *dev;
657 struct video_device *vfd;
658 struct vb2_queue *q;
659 unsigned node_type = node_types[inst];
660 unsigned int allocator = allocators[inst];
661 v4l2_std_id tvnorms_cap = 0, tvnorms_out = 0;
662 int ret;
663 int i;
664
665 /* allocate main vivid state structure */
666 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
667 if (!dev)
668 return -ENOMEM;
669
670 dev->inst = inst;
671
672 /* register v4l2_device */
673 snprintf(dev->v4l2_dev.name, sizeof(dev->v4l2_dev.name),
674 "%s-%03d", VIVID_MODULE_NAME, inst);
675 ret = v4l2_device_register(&pdev->dev, &dev->v4l2_dev);
676 if (ret) {
677 kfree(dev);
678 return ret;
679 }
680 dev->v4l2_dev.release = vivid_dev_release;
681
682 /* start detecting feature set */
683
684 /* do we use single- or multi-planar? */
685 dev->multiplanar = multiplanar[inst] > 1;
686 v4l2_info(&dev->v4l2_dev, "using %splanar format API\n",
687 dev->multiplanar ? "multi" : "single ");
688
689 /* how many inputs do we have and of what type? */
690 dev->num_inputs = num_inputs[inst];
691 if (dev->num_inputs < 1)
692 dev->num_inputs = 1;
693 if (dev->num_inputs >= MAX_INPUTS)
694 dev->num_inputs = MAX_INPUTS;
695 for (i = 0; i < dev->num_inputs; i++) {
696 dev->input_type[i] = (input_types[inst] >> (i * 2)) & 0x3;
697 dev->input_name_counter[i] = in_type_counter[dev->input_type[i]]++;
698 }
699 dev->has_audio_inputs = in_type_counter[TV] && in_type_counter[SVID];
700 if (in_type_counter[HDMI] == 16) {
701 /* The CEC physical address only allows for max 15 inputs */
702 in_type_counter[HDMI]--;
703 dev->num_inputs--;
704 }
705
706 /* how many outputs do we have and of what type? */
707 dev->num_outputs = num_outputs[inst];
708 if (dev->num_outputs < 1)
709 dev->num_outputs = 1;
710 if (dev->num_outputs >= MAX_OUTPUTS)
711 dev->num_outputs = MAX_OUTPUTS;
712 for (i = 0; i < dev->num_outputs; i++) {
713 dev->output_type[i] = ((output_types[inst] >> i) & 1) ? HDMI : SVID;
714 dev->output_name_counter[i] = out_type_counter[dev->output_type[i]]++;
715 }
716 dev->has_audio_outputs = out_type_counter[SVID];
717 if (out_type_counter[HDMI] == 16) {
718 /*
719 * The CEC physical address only allows for max 15 inputs,
720 * so outputs are also limited to 15 to allow for easy
721 * CEC output to input mapping.
722 */
723 out_type_counter[HDMI]--;
724 dev->num_outputs--;
725 }
726
727 /* do we create a video capture device? */
728 dev->has_vid_cap = node_type & 0x0001;
729
730 /* do we create a vbi capture device? */
731 if (in_type_counter[TV] || in_type_counter[SVID]) {
732 dev->has_raw_vbi_cap = node_type & 0x0004;
733 dev->has_sliced_vbi_cap = node_type & 0x0008;
734 dev->has_vbi_cap = dev->has_raw_vbi_cap | dev->has_sliced_vbi_cap;
735 }
736
737 /* do we create a video output device? */
738 dev->has_vid_out = node_type & 0x0100;
739
740 /* do we create a vbi output device? */
741 if (out_type_counter[SVID]) {
742 dev->has_raw_vbi_out = node_type & 0x0400;
743 dev->has_sliced_vbi_out = node_type & 0x0800;
744 dev->has_vbi_out = dev->has_raw_vbi_out | dev->has_sliced_vbi_out;
745 }
746
747 /* do we create a radio receiver device? */
748 dev->has_radio_rx = node_type & 0x0010;
749
750 /* do we create a radio transmitter device? */
751 dev->has_radio_tx = node_type & 0x1000;
752
753 /* do we create a software defined radio capture device? */
754 dev->has_sdr_cap = node_type & 0x0020;
755
756 /* do we have a tuner? */
757 has_tuner = ((dev->has_vid_cap || dev->has_vbi_cap) && in_type_counter[TV]) ||
758 dev->has_radio_rx || dev->has_sdr_cap;
759
760 /* do we have a modulator? */
761 has_modulator = dev->has_radio_tx;
762
763 if (dev->has_vid_cap)
764 /* do we have a framebuffer for overlay testing? */
765 dev->has_fb = node_type & 0x10000;
766
767 /* can we do crop/compose/scaling while capturing? */
768 if (no_error_inj && ccs_cap == -1)
769 ccs_cap = 7;
770
771 /* if ccs_cap == -1, then the use can select it using controls */
772 if (ccs_cap != -1) {
773 dev->has_crop_cap = ccs_cap & 1;
774 dev->has_compose_cap = ccs_cap & 2;
775 dev->has_scaler_cap = ccs_cap & 4;
776 v4l2_info(&dev->v4l2_dev, "Capture Crop: %c Compose: %c Scaler: %c\n",
777 dev->has_crop_cap ? 'Y' : 'N',
778 dev->has_compose_cap ? 'Y' : 'N',
779 dev->has_scaler_cap ? 'Y' : 'N');
780 }
781
782 /* can we do crop/compose/scaling with video output? */
783 if (no_error_inj && ccs_out == -1)
784 ccs_out = 7;
785
786 /* if ccs_out == -1, then the use can select it using controls */
787 if (ccs_out != -1) {
788 dev->has_crop_out = ccs_out & 1;
789 dev->has_compose_out = ccs_out & 2;
790 dev->has_scaler_out = ccs_out & 4;
791 v4l2_info(&dev->v4l2_dev, "Output Crop: %c Compose: %c Scaler: %c\n",
792 dev->has_crop_out ? 'Y' : 'N',
793 dev->has_compose_out ? 'Y' : 'N',
794 dev->has_scaler_out ? 'Y' : 'N');
795 }
796
797 /* end detecting feature set */
798
799 if (dev->has_vid_cap) {
800 /* set up the capabilities of the video capture device */
801 dev->vid_cap_caps = dev->multiplanar ?
802 V4L2_CAP_VIDEO_CAPTURE_MPLANE :
803 V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_VIDEO_OVERLAY;
804 dev->vid_cap_caps |= V4L2_CAP_STREAMING | V4L2_CAP_READWRITE;
805 if (dev->has_audio_inputs)
806 dev->vid_cap_caps |= V4L2_CAP_AUDIO;
807 if (in_type_counter[TV])
808 dev->vid_cap_caps |= V4L2_CAP_TUNER;
809 }
810 if (dev->has_vid_out) {
811 /* set up the capabilities of the video output device */
812 dev->vid_out_caps = dev->multiplanar ?
813 V4L2_CAP_VIDEO_OUTPUT_MPLANE :
814 V4L2_CAP_VIDEO_OUTPUT;
815 if (dev->has_fb)
816 dev->vid_out_caps |= V4L2_CAP_VIDEO_OUTPUT_OVERLAY;
817 dev->vid_out_caps |= V4L2_CAP_STREAMING | V4L2_CAP_READWRITE;
818 if (dev->has_audio_outputs)
819 dev->vid_out_caps |= V4L2_CAP_AUDIO;
820 }
821 if (dev->has_vbi_cap) {
822 /* set up the capabilities of the vbi capture device */
823 dev->vbi_cap_caps = (dev->has_raw_vbi_cap ? V4L2_CAP_VBI_CAPTURE : 0) |
824 (dev->has_sliced_vbi_cap ? V4L2_CAP_SLICED_VBI_CAPTURE : 0);
825 dev->vbi_cap_caps |= V4L2_CAP_STREAMING | V4L2_CAP_READWRITE;
826 if (dev->has_audio_inputs)
827 dev->vbi_cap_caps |= V4L2_CAP_AUDIO;
828 if (in_type_counter[TV])
829 dev->vbi_cap_caps |= V4L2_CAP_TUNER;
830 }
831 if (dev->has_vbi_out) {
832 /* set up the capabilities of the vbi output device */
833 dev->vbi_out_caps = (dev->has_raw_vbi_out ? V4L2_CAP_VBI_OUTPUT : 0) |
834 (dev->has_sliced_vbi_out ? V4L2_CAP_SLICED_VBI_OUTPUT : 0);
835 dev->vbi_out_caps |= V4L2_CAP_STREAMING | V4L2_CAP_READWRITE;
836 if (dev->has_audio_outputs)
837 dev->vbi_out_caps |= V4L2_CAP_AUDIO;
838 }
839 if (dev->has_sdr_cap) {
840 /* set up the capabilities of the sdr capture device */
841 dev->sdr_cap_caps = V4L2_CAP_SDR_CAPTURE | V4L2_CAP_TUNER;
842 dev->sdr_cap_caps |= V4L2_CAP_STREAMING | V4L2_CAP_READWRITE;
843 }
844 /* set up the capabilities of the radio receiver device */
845 if (dev->has_radio_rx)
846 dev->radio_rx_caps = V4L2_CAP_RADIO | V4L2_CAP_RDS_CAPTURE |
847 V4L2_CAP_HW_FREQ_SEEK | V4L2_CAP_TUNER |
848 V4L2_CAP_READWRITE;
849 /* set up the capabilities of the radio transmitter device */
850 if (dev->has_radio_tx)
851 dev->radio_tx_caps = V4L2_CAP_RDS_OUTPUT | V4L2_CAP_MODULATOR |
852 V4L2_CAP_READWRITE;
853
854 ret = -ENOMEM;
855 /* initialize the test pattern generator */
856 tpg_init(&dev->tpg, 640, 360);
857 if (tpg_alloc(&dev->tpg, MAX_ZOOM * MAX_WIDTH))
858 goto free_dev;
859 dev->scaled_line = vzalloc(MAX_ZOOM * MAX_WIDTH);
860 if (!dev->scaled_line)
861 goto free_dev;
862 dev->blended_line = vzalloc(MAX_ZOOM * MAX_WIDTH);
863 if (!dev->blended_line)
864 goto free_dev;
865
866 /* load the edid */
867 dev->edid = vmalloc(256 * 128);
868 if (!dev->edid)
869 goto free_dev;
870
871 /* create a string array containing the names of all the preset timings */
872 while (v4l2_dv_timings_presets[dev->query_dv_timings_size].bt.width)
873 dev->query_dv_timings_size++;
874 dev->query_dv_timings_qmenu = kmalloc(dev->query_dv_timings_size *
875 (sizeof(void *) + 32), GFP_KERNEL);
876 if (dev->query_dv_timings_qmenu == NULL)
877 goto free_dev;
878 for (i = 0; i < dev->query_dv_timings_size; i++) {
879 const struct v4l2_bt_timings *bt = &v4l2_dv_timings_presets[i].bt;
880 char *p = (char *)&dev->query_dv_timings_qmenu[dev->query_dv_timings_size];
881 u32 htot, vtot;
882
883 p += i * 32;
884 dev->query_dv_timings_qmenu[i] = p;
885
886 htot = V4L2_DV_BT_FRAME_WIDTH(bt);
887 vtot = V4L2_DV_BT_FRAME_HEIGHT(bt);
888 snprintf(p, 32, "%ux%u%s%u",
889 bt->width, bt->height, bt->interlaced ? "i" : "p",
890 (u32)bt->pixelclock / (htot * vtot));
891 }
892
893 /* disable invalid ioctls based on the feature set */
894 if (!dev->has_audio_inputs) {
895 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_S_AUDIO);
896 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_G_AUDIO);
897 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_ENUMAUDIO);
898 v4l2_disable_ioctl(&dev->vbi_cap_dev, VIDIOC_S_AUDIO);
899 v4l2_disable_ioctl(&dev->vbi_cap_dev, VIDIOC_G_AUDIO);
900 v4l2_disable_ioctl(&dev->vbi_cap_dev, VIDIOC_ENUMAUDIO);
901 }
902 if (!dev->has_audio_outputs) {
903 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_S_AUDOUT);
904 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_G_AUDOUT);
905 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_ENUMAUDOUT);
906 v4l2_disable_ioctl(&dev->vbi_out_dev, VIDIOC_S_AUDOUT);
907 v4l2_disable_ioctl(&dev->vbi_out_dev, VIDIOC_G_AUDOUT);
908 v4l2_disable_ioctl(&dev->vbi_out_dev, VIDIOC_ENUMAUDOUT);
909 }
910 if (!in_type_counter[TV] && !in_type_counter[SVID]) {
911 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_S_STD);
912 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_G_STD);
913 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_ENUMSTD);
914 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_QUERYSTD);
915 }
916 if (!out_type_counter[SVID]) {
917 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_S_STD);
918 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_G_STD);
919 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_ENUMSTD);
920 }
921 if (!has_tuner && !has_modulator) {
922 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_S_FREQUENCY);
923 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_G_FREQUENCY);
924 v4l2_disable_ioctl(&dev->vbi_cap_dev, VIDIOC_S_FREQUENCY);
925 v4l2_disable_ioctl(&dev->vbi_cap_dev, VIDIOC_G_FREQUENCY);
926 }
927 if (!has_tuner) {
928 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_S_TUNER);
929 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_G_TUNER);
930 v4l2_disable_ioctl(&dev->vbi_cap_dev, VIDIOC_S_TUNER);
931 v4l2_disable_ioctl(&dev->vbi_cap_dev, VIDIOC_G_TUNER);
932 }
933 if (in_type_counter[HDMI] == 0) {
934 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_S_EDID);
935 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_G_EDID);
936 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_DV_TIMINGS_CAP);
937 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_G_DV_TIMINGS);
938 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_S_DV_TIMINGS);
939 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_ENUM_DV_TIMINGS);
940 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_QUERY_DV_TIMINGS);
941 }
942 if (out_type_counter[HDMI] == 0) {
943 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_G_EDID);
944 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_DV_TIMINGS_CAP);
945 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_G_DV_TIMINGS);
946 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_S_DV_TIMINGS);
947 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_ENUM_DV_TIMINGS);
948 }
949 if (!dev->has_fb) {
950 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_G_FBUF);
951 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_S_FBUF);
952 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_OVERLAY);
953 }
954 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_S_HW_FREQ_SEEK);
955 v4l2_disable_ioctl(&dev->vbi_cap_dev, VIDIOC_S_HW_FREQ_SEEK);
956 v4l2_disable_ioctl(&dev->sdr_cap_dev, VIDIOC_S_HW_FREQ_SEEK);
957 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_S_FREQUENCY);
958 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_G_FREQUENCY);
959 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_ENUM_FRAMESIZES);
960 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_ENUM_FRAMEINTERVALS);
961 v4l2_disable_ioctl(&dev->vbi_out_dev, VIDIOC_S_FREQUENCY);
962 v4l2_disable_ioctl(&dev->vbi_out_dev, VIDIOC_G_FREQUENCY);
963
964 /* configure internal data */
965 dev->fmt_cap = &vivid_formats[0];
966 dev->fmt_out = &vivid_formats[0];
967 if (!dev->multiplanar)
968 vivid_formats[0].data_offset[0] = 0;
969 dev->webcam_size_idx = 1;
970 dev->webcam_ival_idx = 3;
971 tpg_s_fourcc(&dev->tpg, dev->fmt_cap->fourcc);
972 dev->std_cap = V4L2_STD_PAL;
973 dev->std_out = V4L2_STD_PAL;
974 if (dev->input_type[0] == TV || dev->input_type[0] == SVID)
975 tvnorms_cap = V4L2_STD_ALL;
976 if (dev->output_type[0] == SVID)
977 tvnorms_out = V4L2_STD_ALL;
978 dev->dv_timings_cap = def_dv_timings;
979 dev->dv_timings_out = def_dv_timings;
980 dev->tv_freq = 2804 /* 175.25 * 16 */;
981 dev->tv_audmode = V4L2_TUNER_MODE_STEREO;
982 dev->tv_field_cap = V4L2_FIELD_INTERLACED;
983 dev->tv_field_out = V4L2_FIELD_INTERLACED;
984 dev->radio_rx_freq = 95000 * 16;
985 dev->radio_rx_audmode = V4L2_TUNER_MODE_STEREO;
986 if (dev->has_radio_tx) {
987 dev->radio_tx_freq = 95500 * 16;
988 dev->radio_rds_loop = false;
989 }
990 dev->radio_tx_subchans = V4L2_TUNER_SUB_STEREO | V4L2_TUNER_SUB_RDS;
991 dev->sdr_adc_freq = 300000;
992 dev->sdr_fm_freq = 50000000;
993 dev->sdr_pixelformat = V4L2_SDR_FMT_CU8;
994 dev->sdr_buffersize = SDR_CAP_SAMPLES_PER_BUF * 2;
995
996 dev->edid_max_blocks = dev->edid_blocks = 2;
997 memcpy(dev->edid, vivid_hdmi_edid, sizeof(vivid_hdmi_edid));
998 dev->radio_rds_init_time = ktime_get();
999
1000 /* create all controls */
1001 ret = vivid_create_controls(dev, ccs_cap == -1, ccs_out == -1, no_error_inj,
1002 in_type_counter[TV] || in_type_counter[SVID] ||
1003 out_type_counter[SVID],
1004 in_type_counter[HDMI] || out_type_counter[HDMI]);
1005 if (ret)
1006 goto unreg_dev;
1007
1008 /*
1009 * update the capture and output formats to do a proper initial
1010 * configuration.
1011 */
1012 vivid_update_format_cap(dev, false);
1013 vivid_update_format_out(dev);
1014
1015 v4l2_ctrl_handler_setup(&dev->ctrl_hdl_vid_cap);
1016 v4l2_ctrl_handler_setup(&dev->ctrl_hdl_vid_out);
1017 v4l2_ctrl_handler_setup(&dev->ctrl_hdl_vbi_cap);
1018 v4l2_ctrl_handler_setup(&dev->ctrl_hdl_vbi_out);
1019 v4l2_ctrl_handler_setup(&dev->ctrl_hdl_radio_rx);
1020 v4l2_ctrl_handler_setup(&dev->ctrl_hdl_radio_tx);
1021 v4l2_ctrl_handler_setup(&dev->ctrl_hdl_sdr_cap);
1022
1023 /* initialize overlay */
1024 dev->fb_cap.fmt.width = dev->src_rect.width;
1025 dev->fb_cap.fmt.height = dev->src_rect.height;
1026 dev->fb_cap.fmt.pixelformat = dev->fmt_cap->fourcc;
1027 dev->fb_cap.fmt.bytesperline = dev->src_rect.width * tpg_g_twopixelsize(&dev->tpg, 0) / 2;
1028 dev->fb_cap.fmt.sizeimage = dev->src_rect.height * dev->fb_cap.fmt.bytesperline;
1029
1030 /* initialize locks */
1031 spin_lock_init(&dev->slock);
1032 mutex_init(&dev->mutex);
1033
1034 /* init dma queues */
1035 INIT_LIST_HEAD(&dev->vid_cap_active);
1036 INIT_LIST_HEAD(&dev->vid_out_active);
1037 INIT_LIST_HEAD(&dev->vbi_cap_active);
1038 INIT_LIST_HEAD(&dev->vbi_out_active);
1039 INIT_LIST_HEAD(&dev->sdr_cap_active);
1040
1041 INIT_LIST_HEAD(&dev->cec_work_list);
1042 spin_lock_init(&dev->cec_slock);
1043 /*
1044 * Same as create_singlethread_workqueue, but now I can use the
1045 * string formatting of alloc_ordered_workqueue.
1046 */
1047 dev->cec_workqueue =
1048 alloc_ordered_workqueue("vivid-%03d-cec", WQ_MEM_RECLAIM, inst);
1049 if (!dev->cec_workqueue) {
1050 ret = -ENOMEM;
1051 goto unreg_dev;
1052 }
1053
1054 if (allocator == 1)
1055 dma_coerce_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32));
1056 else if (allocator >= ARRAY_SIZE(vivid_mem_ops))
1057 allocator = 0;
1058
1059 /* start creating the vb2 queues */
1060 if (dev->has_vid_cap) {
1061 /* initialize vid_cap queue */
1062 q = &dev->vb_vid_cap_q;
1063 q->type = dev->multiplanar ? V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE :
1064 V4L2_BUF_TYPE_VIDEO_CAPTURE;
1065 q->io_modes = VB2_MMAP | VB2_USERPTR | VB2_DMABUF | VB2_READ;
1066 q->drv_priv = dev;
1067 q->buf_struct_size = sizeof(struct vivid_buffer);
1068 q->ops = &vivid_vid_cap_qops;
1069 q->mem_ops = vivid_mem_ops[allocator];
1070 q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1071 q->min_buffers_needed = 2;
1072 q->lock = &dev->mutex;
1073 q->dev = dev->v4l2_dev.dev;
1074
1075 ret = vb2_queue_init(q);
1076 if (ret)
1077 goto unreg_dev;
1078 }
1079
1080 if (dev->has_vid_out) {
1081 /* initialize vid_out queue */
1082 q = &dev->vb_vid_out_q;
1083 q->type = dev->multiplanar ? V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE :
1084 V4L2_BUF_TYPE_VIDEO_OUTPUT;
1085 q->io_modes = VB2_MMAP | VB2_USERPTR | VB2_DMABUF | VB2_WRITE;
1086 q->drv_priv = dev;
1087 q->buf_struct_size = sizeof(struct vivid_buffer);
1088 q->ops = &vivid_vid_out_qops;
1089 q->mem_ops = vivid_mem_ops[allocator];
1090 q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1091 q->min_buffers_needed = 2;
1092 q->lock = &dev->mutex;
1093 q->dev = dev->v4l2_dev.dev;
1094
1095 ret = vb2_queue_init(q);
1096 if (ret)
1097 goto unreg_dev;
1098 }
1099
1100 if (dev->has_vbi_cap) {
1101 /* initialize vbi_cap queue */
1102 q = &dev->vb_vbi_cap_q;
1103 q->type = dev->has_raw_vbi_cap ? V4L2_BUF_TYPE_VBI_CAPTURE :
1104 V4L2_BUF_TYPE_SLICED_VBI_CAPTURE;
1105 q->io_modes = VB2_MMAP | VB2_USERPTR | VB2_DMABUF | VB2_READ;
1106 q->drv_priv = dev;
1107 q->buf_struct_size = sizeof(struct vivid_buffer);
1108 q->ops = &vivid_vbi_cap_qops;
1109 q->mem_ops = vivid_mem_ops[allocator];
1110 q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1111 q->min_buffers_needed = 2;
1112 q->lock = &dev->mutex;
1113 q->dev = dev->v4l2_dev.dev;
1114
1115 ret = vb2_queue_init(q);
1116 if (ret)
1117 goto unreg_dev;
1118 }
1119
1120 if (dev->has_vbi_out) {
1121 /* initialize vbi_out queue */
1122 q = &dev->vb_vbi_out_q;
1123 q->type = dev->has_raw_vbi_out ? V4L2_BUF_TYPE_VBI_OUTPUT :
1124 V4L2_BUF_TYPE_SLICED_VBI_OUTPUT;
1125 q->io_modes = VB2_MMAP | VB2_USERPTR | VB2_DMABUF | VB2_WRITE;
1126 q->drv_priv = dev;
1127 q->buf_struct_size = sizeof(struct vivid_buffer);
1128 q->ops = &vivid_vbi_out_qops;
1129 q->mem_ops = vivid_mem_ops[allocator];
1130 q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1131 q->min_buffers_needed = 2;
1132 q->lock = &dev->mutex;
1133 q->dev = dev->v4l2_dev.dev;
1134
1135 ret = vb2_queue_init(q);
1136 if (ret)
1137 goto unreg_dev;
1138 }
1139
1140 if (dev->has_sdr_cap) {
1141 /* initialize sdr_cap queue */
1142 q = &dev->vb_sdr_cap_q;
1143 q->type = V4L2_BUF_TYPE_SDR_CAPTURE;
1144 q->io_modes = VB2_MMAP | VB2_USERPTR | VB2_DMABUF | VB2_READ;
1145 q->drv_priv = dev;
1146 q->buf_struct_size = sizeof(struct vivid_buffer);
1147 q->ops = &vivid_sdr_cap_qops;
1148 q->mem_ops = vivid_mem_ops[allocator];
1149 q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1150 q->min_buffers_needed = 8;
1151 q->lock = &dev->mutex;
1152 q->dev = dev->v4l2_dev.dev;
1153
1154 ret = vb2_queue_init(q);
1155 if (ret)
1156 goto unreg_dev;
1157 }
1158
1159 if (dev->has_fb) {
1160 /* Create framebuffer for testing capture/output overlay */
1161 ret = vivid_fb_init(dev);
1162 if (ret)
1163 goto unreg_dev;
1164 v4l2_info(&dev->v4l2_dev, "Framebuffer device registered as fb%d\n",
1165 dev->fb_info.node);
1166 }
1167
1168 /* finally start creating the device nodes */
1169 if (dev->has_vid_cap) {
1170 vfd = &dev->vid_cap_dev;
1171 snprintf(vfd->name, sizeof(vfd->name),
1172 "vivid-%03d-vid-cap", inst);
1173 vfd->fops = &vivid_fops;
1174 vfd->ioctl_ops = &vivid_ioctl_ops;
1175 vfd->device_caps = dev->vid_cap_caps;
1176 vfd->release = video_device_release_empty;
1177 vfd->v4l2_dev = &dev->v4l2_dev;
1178 vfd->queue = &dev->vb_vid_cap_q;
1179 vfd->tvnorms = tvnorms_cap;
1180
1181 /*
1182 * Provide a mutex to v4l2 core. It will be used to protect
1183 * all fops and v4l2 ioctls.
1184 */
1185 vfd->lock = &dev->mutex;
1186 video_set_drvdata(vfd, dev);
1187
1188 #ifdef CONFIG_VIDEO_VIVID_CEC
1189 if (in_type_counter[HDMI]) {
1190 struct cec_adapter *adap;
1191
1192 adap = vivid_cec_alloc_adap(dev, 0, false);
1193 ret = PTR_ERR_OR_ZERO(adap);
1194 if (ret < 0)
1195 goto unreg_dev;
1196 dev->cec_rx_adap = adap;
1197 ret = cec_register_adapter(adap, &pdev->dev);
1198 if (ret < 0) {
1199 cec_delete_adapter(adap);
1200 dev->cec_rx_adap = NULL;
1201 goto unreg_dev;
1202 }
1203 cec_s_phys_addr(adap, 0, false);
1204 v4l2_info(&dev->v4l2_dev, "CEC adapter %s registered for HDMI input 0\n",
1205 dev_name(&adap->devnode.dev));
1206 }
1207 #endif
1208
1209 ret = video_register_device(vfd, VFL_TYPE_GRABBER, vid_cap_nr[inst]);
1210 if (ret < 0)
1211 goto unreg_dev;
1212 v4l2_info(&dev->v4l2_dev, "V4L2 capture device registered as %s\n",
1213 video_device_node_name(vfd));
1214 }
1215
1216 if (dev->has_vid_out) {
1217 #ifdef CONFIG_VIDEO_VIVID_CEC
1218 unsigned int bus_cnt = 0;
1219 #endif
1220
1221 vfd = &dev->vid_out_dev;
1222 snprintf(vfd->name, sizeof(vfd->name),
1223 "vivid-%03d-vid-out", inst);
1224 vfd->vfl_dir = VFL_DIR_TX;
1225 vfd->fops = &vivid_fops;
1226 vfd->ioctl_ops = &vivid_ioctl_ops;
1227 vfd->device_caps = dev->vid_out_caps;
1228 vfd->release = video_device_release_empty;
1229 vfd->v4l2_dev = &dev->v4l2_dev;
1230 vfd->queue = &dev->vb_vid_out_q;
1231 vfd->tvnorms = tvnorms_out;
1232
1233 /*
1234 * Provide a mutex to v4l2 core. It will be used to protect
1235 * all fops and v4l2 ioctls.
1236 */
1237 vfd->lock = &dev->mutex;
1238 video_set_drvdata(vfd, dev);
1239
1240 #ifdef CONFIG_VIDEO_VIVID_CEC
1241 for (i = 0; i < dev->num_outputs; i++) {
1242 struct cec_adapter *adap;
1243
1244 if (dev->output_type[i] != HDMI)
1245 continue;
1246 dev->cec_output2bus_map[i] = bus_cnt;
1247 adap = vivid_cec_alloc_adap(dev, bus_cnt, true);
1248 ret = PTR_ERR_OR_ZERO(adap);
1249 if (ret < 0)
1250 goto unreg_dev;
1251 dev->cec_tx_adap[bus_cnt] = adap;
1252 ret = cec_register_adapter(adap, &pdev->dev);
1253 if (ret < 0) {
1254 cec_delete_adapter(adap);
1255 dev->cec_tx_adap[bus_cnt] = NULL;
1256 goto unreg_dev;
1257 }
1258 v4l2_info(&dev->v4l2_dev, "CEC adapter %s registered for HDMI output %d\n",
1259 dev_name(&adap->devnode.dev), bus_cnt);
1260 bus_cnt++;
1261 if (bus_cnt <= out_type_counter[HDMI])
1262 cec_s_phys_addr(adap, bus_cnt << 12, false);
1263 else
1264 cec_s_phys_addr(adap, 0x1000, false);
1265 }
1266 #endif
1267
1268 ret = video_register_device(vfd, VFL_TYPE_GRABBER, vid_out_nr[inst]);
1269 if (ret < 0)
1270 goto unreg_dev;
1271 v4l2_info(&dev->v4l2_dev, "V4L2 output device registered as %s\n",
1272 video_device_node_name(vfd));
1273 }
1274
1275 if (dev->has_vbi_cap) {
1276 vfd = &dev->vbi_cap_dev;
1277 snprintf(vfd->name, sizeof(vfd->name),
1278 "vivid-%03d-vbi-cap", inst);
1279 vfd->fops = &vivid_fops;
1280 vfd->ioctl_ops = &vivid_ioctl_ops;
1281 vfd->device_caps = dev->vbi_cap_caps;
1282 vfd->release = video_device_release_empty;
1283 vfd->v4l2_dev = &dev->v4l2_dev;
1284 vfd->queue = &dev->vb_vbi_cap_q;
1285 vfd->lock = &dev->mutex;
1286 vfd->tvnorms = tvnorms_cap;
1287 video_set_drvdata(vfd, dev);
1288
1289 ret = video_register_device(vfd, VFL_TYPE_VBI, vbi_cap_nr[inst]);
1290 if (ret < 0)
1291 goto unreg_dev;
1292 v4l2_info(&dev->v4l2_dev, "V4L2 capture device registered as %s, supports %s VBI\n",
1293 video_device_node_name(vfd),
1294 (dev->has_raw_vbi_cap && dev->has_sliced_vbi_cap) ?
1295 "raw and sliced" :
1296 (dev->has_raw_vbi_cap ? "raw" : "sliced"));
1297 }
1298
1299 if (dev->has_vbi_out) {
1300 vfd = &dev->vbi_out_dev;
1301 snprintf(vfd->name, sizeof(vfd->name),
1302 "vivid-%03d-vbi-out", inst);
1303 vfd->vfl_dir = VFL_DIR_TX;
1304 vfd->fops = &vivid_fops;
1305 vfd->ioctl_ops = &vivid_ioctl_ops;
1306 vfd->device_caps = dev->vbi_out_caps;
1307 vfd->release = video_device_release_empty;
1308 vfd->v4l2_dev = &dev->v4l2_dev;
1309 vfd->queue = &dev->vb_vbi_out_q;
1310 vfd->lock = &dev->mutex;
1311 vfd->tvnorms = tvnorms_out;
1312 video_set_drvdata(vfd, dev);
1313
1314 ret = video_register_device(vfd, VFL_TYPE_VBI, vbi_out_nr[inst]);
1315 if (ret < 0)
1316 goto unreg_dev;
1317 v4l2_info(&dev->v4l2_dev, "V4L2 output device registered as %s, supports %s VBI\n",
1318 video_device_node_name(vfd),
1319 (dev->has_raw_vbi_out && dev->has_sliced_vbi_out) ?
1320 "raw and sliced" :
1321 (dev->has_raw_vbi_out ? "raw" : "sliced"));
1322 }
1323
1324 if (dev->has_sdr_cap) {
1325 vfd = &dev->sdr_cap_dev;
1326 snprintf(vfd->name, sizeof(vfd->name),
1327 "vivid-%03d-sdr-cap", inst);
1328 vfd->fops = &vivid_fops;
1329 vfd->ioctl_ops = &vivid_ioctl_ops;
1330 vfd->device_caps = dev->sdr_cap_caps;
1331 vfd->release = video_device_release_empty;
1332 vfd->v4l2_dev = &dev->v4l2_dev;
1333 vfd->queue = &dev->vb_sdr_cap_q;
1334 vfd->lock = &dev->mutex;
1335 video_set_drvdata(vfd, dev);
1336
1337 ret = video_register_device(vfd, VFL_TYPE_SDR, sdr_cap_nr[inst]);
1338 if (ret < 0)
1339 goto unreg_dev;
1340 v4l2_info(&dev->v4l2_dev, "V4L2 capture device registered as %s\n",
1341 video_device_node_name(vfd));
1342 }
1343
1344 if (dev->has_radio_rx) {
1345 vfd = &dev->radio_rx_dev;
1346 snprintf(vfd->name, sizeof(vfd->name),
1347 "vivid-%03d-rad-rx", inst);
1348 vfd->fops = &vivid_radio_fops;
1349 vfd->ioctl_ops = &vivid_ioctl_ops;
1350 vfd->device_caps = dev->radio_rx_caps;
1351 vfd->release = video_device_release_empty;
1352 vfd->v4l2_dev = &dev->v4l2_dev;
1353 vfd->lock = &dev->mutex;
1354 video_set_drvdata(vfd, dev);
1355
1356 ret = video_register_device(vfd, VFL_TYPE_RADIO, radio_rx_nr[inst]);
1357 if (ret < 0)
1358 goto unreg_dev;
1359 v4l2_info(&dev->v4l2_dev, "V4L2 receiver device registered as %s\n",
1360 video_device_node_name(vfd));
1361 }
1362
1363 if (dev->has_radio_tx) {
1364 vfd = &dev->radio_tx_dev;
1365 snprintf(vfd->name, sizeof(vfd->name),
1366 "vivid-%03d-rad-tx", inst);
1367 vfd->vfl_dir = VFL_DIR_TX;
1368 vfd->fops = &vivid_radio_fops;
1369 vfd->ioctl_ops = &vivid_ioctl_ops;
1370 vfd->device_caps = dev->radio_tx_caps;
1371 vfd->release = video_device_release_empty;
1372 vfd->v4l2_dev = &dev->v4l2_dev;
1373 vfd->lock = &dev->mutex;
1374 video_set_drvdata(vfd, dev);
1375
1376 ret = video_register_device(vfd, VFL_TYPE_RADIO, radio_tx_nr[inst]);
1377 if (ret < 0)
1378 goto unreg_dev;
1379 v4l2_info(&dev->v4l2_dev, "V4L2 transmitter device registered as %s\n",
1380 video_device_node_name(vfd));
1381 }
1382
1383 /* Now that everything is fine, let's add it to device list */
1384 vivid_devs[inst] = dev;
1385
1386 return 0;
1387
1388 unreg_dev:
1389 video_unregister_device(&dev->radio_tx_dev);
1390 video_unregister_device(&dev->radio_rx_dev);
1391 video_unregister_device(&dev->sdr_cap_dev);
1392 video_unregister_device(&dev->vbi_out_dev);
1393 video_unregister_device(&dev->vbi_cap_dev);
1394 video_unregister_device(&dev->vid_out_dev);
1395 video_unregister_device(&dev->vid_cap_dev);
1396 cec_unregister_adapter(dev->cec_rx_adap);
1397 for (i = 0; i < MAX_OUTPUTS; i++)
1398 cec_unregister_adapter(dev->cec_tx_adap[i]);
1399 if (dev->cec_workqueue) {
1400 vivid_cec_bus_free_work(dev);
1401 destroy_workqueue(dev->cec_workqueue);
1402 }
1403 free_dev:
1404 v4l2_device_put(&dev->v4l2_dev);
1405 return ret;
1406 }
1407
1408 /* This routine allocates from 1 to n_devs virtual drivers.
1409
1410 The real maximum number of virtual drivers will depend on how many drivers
1411 will succeed. This is limited to the maximum number of devices that
1412 videodev supports, which is equal to VIDEO_NUM_DEVICES.
1413 */
1414 static int vivid_probe(struct platform_device *pdev)
1415 {
1416 const struct font_desc *font = find_font("VGA8x16");
1417 int ret = 0, i;
1418
1419 if (font == NULL) {
1420 pr_err("vivid: could not find font\n");
1421 return -ENODEV;
1422 }
1423
1424 tpg_set_font(font->data);
1425
1426 n_devs = clamp_t(unsigned, n_devs, 1, VIVID_MAX_DEVS);
1427
1428 for (i = 0; i < n_devs; i++) {
1429 ret = vivid_create_instance(pdev, i);
1430 if (ret) {
1431 /* If some instantiations succeeded, keep driver */
1432 if (i)
1433 ret = 0;
1434 break;
1435 }
1436 }
1437
1438 if (ret < 0) {
1439 pr_err("vivid: error %d while loading driver\n", ret);
1440 return ret;
1441 }
1442
1443 /* n_devs will reflect the actual number of allocated devices */
1444 n_devs = i;
1445
1446 return ret;
1447 }
1448
1449 static int vivid_remove(struct platform_device *pdev)
1450 {
1451 struct vivid_dev *dev;
1452 unsigned int i, j;
1453
1454 for (i = 0; i < n_devs; i++) {
1455 dev = vivid_devs[i];
1456 if (!dev)
1457 continue;
1458
1459 if (dev->has_vid_cap) {
1460 v4l2_info(&dev->v4l2_dev, "unregistering %s\n",
1461 video_device_node_name(&dev->vid_cap_dev));
1462 video_unregister_device(&dev->vid_cap_dev);
1463 }
1464 if (dev->has_vid_out) {
1465 v4l2_info(&dev->v4l2_dev, "unregistering %s\n",
1466 video_device_node_name(&dev->vid_out_dev));
1467 video_unregister_device(&dev->vid_out_dev);
1468 }
1469 if (dev->has_vbi_cap) {
1470 v4l2_info(&dev->v4l2_dev, "unregistering %s\n",
1471 video_device_node_name(&dev->vbi_cap_dev));
1472 video_unregister_device(&dev->vbi_cap_dev);
1473 }
1474 if (dev->has_vbi_out) {
1475 v4l2_info(&dev->v4l2_dev, "unregistering %s\n",
1476 video_device_node_name(&dev->vbi_out_dev));
1477 video_unregister_device(&dev->vbi_out_dev);
1478 }
1479 if (dev->has_sdr_cap) {
1480 v4l2_info(&dev->v4l2_dev, "unregistering %s\n",
1481 video_device_node_name(&dev->sdr_cap_dev));
1482 video_unregister_device(&dev->sdr_cap_dev);
1483 }
1484 if (dev->has_radio_rx) {
1485 v4l2_info(&dev->v4l2_dev, "unregistering %s\n",
1486 video_device_node_name(&dev->radio_rx_dev));
1487 video_unregister_device(&dev->radio_rx_dev);
1488 }
1489 if (dev->has_radio_tx) {
1490 v4l2_info(&dev->v4l2_dev, "unregistering %s\n",
1491 video_device_node_name(&dev->radio_tx_dev));
1492 video_unregister_device(&dev->radio_tx_dev);
1493 }
1494 if (dev->has_fb) {
1495 v4l2_info(&dev->v4l2_dev, "unregistering fb%d\n",
1496 dev->fb_info.node);
1497 unregister_framebuffer(&dev->fb_info);
1498 vivid_fb_release_buffers(dev);
1499 }
1500 cec_unregister_adapter(dev->cec_rx_adap);
1501 for (j = 0; j < MAX_OUTPUTS; j++)
1502 cec_unregister_adapter(dev->cec_tx_adap[j]);
1503 if (dev->cec_workqueue) {
1504 vivid_cec_bus_free_work(dev);
1505 destroy_workqueue(dev->cec_workqueue);
1506 }
1507 v4l2_device_put(&dev->v4l2_dev);
1508 vivid_devs[i] = NULL;
1509 }
1510 return 0;
1511 }
1512
1513 static void vivid_pdev_release(struct device *dev)
1514 {
1515 }
1516
1517 static struct platform_device vivid_pdev = {
1518 .name = "vivid",
1519 .dev.release = vivid_pdev_release,
1520 };
1521
1522 static struct platform_driver vivid_pdrv = {
1523 .probe = vivid_probe,
1524 .remove = vivid_remove,
1525 .driver = {
1526 .name = "vivid",
1527 },
1528 };
1529
1530 static int __init vivid_init(void)
1531 {
1532 int ret;
1533
1534 ret = platform_device_register(&vivid_pdev);
1535 if (ret)
1536 return ret;
1537
1538 ret = platform_driver_register(&vivid_pdrv);
1539 if (ret)
1540 platform_device_unregister(&vivid_pdev);
1541
1542 return ret;
1543 }
1544
1545 static void __exit vivid_exit(void)
1546 {
1547 platform_driver_unregister(&vivid_pdrv);
1548 platform_device_unregister(&vivid_pdev);
1549 }
1550
1551 module_init(vivid_init);
1552 module_exit(vivid_exit);
CRIS linux kernel tree