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