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