2 * vivid-core.c - A Virtual Video Test Driver, core initialization
4 * Copyright 2014 Cisco Systems, Inc. and/or its affiliates. All rights reserved.
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.
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
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/v4l2-dv-timings.h>
34 #include <media/v4l2-ioctl.h>
35 #include <media/v4l2-fh.h>
36 #include <media/v4l2-event.h>
38 #include "vivid-core.h"
39 #include "vivid-vid-common.h"
40 #include "vivid-vid-cap.h"
41 #include "vivid-vid-out.h"
42 #include "vivid-radio-common.h"
43 #include "vivid-radio-rx.h"
44 #include "vivid-radio-tx.h"
45 #include "vivid-sdr-cap.h"
46 #include "vivid-vbi-cap.h"
47 #include "vivid-vbi-out.h"
48 #include "vivid-osd.h"
49 #include "vivid-ctrls.h"
51 #define VIVID_MODULE_NAME "vivid"
53 /* The maximum number of vivid devices */
54 #define VIVID_MAX_DEVS 64
56 MODULE_DESCRIPTION("Virtual Video Test Driver");
57 MODULE_AUTHOR("Hans Verkuil");
58 MODULE_LICENSE("GPL");
60 static unsigned n_devs = 1;
61 module_param(n_devs, uint, 0444);
62 MODULE_PARM_DESC(n_devs, " number of driver instances to create");
64 static int vid_cap_nr[VIVID_MAX_DEVS] = { [0 ... (VIVID_MAX_DEVS - 1)] = -1 };
65 module_param_array(vid_cap_nr, int, NULL, 0444);
66 MODULE_PARM_DESC(vid_cap_nr, " videoX start number, -1 is autodetect");
68 static int vid_out_nr[VIVID_MAX_DEVS] = { [0 ... (VIVID_MAX_DEVS - 1)] = -1 };
69 module_param_array(vid_out_nr, int, NULL, 0444);
70 MODULE_PARM_DESC(vid_out_nr, " videoX start number, -1 is autodetect");
72 static int vbi_cap_nr[VIVID_MAX_DEVS] = { [0 ... (VIVID_MAX_DEVS - 1)] = -1 };
73 module_param_array(vbi_cap_nr, int, NULL, 0444);
74 MODULE_PARM_DESC(vbi_cap_nr, " vbiX start number, -1 is autodetect");
76 static int vbi_out_nr[VIVID_MAX_DEVS] = { [0 ... (VIVID_MAX_DEVS - 1)] = -1 };
77 module_param_array(vbi_out_nr, int, NULL, 0444);
78 MODULE_PARM_DESC(vbi_out_nr, " vbiX start number, -1 is autodetect");
80 static int sdr_cap_nr[VIVID_MAX_DEVS] = { [0 ... (VIVID_MAX_DEVS - 1)] = -1 };
81 module_param_array(sdr_cap_nr, int, NULL, 0444);
82 MODULE_PARM_DESC(sdr_cap_nr, " swradioX start number, -1 is autodetect");
84 static int radio_rx_nr[VIVID_MAX_DEVS] = { [0 ... (VIVID_MAX_DEVS - 1)] = -1 };
85 module_param_array(radio_rx_nr, int, NULL, 0444);
86 MODULE_PARM_DESC(radio_rx_nr, " radioX start number, -1 is autodetect");
88 static int radio_tx_nr[VIVID_MAX_DEVS] = { [0 ... (VIVID_MAX_DEVS - 1)] = -1 };
89 module_param_array(radio_tx_nr, int, NULL, 0444);
90 MODULE_PARM_DESC(radio_tx_nr, " radioX start number, -1 is autodetect");
92 static int ccs_cap_mode[VIVID_MAX_DEVS] = { [0 ... (VIVID_MAX_DEVS - 1)] = -1 };
93 module_param_array(ccs_cap_mode, int, NULL, 0444);
94 MODULE_PARM_DESC(ccs_cap_mode, " capture crop/compose/scale mode:\n"
95 "\t\t bit 0=crop, 1=compose, 2=scale,\n"
96 "\t\t -1=user-controlled (default)");
98 static int ccs_out_mode[VIVID_MAX_DEVS] = { [0 ... (VIVID_MAX_DEVS - 1)] = -1 };
99 module_param_array(ccs_out_mode, int, NULL, 0444);
100 MODULE_PARM_DESC(ccs_out_mode, " output crop/compose/scale mode:\n"
101 "\t\t bit 0=crop, 1=compose, 2=scale,\n"
102 "\t\t -1=user-controlled (default)");
104 static unsigned multiplanar[VIVID_MAX_DEVS] = { [0 ... (VIVID_MAX_DEVS - 1)] = 1 };
105 module_param_array(multiplanar, uint, NULL, 0444);
106 MODULE_PARM_DESC(multiplanar, " 1 (default) creates a single planar device, 2 creates a multiplanar device.");
108 /* Default: video + vbi-cap (raw and sliced) + radio rx + radio tx + sdr + vbi-out + vid-out */
109 static unsigned node_types[VIVID_MAX_DEVS] = { [0 ... (VIVID_MAX_DEVS - 1)] = 0x1d3d };
110 module_param_array(node_types, uint, NULL, 0444);
111 MODULE_PARM_DESC(node_types, " node types, default is 0x1d3d. Bitmask with the following meaning:\n"
112 "\t\t bit 0: Video Capture node\n"
113 "\t\t bit 2-3: VBI Capture node: 0 = none, 1 = raw vbi, 2 = sliced vbi, 3 = both\n"
114 "\t\t bit 4: Radio Receiver node\n"
115 "\t\t bit 5: Software Defined Radio Receiver node\n"
116 "\t\t bit 8: Video Output node\n"
117 "\t\t bit 10-11: VBI Output node: 0 = none, 1 = raw vbi, 2 = sliced vbi, 3 = both\n"
118 "\t\t bit 12: Radio Transmitter node\n"
119 "\t\t bit 16: Framebuffer for testing overlays");
121 /* Default: 4 inputs */
122 static unsigned num_inputs[VIVID_MAX_DEVS] = { [0 ... (VIVID_MAX_DEVS - 1)] = 4 };
123 module_param_array(num_inputs, uint, NULL, 0444);
124 MODULE_PARM_DESC(num_inputs, " number of inputs, default is 4");
126 /* Default: input 0 = WEBCAM, 1 = TV, 2 = SVID, 3 = HDMI */
127 static unsigned input_types[VIVID_MAX_DEVS] = { [0 ... (VIVID_MAX_DEVS - 1)] = 0xe4 };
128 module_param_array(input_types, uint, NULL, 0444);
129 MODULE_PARM_DESC(input_types, " input types, default is 0xe4. Two bits per input,\n"
130 "\t\t bits 0-1 == input 0, bits 31-30 == input 15.\n"
131 "\t\t Type 0 == webcam, 1 == TV, 2 == S-Video, 3 == HDMI");
133 /* Default: 2 outputs */
134 static unsigned num_outputs[VIVID_MAX_DEVS] = { [0 ... (VIVID_MAX_DEVS - 1)] = 2 };
135 module_param_array(num_outputs, uint, NULL, 0444);
136 MODULE_PARM_DESC(num_outputs, " number of outputs, default is 2");
138 /* Default: output 0 = SVID, 1 = HDMI */
139 static unsigned output_types[VIVID_MAX_DEVS] = { [0 ... (VIVID_MAX_DEVS - 1)] = 2 };
140 module_param_array(output_types, uint, NULL, 0444);
141 MODULE_PARM_DESC(output_types, " output types, default is 0x02. One bit per output,\n"
142 "\t\t bit 0 == output 0, bit 15 == output 15.\n"
143 "\t\t Type 0 == S-Video, 1 == HDMI");
145 unsigned vivid_debug;
146 module_param(vivid_debug, uint, 0644);
147 MODULE_PARM_DESC(vivid_debug, " activates debug info");
149 static bool no_error_inj;
150 module_param(no_error_inj, bool, 0444);
151 MODULE_PARM_DESC(no_error_inj, " if set disable the error injecting controls");
153 static struct vivid_dev *vivid_devs[VIVID_MAX_DEVS];
155 const struct v4l2_rect vivid_min_rect = {
156 0, 0, MIN_WIDTH, MIN_HEIGHT
159 const struct v4l2_rect vivid_max_rect = {
160 0, 0, MAX_WIDTH * MAX_ZOOM, MAX_HEIGHT * MAX_ZOOM
163 static const u8 vivid_hdmi_edid[256] = {
164 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00,
165 0x63, 0x3a, 0xaa, 0x55, 0x00, 0x00, 0x00, 0x00,
166 0x0a, 0x18, 0x01, 0x03, 0x80, 0x10, 0x09, 0x78,
167 0x0e, 0x00, 0xb2, 0xa0, 0x57, 0x49, 0x9b, 0x26,
168 0x10, 0x48, 0x4f, 0x2f, 0xcf, 0x00, 0x31, 0x59,
169 0x45, 0x59, 0x81, 0x80, 0x81, 0x40, 0x90, 0x40,
170 0x95, 0x00, 0xa9, 0x40, 0xb3, 0x00, 0x02, 0x3a,
171 0x80, 0x18, 0x71, 0x38, 0x2d, 0x40, 0x58, 0x2c,
172 0x46, 0x00, 0x10, 0x09, 0x00, 0x00, 0x00, 0x1e,
173 0x00, 0x00, 0x00, 0xfd, 0x00, 0x18, 0x55, 0x18,
174 0x5e, 0x11, 0x00, 0x0a, 0x20, 0x20, 0x20, 0x20,
175 0x20, 0x20, 0x00, 0x00, 0x00, 0xfc, 0x00, 'v',
176 '4', 'l', '2', '-', 'h', 'd', 'm', 'i',
177 0x0a, 0x0a, 0x0a, 0x0a, 0x00, 0x00, 0x00, 0x10,
178 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
179 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0xf0,
181 0x02, 0x03, 0x1a, 0xc0, 0x48, 0xa2, 0x10, 0x04,
182 0x02, 0x01, 0x21, 0x14, 0x13, 0x23, 0x09, 0x07,
183 0x07, 0x65, 0x03, 0x0c, 0x00, 0x10, 0x00, 0xe2,
184 0x00, 0x2a, 0x01, 0x1d, 0x00, 0x80, 0x51, 0xd0,
185 0x1c, 0x20, 0x40, 0x80, 0x35, 0x00, 0x00, 0x00,
186 0x00, 0x00, 0x00, 0x1e, 0x8c, 0x0a, 0xd0, 0x8a,
187 0x20, 0xe0, 0x2d, 0x10, 0x10, 0x3e, 0x96, 0x00,
188 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00,
189 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
190 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
191 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
192 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
193 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
194 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
195 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
196 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xd7
199 static int vidioc_querycap(struct file *file, void *priv,
200 struct v4l2_capability *cap)
202 struct vivid_dev *dev = video_drvdata(file);
203 struct video_device *vdev = video_devdata(file);
205 strcpy(cap->driver, "vivid");
206 strcpy(cap->card, "vivid");
207 snprintf(cap->bus_info, sizeof(cap->bus_info),
208 "platform:%s", dev->v4l2_dev.name);
210 if (vdev->vfl_type == VFL_TYPE_GRABBER && vdev->vfl_dir == VFL_DIR_RX)
211 cap->device_caps = dev->vid_cap_caps;
212 if (vdev->vfl_type == VFL_TYPE_GRABBER && vdev->vfl_dir == VFL_DIR_TX)
213 cap->device_caps = dev->vid_out_caps;
214 else if (vdev->vfl_type == VFL_TYPE_VBI && vdev->vfl_dir == VFL_DIR_RX)
215 cap->device_caps = dev->vbi_cap_caps;
216 else if (vdev->vfl_type == VFL_TYPE_VBI && vdev->vfl_dir == VFL_DIR_TX)
217 cap->device_caps = dev->vbi_out_caps;
218 else if (vdev->vfl_type == VFL_TYPE_SDR)
219 cap->device_caps = dev->sdr_cap_caps;
220 else if (vdev->vfl_type == VFL_TYPE_RADIO && vdev->vfl_dir == VFL_DIR_RX)
221 cap->device_caps = dev->radio_rx_caps;
222 else if (vdev->vfl_type == VFL_TYPE_RADIO && vdev->vfl_dir == VFL_DIR_TX)
223 cap->device_caps = dev->radio_tx_caps;
224 cap->capabilities = dev->vid_cap_caps | dev->vid_out_caps |
225 dev->vbi_cap_caps | dev->vbi_out_caps |
226 dev->radio_rx_caps | dev->radio_tx_caps |
227 dev->sdr_cap_caps | V4L2_CAP_DEVICE_CAPS;
231 static int vidioc_s_hw_freq_seek(struct file *file, void *fh, const struct v4l2_hw_freq_seek *a)
233 struct video_device *vdev = video_devdata(file);
235 if (vdev->vfl_type == VFL_TYPE_RADIO)
236 return vivid_radio_rx_s_hw_freq_seek(file, fh, a);
240 static int vidioc_enum_freq_bands(struct file *file, void *fh, struct v4l2_frequency_band *band)
242 struct video_device *vdev = video_devdata(file);
244 if (vdev->vfl_type == VFL_TYPE_RADIO)
245 return vivid_radio_rx_enum_freq_bands(file, fh, band);
246 if (vdev->vfl_type == VFL_TYPE_SDR)
247 return vivid_sdr_enum_freq_bands(file, fh, band);
251 static int vidioc_g_tuner(struct file *file, void *fh, struct v4l2_tuner *vt)
253 struct video_device *vdev = video_devdata(file);
255 if (vdev->vfl_type == VFL_TYPE_RADIO)
256 return vivid_radio_rx_g_tuner(file, fh, vt);
257 if (vdev->vfl_type == VFL_TYPE_SDR)
258 return vivid_sdr_g_tuner(file, fh, vt);
259 return vivid_video_g_tuner(file, fh, vt);
262 static int vidioc_s_tuner(struct file *file, void *fh, const struct v4l2_tuner *vt)
264 struct video_device *vdev = video_devdata(file);
266 if (vdev->vfl_type == VFL_TYPE_RADIO)
267 return vivid_radio_rx_s_tuner(file, fh, vt);
268 if (vdev->vfl_type == VFL_TYPE_SDR)
269 return vivid_sdr_s_tuner(file, fh, vt);
270 return vivid_video_s_tuner(file, fh, vt);
273 static int vidioc_g_frequency(struct file *file, void *fh, struct v4l2_frequency *vf)
275 struct vivid_dev *dev = video_drvdata(file);
276 struct video_device *vdev = video_devdata(file);
278 if (vdev->vfl_type == VFL_TYPE_RADIO)
279 return vivid_radio_g_frequency(file,
280 vdev->vfl_dir == VFL_DIR_RX ?
281 &dev->radio_rx_freq : &dev->radio_tx_freq, vf);
282 if (vdev->vfl_type == VFL_TYPE_SDR)
283 return vivid_sdr_g_frequency(file, fh, vf);
284 return vivid_video_g_frequency(file, fh, vf);
287 static int vidioc_s_frequency(struct file *file, void *fh, const struct v4l2_frequency *vf)
289 struct vivid_dev *dev = video_drvdata(file);
290 struct video_device *vdev = video_devdata(file);
292 if (vdev->vfl_type == VFL_TYPE_RADIO)
293 return vivid_radio_s_frequency(file,
294 vdev->vfl_dir == VFL_DIR_RX ?
295 &dev->radio_rx_freq : &dev->radio_tx_freq, vf);
296 if (vdev->vfl_type == VFL_TYPE_SDR)
297 return vivid_sdr_s_frequency(file, fh, vf);
298 return vivid_video_s_frequency(file, fh, vf);
301 static int vidioc_overlay(struct file *file, void *fh, unsigned i)
303 struct video_device *vdev = video_devdata(file);
305 if (vdev->vfl_dir == VFL_DIR_RX)
306 return vivid_vid_cap_overlay(file, fh, i);
307 return vivid_vid_out_overlay(file, fh, i);
310 static int vidioc_g_fbuf(struct file *file, void *fh, struct v4l2_framebuffer *a)
312 struct video_device *vdev = video_devdata(file);
314 if (vdev->vfl_dir == VFL_DIR_RX)
315 return vivid_vid_cap_g_fbuf(file, fh, a);
316 return vivid_vid_out_g_fbuf(file, fh, a);
319 static int vidioc_s_fbuf(struct file *file, void *fh, const struct v4l2_framebuffer *a)
321 struct video_device *vdev = video_devdata(file);
323 if (vdev->vfl_dir == VFL_DIR_RX)
324 return vivid_vid_cap_s_fbuf(file, fh, a);
325 return vivid_vid_out_s_fbuf(file, fh, a);
328 static int vidioc_s_std(struct file *file, void *fh, v4l2_std_id id)
330 struct video_device *vdev = video_devdata(file);
332 if (vdev->vfl_dir == VFL_DIR_RX)
333 return vivid_vid_cap_s_std(file, fh, id);
334 return vivid_vid_out_s_std(file, fh, id);
337 static int vidioc_s_dv_timings(struct file *file, void *fh, struct v4l2_dv_timings *timings)
339 struct video_device *vdev = video_devdata(file);
341 if (vdev->vfl_dir == VFL_DIR_RX)
342 return vivid_vid_cap_s_dv_timings(file, fh, timings);
343 return vivid_vid_out_s_dv_timings(file, fh, timings);
346 static int vidioc_cropcap(struct file *file, void *fh, struct v4l2_cropcap *cc)
348 struct video_device *vdev = video_devdata(file);
350 if (vdev->vfl_dir == VFL_DIR_RX)
351 return vivid_vid_cap_cropcap(file, fh, cc);
352 return vivid_vid_out_cropcap(file, fh, cc);
355 static int vidioc_g_selection(struct file *file, void *fh,
356 struct v4l2_selection *sel)
358 struct video_device *vdev = video_devdata(file);
360 if (vdev->vfl_dir == VFL_DIR_RX)
361 return vivid_vid_cap_g_selection(file, fh, sel);
362 return vivid_vid_out_g_selection(file, fh, sel);
365 static int vidioc_s_selection(struct file *file, void *fh,
366 struct v4l2_selection *sel)
368 struct video_device *vdev = video_devdata(file);
370 if (vdev->vfl_dir == VFL_DIR_RX)
371 return vivid_vid_cap_s_selection(file, fh, sel);
372 return vivid_vid_out_s_selection(file, fh, sel);
375 static int vidioc_g_parm(struct file *file, void *fh,
376 struct v4l2_streamparm *parm)
378 struct video_device *vdev = video_devdata(file);
380 if (vdev->vfl_dir == VFL_DIR_RX)
381 return vivid_vid_cap_g_parm(file, fh, parm);
382 return vivid_vid_out_g_parm(file, fh, parm);
385 static int vidioc_s_parm(struct file *file, void *fh,
386 struct v4l2_streamparm *parm)
388 struct video_device *vdev = video_devdata(file);
390 if (vdev->vfl_dir == VFL_DIR_RX)
391 return vivid_vid_cap_s_parm(file, fh, parm);
392 return vivid_vid_out_g_parm(file, fh, parm);
395 static ssize_t vivid_radio_read(struct file *file, char __user *buf,
396 size_t size, loff_t *offset)
398 struct video_device *vdev = video_devdata(file);
400 if (vdev->vfl_dir == VFL_DIR_TX)
402 return vivid_radio_rx_read(file, buf, size, offset);
405 static ssize_t vivid_radio_write(struct file *file, const char __user *buf,
406 size_t size, loff_t *offset)
408 struct video_device *vdev = video_devdata(file);
410 if (vdev->vfl_dir == VFL_DIR_RX)
412 return vivid_radio_tx_write(file, buf, size, offset);
415 static unsigned int vivid_radio_poll(struct file *file, struct poll_table_struct *wait)
417 struct video_device *vdev = video_devdata(file);
419 if (vdev->vfl_dir == VFL_DIR_RX)
420 return vivid_radio_rx_poll(file, wait);
421 return vivid_radio_tx_poll(file, wait);
424 static bool vivid_is_in_use(struct video_device *vdev)
429 spin_lock_irqsave(&vdev->fh_lock, flags);
430 res = !list_empty(&vdev->fh_list);
431 spin_unlock_irqrestore(&vdev->fh_lock, flags);
435 static bool vivid_is_last_user(struct vivid_dev *dev)
437 unsigned uses = vivid_is_in_use(&dev->vid_cap_dev) +
438 vivid_is_in_use(&dev->vid_out_dev) +
439 vivid_is_in_use(&dev->vbi_cap_dev) +
440 vivid_is_in_use(&dev->vbi_out_dev) +
441 vivid_is_in_use(&dev->sdr_cap_dev) +
442 vivid_is_in_use(&dev->radio_rx_dev) +
443 vivid_is_in_use(&dev->radio_tx_dev);
448 static int vivid_fop_release(struct file *file)
450 struct vivid_dev *dev = video_drvdata(file);
451 struct video_device *vdev = video_devdata(file);
453 mutex_lock(&dev->mutex);
454 if (!no_error_inj && v4l2_fh_is_singular_file(file) &&
455 !video_is_registered(vdev) && vivid_is_last_user(dev)) {
457 * I am the last user of this driver, and a disconnect
458 * was forced (since this video_device is unregistered),
459 * so re-register all video_device's again.
461 v4l2_info(&dev->v4l2_dev, "reconnect\n");
462 set_bit(V4L2_FL_REGISTERED, &dev->vid_cap_dev.flags);
463 set_bit(V4L2_FL_REGISTERED, &dev->vid_out_dev.flags);
464 set_bit(V4L2_FL_REGISTERED, &dev->vbi_cap_dev.flags);
465 set_bit(V4L2_FL_REGISTERED, &dev->vbi_out_dev.flags);
466 set_bit(V4L2_FL_REGISTERED, &dev->sdr_cap_dev.flags);
467 set_bit(V4L2_FL_REGISTERED, &dev->radio_rx_dev.flags);
468 set_bit(V4L2_FL_REGISTERED, &dev->radio_tx_dev.flags);
470 mutex_unlock(&dev->mutex);
471 if (file->private_data == dev->overlay_cap_owner)
472 dev->overlay_cap_owner = NULL;
473 if (file->private_data == dev->radio_rx_rds_owner) {
474 dev->radio_rx_rds_last_block = 0;
475 dev->radio_rx_rds_owner = NULL;
477 if (file->private_data == dev->radio_tx_rds_owner) {
478 dev->radio_tx_rds_last_block = 0;
479 dev->radio_tx_rds_owner = NULL;
482 return vb2_fop_release(file);
483 return v4l2_fh_release(file);
486 static const struct v4l2_file_operations vivid_fops = {
487 .owner = THIS_MODULE,
488 .open = v4l2_fh_open,
489 .release = vivid_fop_release,
490 .read = vb2_fop_read,
491 .write = vb2_fop_write,
492 .poll = vb2_fop_poll,
493 .unlocked_ioctl = video_ioctl2,
494 .mmap = vb2_fop_mmap,
497 static const struct v4l2_file_operations vivid_radio_fops = {
498 .owner = THIS_MODULE,
499 .open = v4l2_fh_open,
500 .release = vivid_fop_release,
501 .read = vivid_radio_read,
502 .write = vivid_radio_write,
503 .poll = vivid_radio_poll,
504 .unlocked_ioctl = video_ioctl2,
507 static const struct v4l2_ioctl_ops vivid_ioctl_ops = {
508 .vidioc_querycap = vidioc_querycap,
510 .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid,
511 .vidioc_g_fmt_vid_cap = vidioc_g_fmt_vid_cap,
512 .vidioc_try_fmt_vid_cap = vidioc_try_fmt_vid_cap,
513 .vidioc_s_fmt_vid_cap = vidioc_s_fmt_vid_cap,
514 .vidioc_enum_fmt_vid_cap_mplane = vidioc_enum_fmt_vid_mplane,
515 .vidioc_g_fmt_vid_cap_mplane = vidioc_g_fmt_vid_cap_mplane,
516 .vidioc_try_fmt_vid_cap_mplane = vidioc_try_fmt_vid_cap_mplane,
517 .vidioc_s_fmt_vid_cap_mplane = vidioc_s_fmt_vid_cap_mplane,
519 .vidioc_enum_fmt_vid_out = vidioc_enum_fmt_vid,
520 .vidioc_g_fmt_vid_out = vidioc_g_fmt_vid_out,
521 .vidioc_try_fmt_vid_out = vidioc_try_fmt_vid_out,
522 .vidioc_s_fmt_vid_out = vidioc_s_fmt_vid_out,
523 .vidioc_enum_fmt_vid_out_mplane = vidioc_enum_fmt_vid_mplane,
524 .vidioc_g_fmt_vid_out_mplane = vidioc_g_fmt_vid_out_mplane,
525 .vidioc_try_fmt_vid_out_mplane = vidioc_try_fmt_vid_out_mplane,
526 .vidioc_s_fmt_vid_out_mplane = vidioc_s_fmt_vid_out_mplane,
528 .vidioc_g_selection = vidioc_g_selection,
529 .vidioc_s_selection = vidioc_s_selection,
530 .vidioc_cropcap = vidioc_cropcap,
532 .vidioc_g_fmt_vbi_cap = vidioc_g_fmt_vbi_cap,
533 .vidioc_try_fmt_vbi_cap = vidioc_g_fmt_vbi_cap,
534 .vidioc_s_fmt_vbi_cap = vidioc_s_fmt_vbi_cap,
536 .vidioc_g_fmt_sliced_vbi_cap = vidioc_g_fmt_sliced_vbi_cap,
537 .vidioc_try_fmt_sliced_vbi_cap = vidioc_try_fmt_sliced_vbi_cap,
538 .vidioc_s_fmt_sliced_vbi_cap = vidioc_s_fmt_sliced_vbi_cap,
539 .vidioc_g_sliced_vbi_cap = vidioc_g_sliced_vbi_cap,
541 .vidioc_g_fmt_vbi_out = vidioc_g_fmt_vbi_out,
542 .vidioc_try_fmt_vbi_out = vidioc_g_fmt_vbi_out,
543 .vidioc_s_fmt_vbi_out = vidioc_s_fmt_vbi_out,
545 .vidioc_g_fmt_sliced_vbi_out = vidioc_g_fmt_sliced_vbi_out,
546 .vidioc_try_fmt_sliced_vbi_out = vidioc_try_fmt_sliced_vbi_out,
547 .vidioc_s_fmt_sliced_vbi_out = vidioc_s_fmt_sliced_vbi_out,
549 .vidioc_enum_fmt_sdr_cap = vidioc_enum_fmt_sdr_cap,
550 .vidioc_g_fmt_sdr_cap = vidioc_g_fmt_sdr_cap,
551 .vidioc_try_fmt_sdr_cap = vidioc_g_fmt_sdr_cap,
552 .vidioc_s_fmt_sdr_cap = vidioc_g_fmt_sdr_cap,
554 .vidioc_overlay = vidioc_overlay,
555 .vidioc_enum_framesizes = vidioc_enum_framesizes,
556 .vidioc_enum_frameintervals = vidioc_enum_frameintervals,
557 .vidioc_g_parm = vidioc_g_parm,
558 .vidioc_s_parm = vidioc_s_parm,
560 .vidioc_enum_fmt_vid_overlay = vidioc_enum_fmt_vid_overlay,
561 .vidioc_g_fmt_vid_overlay = vidioc_g_fmt_vid_overlay,
562 .vidioc_try_fmt_vid_overlay = vidioc_try_fmt_vid_overlay,
563 .vidioc_s_fmt_vid_overlay = vidioc_s_fmt_vid_overlay,
564 .vidioc_g_fmt_vid_out_overlay = vidioc_g_fmt_vid_out_overlay,
565 .vidioc_try_fmt_vid_out_overlay = vidioc_try_fmt_vid_out_overlay,
566 .vidioc_s_fmt_vid_out_overlay = vidioc_s_fmt_vid_out_overlay,
567 .vidioc_g_fbuf = vidioc_g_fbuf,
568 .vidioc_s_fbuf = vidioc_s_fbuf,
570 .vidioc_reqbufs = vb2_ioctl_reqbufs,
571 .vidioc_create_bufs = vb2_ioctl_create_bufs,
572 .vidioc_prepare_buf = vb2_ioctl_prepare_buf,
573 .vidioc_querybuf = vb2_ioctl_querybuf,
574 .vidioc_qbuf = vb2_ioctl_qbuf,
575 .vidioc_dqbuf = vb2_ioctl_dqbuf,
576 .vidioc_expbuf = vb2_ioctl_expbuf,
577 .vidioc_streamon = vb2_ioctl_streamon,
578 .vidioc_streamoff = vb2_ioctl_streamoff,
580 .vidioc_enum_input = vidioc_enum_input,
581 .vidioc_g_input = vidioc_g_input,
582 .vidioc_s_input = vidioc_s_input,
583 .vidioc_s_audio = vidioc_s_audio,
584 .vidioc_g_audio = vidioc_g_audio,
585 .vidioc_enumaudio = vidioc_enumaudio,
586 .vidioc_s_frequency = vidioc_s_frequency,
587 .vidioc_g_frequency = vidioc_g_frequency,
588 .vidioc_s_tuner = vidioc_s_tuner,
589 .vidioc_g_tuner = vidioc_g_tuner,
590 .vidioc_s_modulator = vidioc_s_modulator,
591 .vidioc_g_modulator = vidioc_g_modulator,
592 .vidioc_s_hw_freq_seek = vidioc_s_hw_freq_seek,
593 .vidioc_enum_freq_bands = vidioc_enum_freq_bands,
595 .vidioc_enum_output = vidioc_enum_output,
596 .vidioc_g_output = vidioc_g_output,
597 .vidioc_s_output = vidioc_s_output,
598 .vidioc_s_audout = vidioc_s_audout,
599 .vidioc_g_audout = vidioc_g_audout,
600 .vidioc_enumaudout = vidioc_enumaudout,
602 .vidioc_querystd = vidioc_querystd,
603 .vidioc_g_std = vidioc_g_std,
604 .vidioc_s_std = vidioc_s_std,
605 .vidioc_s_dv_timings = vidioc_s_dv_timings,
606 .vidioc_g_dv_timings = vidioc_g_dv_timings,
607 .vidioc_query_dv_timings = vidioc_query_dv_timings,
608 .vidioc_enum_dv_timings = vidioc_enum_dv_timings,
609 .vidioc_dv_timings_cap = vidioc_dv_timings_cap,
610 .vidioc_g_edid = vidioc_g_edid,
611 .vidioc_s_edid = vidioc_s_edid,
613 .vidioc_log_status = v4l2_ctrl_log_status,
614 .vidioc_subscribe_event = vidioc_subscribe_event,
615 .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
618 /* -----------------------------------------------------------------
619 Initialization and module stuff
620 ------------------------------------------------------------------*/
622 static void vivid_dev_release(struct v4l2_device *v4l2_dev)
624 struct vivid_dev *dev = container_of(v4l2_dev, struct vivid_dev, v4l2_dev);
626 vivid_free_controls(dev);
627 v4l2_device_unregister(&dev->v4l2_dev);
628 vfree(dev->scaled_line);
629 vfree(dev->blended_line);
631 vfree(dev->bitmap_cap);
632 vfree(dev->bitmap_out);
634 kfree(dev->query_dv_timings_qmenu);
638 static int vivid_create_instance(struct platform_device *pdev, int inst)
640 static const struct v4l2_dv_timings def_dv_timings =
641 V4L2_DV_BT_CEA_1280X720P60;
642 unsigned in_type_counter[4] = { 0, 0, 0, 0 };
643 unsigned out_type_counter[4] = { 0, 0, 0, 0 };
644 int ccs_cap = ccs_cap_mode[inst];
645 int ccs_out = ccs_out_mode[inst];
648 struct vivid_dev *dev;
649 struct video_device *vfd;
651 unsigned node_type = node_types[inst];
652 v4l2_std_id tvnorms_cap = 0, tvnorms_out = 0;
656 /* allocate main vivid state structure */
657 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
663 /* register v4l2_device */
664 snprintf(dev->v4l2_dev.name, sizeof(dev->v4l2_dev.name),
665 "%s-%03d", VIVID_MODULE_NAME, inst);
666 ret = v4l2_device_register(&pdev->dev, &dev->v4l2_dev);
671 dev->v4l2_dev.release = vivid_dev_release;
673 /* start detecting feature set */
675 /* do we use single- or multi-planar? */
676 dev->multiplanar = multiplanar[inst] > 1;
677 v4l2_info(&dev->v4l2_dev, "using %splanar format API\n",
678 dev->multiplanar ? "multi" : "single ");
680 /* how many inputs do we have and of what type? */
681 dev->num_inputs = num_inputs[inst];
682 if (dev->num_inputs < 1)
684 if (dev->num_inputs >= MAX_INPUTS)
685 dev->num_inputs = MAX_INPUTS;
686 for (i = 0; i < dev->num_inputs; i++) {
687 dev->input_type[i] = (input_types[inst] >> (i * 2)) & 0x3;
688 dev->input_name_counter[i] = in_type_counter[dev->input_type[i]]++;
690 dev->has_audio_inputs = in_type_counter[TV] && in_type_counter[SVID];
692 /* how many outputs do we have and of what type? */
693 dev->num_outputs = num_outputs[inst];
694 if (dev->num_outputs < 1)
695 dev->num_outputs = 1;
696 if (dev->num_outputs >= MAX_OUTPUTS)
697 dev->num_outputs = MAX_OUTPUTS;
698 for (i = 0; i < dev->num_outputs; i++) {
699 dev->output_type[i] = ((output_types[inst] >> i) & 1) ? HDMI : SVID;
700 dev->output_name_counter[i] = out_type_counter[dev->output_type[i]]++;
702 dev->has_audio_outputs = out_type_counter[SVID];
704 /* do we create a video capture device? */
705 dev->has_vid_cap = node_type & 0x0001;
707 /* do we create a vbi capture device? */
708 if (in_type_counter[TV] || in_type_counter[SVID]) {
709 dev->has_raw_vbi_cap = node_type & 0x0004;
710 dev->has_sliced_vbi_cap = node_type & 0x0008;
711 dev->has_vbi_cap = dev->has_raw_vbi_cap | dev->has_sliced_vbi_cap;
714 /* do we create a video output device? */
715 dev->has_vid_out = node_type & 0x0100;
717 /* do we create a vbi output device? */
718 if (out_type_counter[SVID]) {
719 dev->has_raw_vbi_out = node_type & 0x0400;
720 dev->has_sliced_vbi_out = node_type & 0x0800;
721 dev->has_vbi_out = dev->has_raw_vbi_out | dev->has_sliced_vbi_out;
724 /* do we create a radio receiver device? */
725 dev->has_radio_rx = node_type & 0x0010;
727 /* do we create a radio transmitter device? */
728 dev->has_radio_tx = node_type & 0x1000;
730 /* do we create a software defined radio capture device? */
731 dev->has_sdr_cap = node_type & 0x0020;
733 /* do we have a tuner? */
734 has_tuner = ((dev->has_vid_cap || dev->has_vbi_cap) && in_type_counter[TV]) ||
735 dev->has_radio_rx || dev->has_sdr_cap;
737 /* do we have a modulator? */
738 has_modulator = dev->has_radio_tx;
740 if (dev->has_vid_cap)
741 /* do we have a framebuffer for overlay testing? */
742 dev->has_fb = node_type & 0x10000;
744 /* can we do crop/compose/scaling while capturing? */
745 if (no_error_inj && ccs_cap == -1)
748 /* if ccs_cap == -1, then the use can select it using controls */
750 dev->has_crop_cap = ccs_cap & 1;
751 dev->has_compose_cap = ccs_cap & 2;
752 dev->has_scaler_cap = ccs_cap & 4;
753 v4l2_info(&dev->v4l2_dev, "Capture Crop: %c Compose: %c Scaler: %c\n",
754 dev->has_crop_cap ? 'Y' : 'N',
755 dev->has_compose_cap ? 'Y' : 'N',
756 dev->has_scaler_cap ? 'Y' : 'N');
759 /* can we do crop/compose/scaling with video output? */
760 if (no_error_inj && ccs_out == -1)
763 /* if ccs_out == -1, then the use can select it using controls */
765 dev->has_crop_out = ccs_out & 1;
766 dev->has_compose_out = ccs_out & 2;
767 dev->has_scaler_out = ccs_out & 4;
768 v4l2_info(&dev->v4l2_dev, "Output Crop: %c Compose: %c Scaler: %c\n",
769 dev->has_crop_out ? 'Y' : 'N',
770 dev->has_compose_out ? 'Y' : 'N',
771 dev->has_scaler_out ? 'Y' : 'N');
774 /* end detecting feature set */
776 if (dev->has_vid_cap) {
777 /* set up the capabilities of the video capture device */
778 dev->vid_cap_caps = dev->multiplanar ?
779 V4L2_CAP_VIDEO_CAPTURE_MPLANE :
780 V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_VIDEO_OVERLAY;
781 dev->vid_cap_caps |= V4L2_CAP_STREAMING | V4L2_CAP_READWRITE;
782 if (dev->has_audio_inputs)
783 dev->vid_cap_caps |= V4L2_CAP_AUDIO;
784 if (in_type_counter[TV])
785 dev->vid_cap_caps |= V4L2_CAP_TUNER;
787 if (dev->has_vid_out) {
788 /* set up the capabilities of the video output device */
789 dev->vid_out_caps = dev->multiplanar ?
790 V4L2_CAP_VIDEO_OUTPUT_MPLANE :
791 V4L2_CAP_VIDEO_OUTPUT;
793 dev->vid_out_caps |= V4L2_CAP_VIDEO_OUTPUT_OVERLAY;
794 dev->vid_out_caps |= V4L2_CAP_STREAMING | V4L2_CAP_READWRITE;
795 if (dev->has_audio_outputs)
796 dev->vid_out_caps |= V4L2_CAP_AUDIO;
798 if (dev->has_vbi_cap) {
799 /* set up the capabilities of the vbi capture device */
800 dev->vbi_cap_caps = (dev->has_raw_vbi_cap ? V4L2_CAP_VBI_CAPTURE : 0) |
801 (dev->has_sliced_vbi_cap ? V4L2_CAP_SLICED_VBI_CAPTURE : 0);
802 dev->vbi_cap_caps |= V4L2_CAP_STREAMING | V4L2_CAP_READWRITE;
803 if (dev->has_audio_inputs)
804 dev->vbi_cap_caps |= V4L2_CAP_AUDIO;
805 if (in_type_counter[TV])
806 dev->vbi_cap_caps |= V4L2_CAP_TUNER;
808 if (dev->has_vbi_out) {
809 /* set up the capabilities of the vbi output device */
810 dev->vbi_out_caps = (dev->has_raw_vbi_out ? V4L2_CAP_VBI_OUTPUT : 0) |
811 (dev->has_sliced_vbi_out ? V4L2_CAP_SLICED_VBI_OUTPUT : 0);
812 dev->vbi_out_caps |= V4L2_CAP_STREAMING | V4L2_CAP_READWRITE;
813 if (dev->has_audio_outputs)
814 dev->vbi_out_caps |= V4L2_CAP_AUDIO;
816 if (dev->has_sdr_cap) {
817 /* set up the capabilities of the sdr capture device */
818 dev->sdr_cap_caps = V4L2_CAP_SDR_CAPTURE | V4L2_CAP_TUNER;
819 dev->sdr_cap_caps |= V4L2_CAP_STREAMING | V4L2_CAP_READWRITE;
821 /* set up the capabilities of the radio receiver device */
822 if (dev->has_radio_rx)
823 dev->radio_rx_caps = V4L2_CAP_RADIO | V4L2_CAP_RDS_CAPTURE |
824 V4L2_CAP_HW_FREQ_SEEK | V4L2_CAP_TUNER |
826 /* set up the capabilities of the radio transmitter device */
827 if (dev->has_radio_tx)
828 dev->radio_tx_caps = V4L2_CAP_RDS_OUTPUT | V4L2_CAP_MODULATOR |
831 /* initialize the test pattern generator */
832 tpg_init(&dev->tpg, 640, 360);
833 if (tpg_alloc(&dev->tpg, MAX_ZOOM * MAX_WIDTH))
835 dev->scaled_line = vzalloc(MAX_ZOOM * MAX_WIDTH);
836 if (!dev->scaled_line)
838 dev->blended_line = vzalloc(MAX_ZOOM * MAX_WIDTH);
839 if (!dev->blended_line)
843 dev->edid = vmalloc(256 * 128);
847 /* create a string array containing the names of all the preset timings */
848 while (v4l2_dv_timings_presets[dev->query_dv_timings_size].bt.width)
849 dev->query_dv_timings_size++;
850 dev->query_dv_timings_qmenu = kmalloc(dev->query_dv_timings_size *
851 (sizeof(void *) + 32), GFP_KERNEL);
852 if (dev->query_dv_timings_qmenu == NULL)
854 for (i = 0; i < dev->query_dv_timings_size; i++) {
855 const struct v4l2_bt_timings *bt = &v4l2_dv_timings_presets[i].bt;
856 char *p = (char *)&dev->query_dv_timings_qmenu[dev->query_dv_timings_size];
860 dev->query_dv_timings_qmenu[i] = p;
862 htot = V4L2_DV_BT_FRAME_WIDTH(bt);
863 vtot = V4L2_DV_BT_FRAME_HEIGHT(bt);
864 snprintf(p, 32, "%ux%u%s%u",
865 bt->width, bt->height, bt->interlaced ? "i" : "p",
866 (u32)bt->pixelclock / (htot * vtot));
869 /* disable invalid ioctls based on the feature set */
870 if (!dev->has_audio_inputs) {
871 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_S_AUDIO);
872 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_G_AUDIO);
873 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_ENUMAUDIO);
874 v4l2_disable_ioctl(&dev->vbi_cap_dev, VIDIOC_S_AUDIO);
875 v4l2_disable_ioctl(&dev->vbi_cap_dev, VIDIOC_G_AUDIO);
876 v4l2_disable_ioctl(&dev->vbi_cap_dev, VIDIOC_ENUMAUDIO);
878 if (!dev->has_audio_outputs) {
879 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_S_AUDOUT);
880 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_G_AUDOUT);
881 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_ENUMAUDOUT);
882 v4l2_disable_ioctl(&dev->vbi_out_dev, VIDIOC_S_AUDOUT);
883 v4l2_disable_ioctl(&dev->vbi_out_dev, VIDIOC_G_AUDOUT);
884 v4l2_disable_ioctl(&dev->vbi_out_dev, VIDIOC_ENUMAUDOUT);
886 if (!in_type_counter[TV] && !in_type_counter[SVID]) {
887 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_S_STD);
888 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_G_STD);
889 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_ENUMSTD);
890 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_QUERYSTD);
892 if (!out_type_counter[SVID]) {
893 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_S_STD);
894 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_G_STD);
895 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_ENUMSTD);
897 if (!has_tuner && !has_modulator) {
898 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_S_FREQUENCY);
899 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_G_FREQUENCY);
900 v4l2_disable_ioctl(&dev->vbi_cap_dev, VIDIOC_S_FREQUENCY);
901 v4l2_disable_ioctl(&dev->vbi_cap_dev, VIDIOC_G_FREQUENCY);
904 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_S_TUNER);
905 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_G_TUNER);
906 v4l2_disable_ioctl(&dev->vbi_cap_dev, VIDIOC_S_TUNER);
907 v4l2_disable_ioctl(&dev->vbi_cap_dev, VIDIOC_G_TUNER);
909 if (in_type_counter[HDMI] == 0) {
910 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_S_EDID);
911 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_G_EDID);
912 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_DV_TIMINGS_CAP);
913 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_G_DV_TIMINGS);
914 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_S_DV_TIMINGS);
915 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_ENUM_DV_TIMINGS);
916 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_QUERY_DV_TIMINGS);
918 if (out_type_counter[HDMI] == 0) {
919 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_G_EDID);
920 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_DV_TIMINGS_CAP);
921 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_G_DV_TIMINGS);
922 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_S_DV_TIMINGS);
923 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_ENUM_DV_TIMINGS);
926 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_G_FBUF);
927 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_S_FBUF);
928 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_OVERLAY);
930 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_S_HW_FREQ_SEEK);
931 v4l2_disable_ioctl(&dev->vbi_cap_dev, VIDIOC_S_HW_FREQ_SEEK);
932 v4l2_disable_ioctl(&dev->sdr_cap_dev, VIDIOC_S_HW_FREQ_SEEK);
933 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_S_FREQUENCY);
934 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_G_FREQUENCY);
935 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_ENUM_FRAMESIZES);
936 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_ENUM_FRAMEINTERVALS);
937 v4l2_disable_ioctl(&dev->vbi_out_dev, VIDIOC_S_FREQUENCY);
938 v4l2_disable_ioctl(&dev->vbi_out_dev, VIDIOC_G_FREQUENCY);
940 /* configure internal data */
941 dev->fmt_cap = &vivid_formats[0];
942 dev->fmt_out = &vivid_formats[0];
943 if (!dev->multiplanar)
944 vivid_formats[0].data_offset[0] = 0;
945 dev->webcam_size_idx = 1;
946 dev->webcam_ival_idx = 3;
947 tpg_s_fourcc(&dev->tpg, dev->fmt_cap->fourcc);
948 dev->std_cap = V4L2_STD_PAL;
949 dev->std_out = V4L2_STD_PAL;
950 if (dev->input_type[0] == TV || dev->input_type[0] == SVID)
951 tvnorms_cap = V4L2_STD_ALL;
952 if (dev->output_type[0] == SVID)
953 tvnorms_out = V4L2_STD_ALL;
954 dev->dv_timings_cap = def_dv_timings;
955 dev->dv_timings_out = def_dv_timings;
956 dev->tv_freq = 2804 /* 175.25 * 16 */;
957 dev->tv_audmode = V4L2_TUNER_MODE_STEREO;
958 dev->tv_field_cap = V4L2_FIELD_INTERLACED;
959 dev->tv_field_out = V4L2_FIELD_INTERLACED;
960 dev->radio_rx_freq = 95000 * 16;
961 dev->radio_rx_audmode = V4L2_TUNER_MODE_STEREO;
962 if (dev->has_radio_tx) {
963 dev->radio_tx_freq = 95500 * 16;
964 dev->radio_rds_loop = false;
966 dev->radio_tx_subchans = V4L2_TUNER_SUB_STEREO | V4L2_TUNER_SUB_RDS;
967 dev->sdr_adc_freq = 300000;
968 dev->sdr_fm_freq = 50000000;
969 dev->edid_max_blocks = dev->edid_blocks = 2;
970 memcpy(dev->edid, vivid_hdmi_edid, sizeof(vivid_hdmi_edid));
971 ktime_get_ts(&dev->radio_rds_init_ts);
973 /* create all controls */
974 ret = vivid_create_controls(dev, ccs_cap == -1, ccs_out == -1, no_error_inj,
975 in_type_counter[TV] || in_type_counter[SVID] ||
976 out_type_counter[SVID],
977 in_type_counter[HDMI] || out_type_counter[HDMI]);
982 * update the capture and output formats to do a proper initial
985 vivid_update_format_cap(dev, false);
986 vivid_update_format_out(dev);
988 v4l2_ctrl_handler_setup(&dev->ctrl_hdl_vid_cap);
989 v4l2_ctrl_handler_setup(&dev->ctrl_hdl_vid_out);
990 v4l2_ctrl_handler_setup(&dev->ctrl_hdl_vbi_cap);
991 v4l2_ctrl_handler_setup(&dev->ctrl_hdl_vbi_out);
992 v4l2_ctrl_handler_setup(&dev->ctrl_hdl_radio_rx);
993 v4l2_ctrl_handler_setup(&dev->ctrl_hdl_radio_tx);
994 v4l2_ctrl_handler_setup(&dev->ctrl_hdl_sdr_cap);
996 /* initialize overlay */
997 dev->fb_cap.fmt.width = dev->src_rect.width;
998 dev->fb_cap.fmt.height = dev->src_rect.height;
999 dev->fb_cap.fmt.pixelformat = dev->fmt_cap->fourcc;
1000 dev->fb_cap.fmt.bytesperline = dev->src_rect.width * tpg_g_twopixelsize(&dev->tpg, 0) / 2;
1001 dev->fb_cap.fmt.sizeimage = dev->src_rect.height * dev->fb_cap.fmt.bytesperline;
1003 /* initialize locks */
1004 spin_lock_init(&dev->slock);
1005 mutex_init(&dev->mutex);
1007 /* init dma queues */
1008 INIT_LIST_HEAD(&dev->vid_cap_active);
1009 INIT_LIST_HEAD(&dev->vid_out_active);
1010 INIT_LIST_HEAD(&dev->vbi_cap_active);
1011 INIT_LIST_HEAD(&dev->vbi_out_active);
1012 INIT_LIST_HEAD(&dev->sdr_cap_active);
1014 /* start creating the vb2 queues */
1015 if (dev->has_vid_cap) {
1016 /* initialize vid_cap queue */
1017 q = &dev->vb_vid_cap_q;
1018 q->type = dev->multiplanar ? V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE :
1019 V4L2_BUF_TYPE_VIDEO_CAPTURE;
1020 q->io_modes = VB2_MMAP | VB2_USERPTR | VB2_DMABUF | VB2_READ;
1022 q->buf_struct_size = sizeof(struct vivid_buffer);
1023 q->ops = &vivid_vid_cap_qops;
1024 q->mem_ops = &vb2_vmalloc_memops;
1025 q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1026 q->min_buffers_needed = 2;
1027 q->lock = &dev->mutex;
1029 ret = vb2_queue_init(q);
1034 if (dev->has_vid_out) {
1035 /* initialize vid_out queue */
1036 q = &dev->vb_vid_out_q;
1037 q->type = dev->multiplanar ? V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE :
1038 V4L2_BUF_TYPE_VIDEO_OUTPUT;
1039 q->io_modes = VB2_MMAP | VB2_USERPTR | VB2_DMABUF | VB2_WRITE;
1041 q->buf_struct_size = sizeof(struct vivid_buffer);
1042 q->ops = &vivid_vid_out_qops;
1043 q->mem_ops = &vb2_vmalloc_memops;
1044 q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1045 q->min_buffers_needed = 2;
1046 q->lock = &dev->mutex;
1048 ret = vb2_queue_init(q);
1053 if (dev->has_vbi_cap) {
1054 /* initialize vbi_cap queue */
1055 q = &dev->vb_vbi_cap_q;
1056 q->type = dev->has_raw_vbi_cap ? V4L2_BUF_TYPE_VBI_CAPTURE :
1057 V4L2_BUF_TYPE_SLICED_VBI_CAPTURE;
1058 q->io_modes = VB2_MMAP | VB2_USERPTR | VB2_DMABUF | VB2_READ;
1060 q->buf_struct_size = sizeof(struct vivid_buffer);
1061 q->ops = &vivid_vbi_cap_qops;
1062 q->mem_ops = &vb2_vmalloc_memops;
1063 q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1064 q->min_buffers_needed = 2;
1065 q->lock = &dev->mutex;
1067 ret = vb2_queue_init(q);
1072 if (dev->has_vbi_out) {
1073 /* initialize vbi_out queue */
1074 q = &dev->vb_vbi_out_q;
1075 q->type = dev->has_raw_vbi_out ? V4L2_BUF_TYPE_VBI_OUTPUT :
1076 V4L2_BUF_TYPE_SLICED_VBI_OUTPUT;
1077 q->io_modes = VB2_MMAP | VB2_USERPTR | VB2_DMABUF | VB2_WRITE;
1079 q->buf_struct_size = sizeof(struct vivid_buffer);
1080 q->ops = &vivid_vbi_out_qops;
1081 q->mem_ops = &vb2_vmalloc_memops;
1082 q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1083 q->min_buffers_needed = 2;
1084 q->lock = &dev->mutex;
1086 ret = vb2_queue_init(q);
1091 if (dev->has_sdr_cap) {
1092 /* initialize sdr_cap queue */
1093 q = &dev->vb_sdr_cap_q;
1094 q->type = V4L2_BUF_TYPE_SDR_CAPTURE;
1095 q->io_modes = VB2_MMAP | VB2_USERPTR | VB2_DMABUF | VB2_READ;
1097 q->buf_struct_size = sizeof(struct vivid_buffer);
1098 q->ops = &vivid_sdr_cap_qops;
1099 q->mem_ops = &vb2_vmalloc_memops;
1100 q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1101 q->min_buffers_needed = 8;
1102 q->lock = &dev->mutex;
1104 ret = vb2_queue_init(q);
1110 /* Create framebuffer for testing capture/output overlay */
1111 ret = vivid_fb_init(dev);
1114 v4l2_info(&dev->v4l2_dev, "Framebuffer device registered as fb%d\n",
1118 /* finally start creating the device nodes */
1119 if (dev->has_vid_cap) {
1120 vfd = &dev->vid_cap_dev;
1121 strlcpy(vfd->name, "vivid-vid-cap", sizeof(vfd->name));
1122 vfd->fops = &vivid_fops;
1123 vfd->ioctl_ops = &vivid_ioctl_ops;
1124 vfd->release = video_device_release_empty;
1125 vfd->v4l2_dev = &dev->v4l2_dev;
1126 vfd->queue = &dev->vb_vid_cap_q;
1127 vfd->tvnorms = tvnorms_cap;
1130 * Provide a mutex to v4l2 core. It will be used to protect
1131 * all fops and v4l2 ioctls.
1133 vfd->lock = &dev->mutex;
1134 video_set_drvdata(vfd, dev);
1136 ret = video_register_device(vfd, VFL_TYPE_GRABBER, vid_cap_nr[inst]);
1139 v4l2_info(&dev->v4l2_dev, "V4L2 capture device registered as %s\n",
1140 video_device_node_name(vfd));
1143 if (dev->has_vid_out) {
1144 vfd = &dev->vid_out_dev;
1145 strlcpy(vfd->name, "vivid-vid-out", sizeof(vfd->name));
1146 vfd->vfl_dir = VFL_DIR_TX;
1147 vfd->fops = &vivid_fops;
1148 vfd->ioctl_ops = &vivid_ioctl_ops;
1149 vfd->release = video_device_release_empty;
1150 vfd->v4l2_dev = &dev->v4l2_dev;
1151 vfd->queue = &dev->vb_vid_out_q;
1152 vfd->tvnorms = tvnorms_out;
1155 * Provide a mutex to v4l2 core. It will be used to protect
1156 * all fops and v4l2 ioctls.
1158 vfd->lock = &dev->mutex;
1159 video_set_drvdata(vfd, dev);
1161 ret = video_register_device(vfd, VFL_TYPE_GRABBER, vid_out_nr[inst]);
1164 v4l2_info(&dev->v4l2_dev, "V4L2 output device registered as %s\n",
1165 video_device_node_name(vfd));
1168 if (dev->has_vbi_cap) {
1169 vfd = &dev->vbi_cap_dev;
1170 strlcpy(vfd->name, "vivid-vbi-cap", sizeof(vfd->name));
1171 vfd->fops = &vivid_fops;
1172 vfd->ioctl_ops = &vivid_ioctl_ops;
1173 vfd->release = video_device_release_empty;
1174 vfd->v4l2_dev = &dev->v4l2_dev;
1175 vfd->queue = &dev->vb_vbi_cap_q;
1176 vfd->lock = &dev->mutex;
1177 vfd->tvnorms = tvnorms_cap;
1178 video_set_drvdata(vfd, dev);
1180 ret = video_register_device(vfd, VFL_TYPE_VBI, vbi_cap_nr[inst]);
1183 v4l2_info(&dev->v4l2_dev, "V4L2 capture device registered as %s, supports %s VBI\n",
1184 video_device_node_name(vfd),
1185 (dev->has_raw_vbi_cap && dev->has_sliced_vbi_cap) ?
1187 (dev->has_raw_vbi_cap ? "raw" : "sliced"));
1190 if (dev->has_vbi_out) {
1191 vfd = &dev->vbi_out_dev;
1192 strlcpy(vfd->name, "vivid-vbi-out", sizeof(vfd->name));
1193 vfd->vfl_dir = VFL_DIR_TX;
1194 vfd->fops = &vivid_fops;
1195 vfd->ioctl_ops = &vivid_ioctl_ops;
1196 vfd->release = video_device_release_empty;
1197 vfd->v4l2_dev = &dev->v4l2_dev;
1198 vfd->queue = &dev->vb_vbi_out_q;
1199 vfd->lock = &dev->mutex;
1200 vfd->tvnorms = tvnorms_out;
1201 video_set_drvdata(vfd, dev);
1203 ret = video_register_device(vfd, VFL_TYPE_VBI, vbi_out_nr[inst]);
1206 v4l2_info(&dev->v4l2_dev, "V4L2 output device registered as %s, supports %s VBI\n",
1207 video_device_node_name(vfd),
1208 (dev->has_raw_vbi_out && dev->has_sliced_vbi_out) ?
1210 (dev->has_raw_vbi_out ? "raw" : "sliced"));
1213 if (dev->has_sdr_cap) {
1214 vfd = &dev->sdr_cap_dev;
1215 strlcpy(vfd->name, "vivid-sdr-cap", sizeof(vfd->name));
1216 vfd->fops = &vivid_fops;
1217 vfd->ioctl_ops = &vivid_ioctl_ops;
1218 vfd->release = video_device_release_empty;
1219 vfd->v4l2_dev = &dev->v4l2_dev;
1220 vfd->queue = &dev->vb_sdr_cap_q;
1221 vfd->lock = &dev->mutex;
1222 video_set_drvdata(vfd, dev);
1224 ret = video_register_device(vfd, VFL_TYPE_SDR, sdr_cap_nr[inst]);
1227 v4l2_info(&dev->v4l2_dev, "V4L2 capture device registered as %s\n",
1228 video_device_node_name(vfd));
1231 if (dev->has_radio_rx) {
1232 vfd = &dev->radio_rx_dev;
1233 strlcpy(vfd->name, "vivid-rad-rx", sizeof(vfd->name));
1234 vfd->fops = &vivid_radio_fops;
1235 vfd->ioctl_ops = &vivid_ioctl_ops;
1236 vfd->release = video_device_release_empty;
1237 vfd->v4l2_dev = &dev->v4l2_dev;
1238 vfd->lock = &dev->mutex;
1239 video_set_drvdata(vfd, dev);
1241 ret = video_register_device(vfd, VFL_TYPE_RADIO, radio_rx_nr[inst]);
1244 v4l2_info(&dev->v4l2_dev, "V4L2 receiver device registered as %s\n",
1245 video_device_node_name(vfd));
1248 if (dev->has_radio_tx) {
1249 vfd = &dev->radio_tx_dev;
1250 strlcpy(vfd->name, "vivid-rad-tx", sizeof(vfd->name));
1251 vfd->vfl_dir = VFL_DIR_TX;
1252 vfd->fops = &vivid_radio_fops;
1253 vfd->ioctl_ops = &vivid_ioctl_ops;
1254 vfd->release = video_device_release_empty;
1255 vfd->v4l2_dev = &dev->v4l2_dev;
1256 vfd->lock = &dev->mutex;
1257 video_set_drvdata(vfd, dev);
1259 ret = video_register_device(vfd, VFL_TYPE_RADIO, radio_tx_nr[inst]);
1262 v4l2_info(&dev->v4l2_dev, "V4L2 transmitter device registered as %s\n",
1263 video_device_node_name(vfd));
1266 /* Now that everything is fine, let's add it to device list */
1267 vivid_devs[inst] = dev;
1272 video_unregister_device(&dev->radio_tx_dev);
1273 video_unregister_device(&dev->radio_rx_dev);
1274 video_unregister_device(&dev->sdr_cap_dev);
1275 video_unregister_device(&dev->vbi_out_dev);
1276 video_unregister_device(&dev->vbi_cap_dev);
1277 video_unregister_device(&dev->vid_out_dev);
1278 video_unregister_device(&dev->vid_cap_dev);
1280 v4l2_device_put(&dev->v4l2_dev);
1284 /* This routine allocates from 1 to n_devs virtual drivers.
1286 The real maximum number of virtual drivers will depend on how many drivers
1287 will succeed. This is limited to the maximum number of devices that
1288 videodev supports, which is equal to VIDEO_NUM_DEVICES.
1290 static int vivid_probe(struct platform_device *pdev)
1292 const struct font_desc *font = find_font("VGA8x16");
1296 pr_err("vivid: could not find font\n");
1300 tpg_set_font(font->data);
1302 n_devs = clamp_t(unsigned, n_devs, 1, VIVID_MAX_DEVS);
1304 for (i = 0; i < n_devs; i++) {
1305 ret = vivid_create_instance(pdev, i);
1307 /* If some instantiations succeeded, keep driver */
1315 pr_err("vivid: error %d while loading driver\n", ret);
1319 /* n_devs will reflect the actual number of allocated devices */
1325 static int vivid_remove(struct platform_device *pdev)
1327 struct vivid_dev *dev;
1330 for (i = 0; vivid_devs[i]; i++) {
1331 dev = vivid_devs[i];
1333 if (dev->has_vid_cap) {
1334 v4l2_info(&dev->v4l2_dev, "unregistering %s\n",
1335 video_device_node_name(&dev->vid_cap_dev));
1336 video_unregister_device(&dev->vid_cap_dev);
1338 if (dev->has_vid_out) {
1339 v4l2_info(&dev->v4l2_dev, "unregistering %s\n",
1340 video_device_node_name(&dev->vid_out_dev));
1341 video_unregister_device(&dev->vid_out_dev);
1343 if (dev->has_vbi_cap) {
1344 v4l2_info(&dev->v4l2_dev, "unregistering %s\n",
1345 video_device_node_name(&dev->vbi_cap_dev));
1346 video_unregister_device(&dev->vbi_cap_dev);
1348 if (dev->has_vbi_out) {
1349 v4l2_info(&dev->v4l2_dev, "unregistering %s\n",
1350 video_device_node_name(&dev->vbi_out_dev));
1351 video_unregister_device(&dev->vbi_out_dev);
1353 if (dev->has_sdr_cap) {
1354 v4l2_info(&dev->v4l2_dev, "unregistering %s\n",
1355 video_device_node_name(&dev->sdr_cap_dev));
1356 video_unregister_device(&dev->sdr_cap_dev);
1358 if (dev->has_radio_rx) {
1359 v4l2_info(&dev->v4l2_dev, "unregistering %s\n",
1360 video_device_node_name(&dev->radio_rx_dev));
1361 video_unregister_device(&dev->radio_rx_dev);
1363 if (dev->has_radio_tx) {
1364 v4l2_info(&dev->v4l2_dev, "unregistering %s\n",
1365 video_device_node_name(&dev->radio_tx_dev));
1366 video_unregister_device(&dev->radio_tx_dev);
1369 v4l2_info(&dev->v4l2_dev, "unregistering fb%d\n",
1371 unregister_framebuffer(&dev->fb_info);
1372 vivid_fb_release_buffers(dev);
1374 v4l2_device_put(&dev->v4l2_dev);
1375 vivid_devs[i] = NULL;
1380 static void vivid_pdev_release(struct device *dev)
1384 static struct platform_device vivid_pdev = {
1386 .dev.release = vivid_pdev_release,
1389 static struct platform_driver vivid_pdrv = {
1390 .probe = vivid_probe,
1391 .remove = vivid_remove,
1397 static int __init vivid_init(void)
1401 ret = platform_device_register(&vivid_pdev);
1405 ret = platform_driver_register(&vivid_pdrv);
1407 platform_device_unregister(&vivid_pdev);
1412 static void __exit vivid_exit(void)
1414 platform_driver_unregister(&vivid_pdrv);
1415 platform_device_unregister(&vivid_pdev);
1418 module_init(vivid_init);
1419 module_exit(vivid_exit);