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
vidioc_querycap(struct file * file,void * priv,struct v4l2_capability * cap)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
vidioc_s_hw_freq_seek(struct file * file,void * fh,const struct v4l2_hw_freq_seek * a)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
vidioc_enum_freq_bands(struct file * file,void * fh,struct v4l2_frequency_band * band)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
vidioc_g_tuner(struct file * file,void * fh,struct v4l2_tuner * vt)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
vidioc_s_tuner(struct file * file,void * fh,const struct v4l2_tuner * vt)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
vidioc_g_frequency(struct file * file,void * fh,struct v4l2_frequency * vf)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
vidioc_s_frequency(struct file * file,void * fh,const struct v4l2_frequency * vf)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
vidioc_overlay(struct file * file,void * fh,unsigned i)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
vidioc_g_fbuf(struct file * file,void * fh,struct v4l2_framebuffer * a)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
vidioc_s_fbuf(struct file * file,void * fh,const struct v4l2_framebuffer * a)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
vidioc_s_std(struct file * file,void * fh,v4l2_std_id id)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
vidioc_s_dv_timings(struct file * file,void * fh,struct v4l2_dv_timings * timings)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
vidioc_g_pixelaspect(struct file * file,void * fh,int type,struct v4l2_fract * f)327 static int vidioc_g_pixelaspect(struct file *file, void *fh,
328 int type, struct v4l2_fract *f)
329 {
330 struct video_device *vdev = video_devdata(file);
331
332 if (vdev->vfl_dir == VFL_DIR_RX)
333 return vivid_vid_cap_g_pixelaspect(file, fh, type, f);
334 return vivid_vid_out_g_pixelaspect(file, fh, type, f);
335 }
336
vidioc_g_selection(struct file * file,void * fh,struct v4l2_selection * sel)337 static int vidioc_g_selection(struct file *file, void *fh,
338 struct v4l2_selection *sel)
339 {
340 struct video_device *vdev = video_devdata(file);
341
342 if (vdev->vfl_dir == VFL_DIR_RX)
343 return vivid_vid_cap_g_selection(file, fh, sel);
344 return vivid_vid_out_g_selection(file, fh, sel);
345 }
346
vidioc_s_selection(struct file * file,void * fh,struct v4l2_selection * sel)347 static int vidioc_s_selection(struct file *file, void *fh,
348 struct v4l2_selection *sel)
349 {
350 struct video_device *vdev = video_devdata(file);
351
352 if (vdev->vfl_dir == VFL_DIR_RX)
353 return vivid_vid_cap_s_selection(file, fh, sel);
354 return vivid_vid_out_s_selection(file, fh, sel);
355 }
356
vidioc_g_parm(struct file * file,void * fh,struct v4l2_streamparm * parm)357 static int vidioc_g_parm(struct file *file, void *fh,
358 struct v4l2_streamparm *parm)
359 {
360 struct video_device *vdev = video_devdata(file);
361
362 if (vdev->vfl_dir == VFL_DIR_RX)
363 return vivid_vid_cap_g_parm(file, fh, parm);
364 return vivid_vid_out_g_parm(file, fh, parm);
365 }
366
vidioc_s_parm(struct file * file,void * fh,struct v4l2_streamparm * parm)367 static int vidioc_s_parm(struct file *file, void *fh,
368 struct v4l2_streamparm *parm)
369 {
370 struct video_device *vdev = video_devdata(file);
371
372 if (vdev->vfl_dir == VFL_DIR_RX)
373 return vivid_vid_cap_s_parm(file, fh, parm);
374 return -ENOTTY;
375 }
376
vidioc_log_status(struct file * file,void * fh)377 static int vidioc_log_status(struct file *file, void *fh)
378 {
379 struct vivid_dev *dev = video_drvdata(file);
380 struct video_device *vdev = video_devdata(file);
381
382 v4l2_ctrl_log_status(file, fh);
383 if (vdev->vfl_dir == VFL_DIR_RX && vdev->vfl_type == VFL_TYPE_GRABBER)
384 tpg_log_status(&dev->tpg);
385 return 0;
386 }
387
vivid_radio_read(struct file * file,char __user * buf,size_t size,loff_t * offset)388 static ssize_t vivid_radio_read(struct file *file, char __user *buf,
389 size_t size, loff_t *offset)
390 {
391 struct video_device *vdev = video_devdata(file);
392
393 if (vdev->vfl_dir == VFL_DIR_TX)
394 return -EINVAL;
395 return vivid_radio_rx_read(file, buf, size, offset);
396 }
397
vivid_radio_write(struct file * file,const char __user * buf,size_t size,loff_t * offset)398 static ssize_t vivid_radio_write(struct file *file, const char __user *buf,
399 size_t size, loff_t *offset)
400 {
401 struct video_device *vdev = video_devdata(file);
402
403 if (vdev->vfl_dir == VFL_DIR_RX)
404 return -EINVAL;
405 return vivid_radio_tx_write(file, buf, size, offset);
406 }
407
vivid_radio_poll(struct file * file,struct poll_table_struct * wait)408 static __poll_t vivid_radio_poll(struct file *file, struct poll_table_struct *wait)
409 {
410 struct video_device *vdev = video_devdata(file);
411
412 if (vdev->vfl_dir == VFL_DIR_RX)
413 return vivid_radio_rx_poll(file, wait);
414 return vivid_radio_tx_poll(file, wait);
415 }
416
vivid_is_in_use(struct video_device * vdev)417 static bool vivid_is_in_use(struct video_device *vdev)
418 {
419 unsigned long flags;
420 bool res;
421
422 spin_lock_irqsave(&vdev->fh_lock, flags);
423 res = !list_empty(&vdev->fh_list);
424 spin_unlock_irqrestore(&vdev->fh_lock, flags);
425 return res;
426 }
427
vivid_is_last_user(struct vivid_dev * dev)428 static bool vivid_is_last_user(struct vivid_dev *dev)
429 {
430 unsigned uses = vivid_is_in_use(&dev->vid_cap_dev) +
431 vivid_is_in_use(&dev->vid_out_dev) +
432 vivid_is_in_use(&dev->vbi_cap_dev) +
433 vivid_is_in_use(&dev->vbi_out_dev) +
434 vivid_is_in_use(&dev->sdr_cap_dev) +
435 vivid_is_in_use(&dev->radio_rx_dev) +
436 vivid_is_in_use(&dev->radio_tx_dev);
437
438 return uses == 1;
439 }
440
vivid_fop_release(struct file * file)441 static int vivid_fop_release(struct file *file)
442 {
443 struct vivid_dev *dev = video_drvdata(file);
444 struct video_device *vdev = video_devdata(file);
445
446 mutex_lock(&dev->mutex);
447 if (!no_error_inj && v4l2_fh_is_singular_file(file) &&
448 !video_is_registered(vdev) && vivid_is_last_user(dev)) {
449 /*
450 * I am the last user of this driver, and a disconnect
451 * was forced (since this video_device is unregistered),
452 * so re-register all video_device's again.
453 */
454 v4l2_info(&dev->v4l2_dev, "reconnect\n");
455 set_bit(V4L2_FL_REGISTERED, &dev->vid_cap_dev.flags);
456 set_bit(V4L2_FL_REGISTERED, &dev->vid_out_dev.flags);
457 set_bit(V4L2_FL_REGISTERED, &dev->vbi_cap_dev.flags);
458 set_bit(V4L2_FL_REGISTERED, &dev->vbi_out_dev.flags);
459 set_bit(V4L2_FL_REGISTERED, &dev->sdr_cap_dev.flags);
460 set_bit(V4L2_FL_REGISTERED, &dev->radio_rx_dev.flags);
461 set_bit(V4L2_FL_REGISTERED, &dev->radio_tx_dev.flags);
462 }
463 mutex_unlock(&dev->mutex);
464 if (file->private_data == dev->overlay_cap_owner)
465 dev->overlay_cap_owner = NULL;
466 if (file->private_data == dev->radio_rx_rds_owner) {
467 dev->radio_rx_rds_last_block = 0;
468 dev->radio_rx_rds_owner = NULL;
469 }
470 if (file->private_data == dev->radio_tx_rds_owner) {
471 dev->radio_tx_rds_last_block = 0;
472 dev->radio_tx_rds_owner = NULL;
473 }
474 if (vdev->queue)
475 return vb2_fop_release(file);
476 return v4l2_fh_release(file);
477 }
478
479 static const struct v4l2_file_operations vivid_fops = {
480 .owner = THIS_MODULE,
481 .open = v4l2_fh_open,
482 .release = vivid_fop_release,
483 .read = vb2_fop_read,
484 .write = vb2_fop_write,
485 .poll = vb2_fop_poll,
486 .unlocked_ioctl = video_ioctl2,
487 .mmap = vb2_fop_mmap,
488 };
489
490 static const struct v4l2_file_operations vivid_radio_fops = {
491 .owner = THIS_MODULE,
492 .open = v4l2_fh_open,
493 .release = vivid_fop_release,
494 .read = vivid_radio_read,
495 .write = vivid_radio_write,
496 .poll = vivid_radio_poll,
497 .unlocked_ioctl = video_ioctl2,
498 };
499
500 static const struct v4l2_ioctl_ops vivid_ioctl_ops = {
501 .vidioc_querycap = vidioc_querycap,
502
503 .vidioc_enum_fmt_vid_cap = vivid_enum_fmt_vid,
504 .vidioc_g_fmt_vid_cap = vidioc_g_fmt_vid_cap,
505 .vidioc_try_fmt_vid_cap = vidioc_try_fmt_vid_cap,
506 .vidioc_s_fmt_vid_cap = vidioc_s_fmt_vid_cap,
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 = vivid_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_g_fmt_vid_out_mplane = vidioc_g_fmt_vid_out_mplane,
516 .vidioc_try_fmt_vid_out_mplane = vidioc_try_fmt_vid_out_mplane,
517 .vidioc_s_fmt_vid_out_mplane = vidioc_s_fmt_vid_out_mplane,
518
519 .vidioc_g_selection = vidioc_g_selection,
520 .vidioc_s_selection = vidioc_s_selection,
521 .vidioc_g_pixelaspect = vidioc_g_pixelaspect,
522
523 .vidioc_g_fmt_vbi_cap = vidioc_g_fmt_vbi_cap,
524 .vidioc_try_fmt_vbi_cap = vidioc_g_fmt_vbi_cap,
525 .vidioc_s_fmt_vbi_cap = vidioc_s_fmt_vbi_cap,
526
527 .vidioc_g_fmt_sliced_vbi_cap = vidioc_g_fmt_sliced_vbi_cap,
528 .vidioc_try_fmt_sliced_vbi_cap = vidioc_try_fmt_sliced_vbi_cap,
529 .vidioc_s_fmt_sliced_vbi_cap = vidioc_s_fmt_sliced_vbi_cap,
530 .vidioc_g_sliced_vbi_cap = vidioc_g_sliced_vbi_cap,
531
532 .vidioc_g_fmt_vbi_out = vidioc_g_fmt_vbi_out,
533 .vidioc_try_fmt_vbi_out = vidioc_g_fmt_vbi_out,
534 .vidioc_s_fmt_vbi_out = vidioc_s_fmt_vbi_out,
535
536 .vidioc_g_fmt_sliced_vbi_out = vidioc_g_fmt_sliced_vbi_out,
537 .vidioc_try_fmt_sliced_vbi_out = vidioc_try_fmt_sliced_vbi_out,
538 .vidioc_s_fmt_sliced_vbi_out = vidioc_s_fmt_sliced_vbi_out,
539
540 .vidioc_enum_fmt_sdr_cap = vidioc_enum_fmt_sdr_cap,
541 .vidioc_g_fmt_sdr_cap = vidioc_g_fmt_sdr_cap,
542 .vidioc_try_fmt_sdr_cap = vidioc_try_fmt_sdr_cap,
543 .vidioc_s_fmt_sdr_cap = vidioc_s_fmt_sdr_cap,
544
545 .vidioc_overlay = vidioc_overlay,
546 .vidioc_enum_framesizes = vidioc_enum_framesizes,
547 .vidioc_enum_frameintervals = vidioc_enum_frameintervals,
548 .vidioc_g_parm = vidioc_g_parm,
549 .vidioc_s_parm = vidioc_s_parm,
550
551 .vidioc_enum_fmt_vid_overlay = vidioc_enum_fmt_vid_overlay,
552 .vidioc_g_fmt_vid_overlay = vidioc_g_fmt_vid_overlay,
553 .vidioc_try_fmt_vid_overlay = vidioc_try_fmt_vid_overlay,
554 .vidioc_s_fmt_vid_overlay = vidioc_s_fmt_vid_overlay,
555 .vidioc_g_fmt_vid_out_overlay = vidioc_g_fmt_vid_out_overlay,
556 .vidioc_try_fmt_vid_out_overlay = vidioc_try_fmt_vid_out_overlay,
557 .vidioc_s_fmt_vid_out_overlay = vidioc_s_fmt_vid_out_overlay,
558 .vidioc_g_fbuf = vidioc_g_fbuf,
559 .vidioc_s_fbuf = vidioc_s_fbuf,
560
561 .vidioc_reqbufs = vb2_ioctl_reqbufs,
562 .vidioc_create_bufs = vb2_ioctl_create_bufs,
563 .vidioc_prepare_buf = vb2_ioctl_prepare_buf,
564 .vidioc_querybuf = vb2_ioctl_querybuf,
565 .vidioc_qbuf = vb2_ioctl_qbuf,
566 .vidioc_dqbuf = vb2_ioctl_dqbuf,
567 .vidioc_expbuf = vb2_ioctl_expbuf,
568 .vidioc_streamon = vb2_ioctl_streamon,
569 .vidioc_streamoff = vb2_ioctl_streamoff,
570
571 .vidioc_enum_input = vidioc_enum_input,
572 .vidioc_g_input = vidioc_g_input,
573 .vidioc_s_input = vidioc_s_input,
574 .vidioc_s_audio = vidioc_s_audio,
575 .vidioc_g_audio = vidioc_g_audio,
576 .vidioc_enumaudio = vidioc_enumaudio,
577 .vidioc_s_frequency = vidioc_s_frequency,
578 .vidioc_g_frequency = vidioc_g_frequency,
579 .vidioc_s_tuner = vidioc_s_tuner,
580 .vidioc_g_tuner = vidioc_g_tuner,
581 .vidioc_s_modulator = vidioc_s_modulator,
582 .vidioc_g_modulator = vidioc_g_modulator,
583 .vidioc_s_hw_freq_seek = vidioc_s_hw_freq_seek,
584 .vidioc_enum_freq_bands = vidioc_enum_freq_bands,
585
586 .vidioc_enum_output = vidioc_enum_output,
587 .vidioc_g_output = vidioc_g_output,
588 .vidioc_s_output = vidioc_s_output,
589 .vidioc_s_audout = vidioc_s_audout,
590 .vidioc_g_audout = vidioc_g_audout,
591 .vidioc_enumaudout = vidioc_enumaudout,
592
593 .vidioc_querystd = vidioc_querystd,
594 .vidioc_g_std = vidioc_g_std,
595 .vidioc_s_std = vidioc_s_std,
596 .vidioc_s_dv_timings = vidioc_s_dv_timings,
597 .vidioc_g_dv_timings = vidioc_g_dv_timings,
598 .vidioc_query_dv_timings = vidioc_query_dv_timings,
599 .vidioc_enum_dv_timings = vidioc_enum_dv_timings,
600 .vidioc_dv_timings_cap = vidioc_dv_timings_cap,
601 .vidioc_g_edid = vidioc_g_edid,
602 .vidioc_s_edid = vidioc_s_edid,
603
604 .vidioc_log_status = vidioc_log_status,
605 .vidioc_subscribe_event = vidioc_subscribe_event,
606 .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
607 };
608
609 /* -----------------------------------------------------------------
610 Initialization and module stuff
611 ------------------------------------------------------------------*/
612
vivid_dev_release(struct v4l2_device * v4l2_dev)613 static void vivid_dev_release(struct v4l2_device *v4l2_dev)
614 {
615 struct vivid_dev *dev = container_of(v4l2_dev, struct vivid_dev, v4l2_dev);
616
617 vivid_free_controls(dev);
618 v4l2_device_unregister(&dev->v4l2_dev);
619 vfree(dev->scaled_line);
620 vfree(dev->blended_line);
621 vfree(dev->edid);
622 vfree(dev->bitmap_cap);
623 vfree(dev->bitmap_out);
624 tpg_free(&dev->tpg);
625 kfree(dev->query_dv_timings_qmenu);
626 kfree(dev->query_dv_timings_qmenu_strings);
627 kfree(dev);
628 }
629
630 #ifdef CONFIG_MEDIA_CONTROLLER
vivid_req_validate(struct media_request * req)631 static int vivid_req_validate(struct media_request *req)
632 {
633 struct vivid_dev *dev = container_of(req->mdev, struct vivid_dev, mdev);
634
635 if (dev->req_validate_error) {
636 dev->req_validate_error = false;
637 return -EINVAL;
638 }
639 return vb2_request_validate(req);
640 }
641
642 static const struct media_device_ops vivid_media_ops = {
643 .req_validate = vivid_req_validate,
644 .req_queue = vb2_request_queue,
645 };
646 #endif
647
vivid_create_instance(struct platform_device * pdev,int inst)648 static int vivid_create_instance(struct platform_device *pdev, int inst)
649 {
650 static const struct v4l2_dv_timings def_dv_timings =
651 V4L2_DV_BT_CEA_1280X720P60;
652 static const struct vb2_mem_ops * const vivid_mem_ops[2] = {
653 &vb2_vmalloc_memops,
654 &vb2_dma_contig_memops,
655 };
656 unsigned in_type_counter[4] = { 0, 0, 0, 0 };
657 unsigned out_type_counter[4] = { 0, 0, 0, 0 };
658 int ccs_cap = ccs_cap_mode[inst];
659 int ccs_out = ccs_out_mode[inst];
660 bool has_tuner;
661 bool has_modulator;
662 struct vivid_dev *dev;
663 struct video_device *vfd;
664 struct vb2_queue *q;
665 unsigned node_type = node_types[inst];
666 unsigned int allocator = allocators[inst];
667 v4l2_std_id tvnorms_cap = 0, tvnorms_out = 0;
668 int ret;
669 int i;
670 #ifdef CONFIG_VIDEO_VIVID_CEC
671 unsigned int cec_tx_bus_cnt = 0;
672 #endif
673
674 /* allocate main vivid state structure */
675 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
676 if (!dev)
677 return -ENOMEM;
678
679 dev->inst = inst;
680
681 #ifdef CONFIG_MEDIA_CONTROLLER
682 dev->v4l2_dev.mdev = &dev->mdev;
683
684 /* Initialize media device */
685 strscpy(dev->mdev.model, VIVID_MODULE_NAME, sizeof(dev->mdev.model));
686 snprintf(dev->mdev.bus_info, sizeof(dev->mdev.bus_info),
687 "platform:%s-%03d", VIVID_MODULE_NAME, inst);
688 dev->mdev.dev = &pdev->dev;
689 media_device_init(&dev->mdev);
690 dev->mdev.ops = &vivid_media_ops;
691 #endif
692
693 /* register v4l2_device */
694 snprintf(dev->v4l2_dev.name, sizeof(dev->v4l2_dev.name),
695 "%s-%03d", VIVID_MODULE_NAME, inst);
696 ret = v4l2_device_register(&pdev->dev, &dev->v4l2_dev);
697 if (ret) {
698 kfree(dev);
699 return ret;
700 }
701 dev->v4l2_dev.release = vivid_dev_release;
702
703 /* start detecting feature set */
704
705 /* do we use single- or multi-planar? */
706 dev->multiplanar = multiplanar[inst] > 1;
707 v4l2_info(&dev->v4l2_dev, "using %splanar format API\n",
708 dev->multiplanar ? "multi" : "single ");
709
710 /* how many inputs do we have and of what type? */
711 dev->num_inputs = num_inputs[inst];
712 if (dev->num_inputs < 1)
713 dev->num_inputs = 1;
714 if (dev->num_inputs >= MAX_INPUTS)
715 dev->num_inputs = MAX_INPUTS;
716 for (i = 0; i < dev->num_inputs; i++) {
717 dev->input_type[i] = (input_types[inst] >> (i * 2)) & 0x3;
718 dev->input_name_counter[i] = in_type_counter[dev->input_type[i]]++;
719 }
720 dev->has_audio_inputs = in_type_counter[TV] && in_type_counter[SVID];
721 if (in_type_counter[HDMI] == 16) {
722 /* The CEC physical address only allows for max 15 inputs */
723 in_type_counter[HDMI]--;
724 dev->num_inputs--;
725 }
726 dev->num_hdmi_inputs = in_type_counter[HDMI];
727
728 /* how many outputs do we have and of what type? */
729 dev->num_outputs = num_outputs[inst];
730 if (dev->num_outputs < 1)
731 dev->num_outputs = 1;
732 if (dev->num_outputs >= MAX_OUTPUTS)
733 dev->num_outputs = MAX_OUTPUTS;
734 for (i = 0; i < dev->num_outputs; i++) {
735 dev->output_type[i] = ((output_types[inst] >> i) & 1) ? HDMI : SVID;
736 dev->output_name_counter[i] = out_type_counter[dev->output_type[i]]++;
737 dev->display_present[i] = true;
738 }
739 dev->has_audio_outputs = out_type_counter[SVID];
740 if (out_type_counter[HDMI] == 16) {
741 /*
742 * The CEC physical address only allows for max 15 inputs,
743 * so outputs are also limited to 15 to allow for easy
744 * CEC output to input mapping.
745 */
746 out_type_counter[HDMI]--;
747 dev->num_outputs--;
748 }
749 dev->num_hdmi_outputs = out_type_counter[HDMI];
750
751 /* do we create a video capture device? */
752 dev->has_vid_cap = node_type & 0x0001;
753
754 /* do we create a vbi capture device? */
755 if (in_type_counter[TV] || in_type_counter[SVID]) {
756 dev->has_raw_vbi_cap = node_type & 0x0004;
757 dev->has_sliced_vbi_cap = node_type & 0x0008;
758 dev->has_vbi_cap = dev->has_raw_vbi_cap | dev->has_sliced_vbi_cap;
759 }
760
761 /* do we create a video output device? */
762 dev->has_vid_out = node_type & 0x0100;
763
764 /* do we create a vbi output device? */
765 if (out_type_counter[SVID]) {
766 dev->has_raw_vbi_out = node_type & 0x0400;
767 dev->has_sliced_vbi_out = node_type & 0x0800;
768 dev->has_vbi_out = dev->has_raw_vbi_out | dev->has_sliced_vbi_out;
769 }
770
771 /* do we create a radio receiver device? */
772 dev->has_radio_rx = node_type & 0x0010;
773
774 /* do we create a radio transmitter device? */
775 dev->has_radio_tx = node_type & 0x1000;
776
777 /* do we create a software defined radio capture device? */
778 dev->has_sdr_cap = node_type & 0x0020;
779
780 /* do we have a tuner? */
781 has_tuner = ((dev->has_vid_cap || dev->has_vbi_cap) && in_type_counter[TV]) ||
782 dev->has_radio_rx || dev->has_sdr_cap;
783
784 /* do we have a modulator? */
785 has_modulator = dev->has_radio_tx;
786
787 if (dev->has_vid_cap)
788 /* do we have a framebuffer for overlay testing? */
789 dev->has_fb = node_type & 0x10000;
790
791 /* can we do crop/compose/scaling while capturing? */
792 if (no_error_inj && ccs_cap == -1)
793 ccs_cap = 7;
794
795 /* if ccs_cap == -1, then the user can select it using controls */
796 if (ccs_cap != -1) {
797 dev->has_crop_cap = ccs_cap & 1;
798 dev->has_compose_cap = ccs_cap & 2;
799 dev->has_scaler_cap = ccs_cap & 4;
800 v4l2_info(&dev->v4l2_dev, "Capture Crop: %c Compose: %c Scaler: %c\n",
801 dev->has_crop_cap ? 'Y' : 'N',
802 dev->has_compose_cap ? 'Y' : 'N',
803 dev->has_scaler_cap ? 'Y' : 'N');
804 }
805
806 /* can we do crop/compose/scaling with video output? */
807 if (no_error_inj && ccs_out == -1)
808 ccs_out = 7;
809
810 /* if ccs_out == -1, then the user can select it using controls */
811 if (ccs_out != -1) {
812 dev->has_crop_out = ccs_out & 1;
813 dev->has_compose_out = ccs_out & 2;
814 dev->has_scaler_out = ccs_out & 4;
815 v4l2_info(&dev->v4l2_dev, "Output Crop: %c Compose: %c Scaler: %c\n",
816 dev->has_crop_out ? 'Y' : 'N',
817 dev->has_compose_out ? 'Y' : 'N',
818 dev->has_scaler_out ? 'Y' : 'N');
819 }
820
821 /* end detecting feature set */
822
823 if (dev->has_vid_cap) {
824 /* set up the capabilities of the video capture device */
825 dev->vid_cap_caps = dev->multiplanar ?
826 V4L2_CAP_VIDEO_CAPTURE_MPLANE :
827 V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_VIDEO_OVERLAY;
828 dev->vid_cap_caps |= V4L2_CAP_STREAMING | V4L2_CAP_READWRITE;
829 if (dev->has_audio_inputs)
830 dev->vid_cap_caps |= V4L2_CAP_AUDIO;
831 if (in_type_counter[TV])
832 dev->vid_cap_caps |= V4L2_CAP_TUNER;
833 }
834 if (dev->has_vid_out) {
835 /* set up the capabilities of the video output device */
836 dev->vid_out_caps = dev->multiplanar ?
837 V4L2_CAP_VIDEO_OUTPUT_MPLANE :
838 V4L2_CAP_VIDEO_OUTPUT;
839 if (dev->has_fb)
840 dev->vid_out_caps |= V4L2_CAP_VIDEO_OUTPUT_OVERLAY;
841 dev->vid_out_caps |= V4L2_CAP_STREAMING | V4L2_CAP_READWRITE;
842 if (dev->has_audio_outputs)
843 dev->vid_out_caps |= V4L2_CAP_AUDIO;
844 }
845 if (dev->has_vbi_cap) {
846 /* set up the capabilities of the vbi capture device */
847 dev->vbi_cap_caps = (dev->has_raw_vbi_cap ? V4L2_CAP_VBI_CAPTURE : 0) |
848 (dev->has_sliced_vbi_cap ? V4L2_CAP_SLICED_VBI_CAPTURE : 0);
849 dev->vbi_cap_caps |= V4L2_CAP_STREAMING | V4L2_CAP_READWRITE;
850 if (dev->has_audio_inputs)
851 dev->vbi_cap_caps |= V4L2_CAP_AUDIO;
852 if (in_type_counter[TV])
853 dev->vbi_cap_caps |= V4L2_CAP_TUNER;
854 }
855 if (dev->has_vbi_out) {
856 /* set up the capabilities of the vbi output device */
857 dev->vbi_out_caps = (dev->has_raw_vbi_out ? V4L2_CAP_VBI_OUTPUT : 0) |
858 (dev->has_sliced_vbi_out ? V4L2_CAP_SLICED_VBI_OUTPUT : 0);
859 dev->vbi_out_caps |= V4L2_CAP_STREAMING | V4L2_CAP_READWRITE;
860 if (dev->has_audio_outputs)
861 dev->vbi_out_caps |= V4L2_CAP_AUDIO;
862 }
863 if (dev->has_sdr_cap) {
864 /* set up the capabilities of the sdr capture device */
865 dev->sdr_cap_caps = V4L2_CAP_SDR_CAPTURE | V4L2_CAP_TUNER;
866 dev->sdr_cap_caps |= V4L2_CAP_STREAMING | V4L2_CAP_READWRITE;
867 }
868 /* set up the capabilities of the radio receiver device */
869 if (dev->has_radio_rx)
870 dev->radio_rx_caps = V4L2_CAP_RADIO | V4L2_CAP_RDS_CAPTURE |
871 V4L2_CAP_HW_FREQ_SEEK | V4L2_CAP_TUNER |
872 V4L2_CAP_READWRITE;
873 /* set up the capabilities of the radio transmitter device */
874 if (dev->has_radio_tx)
875 dev->radio_tx_caps = V4L2_CAP_RDS_OUTPUT | V4L2_CAP_MODULATOR |
876 V4L2_CAP_READWRITE;
877
878 ret = -ENOMEM;
879 /* initialize the test pattern generator */
880 tpg_init(&dev->tpg, 640, 360);
881 if (tpg_alloc(&dev->tpg, MAX_ZOOM * MAX_WIDTH))
882 goto free_dev;
883 dev->scaled_line = vzalloc(array_size(MAX_WIDTH, MAX_ZOOM));
884 if (!dev->scaled_line)
885 goto free_dev;
886 dev->blended_line = vzalloc(array_size(MAX_WIDTH, MAX_ZOOM));
887 if (!dev->blended_line)
888 goto free_dev;
889
890 /* load the edid */
891 dev->edid = vmalloc(256 * 128);
892 if (!dev->edid)
893 goto free_dev;
894
895 while (v4l2_dv_timings_presets[dev->query_dv_timings_size].bt.width)
896 dev->query_dv_timings_size++;
897
898 /*
899 * Create a char pointer array that points to the names of all the
900 * preset timings
901 */
902 dev->query_dv_timings_qmenu = kmalloc_array(dev->query_dv_timings_size,
903 sizeof(char *), GFP_KERNEL);
904 /*
905 * Create a string array containing the names of all the preset
906 * timings. Each name is max 31 chars long (+ terminating 0).
907 */
908 dev->query_dv_timings_qmenu_strings =
909 kmalloc_array(dev->query_dv_timings_size, 32, GFP_KERNEL);
910
911 if (!dev->query_dv_timings_qmenu ||
912 !dev->query_dv_timings_qmenu_strings)
913 goto free_dev;
914
915 for (i = 0; i < dev->query_dv_timings_size; i++) {
916 const struct v4l2_bt_timings *bt = &v4l2_dv_timings_presets[i].bt;
917 char *p = dev->query_dv_timings_qmenu_strings + i * 32;
918 u32 htot, vtot;
919
920 dev->query_dv_timings_qmenu[i] = p;
921
922 htot = V4L2_DV_BT_FRAME_WIDTH(bt);
923 vtot = V4L2_DV_BT_FRAME_HEIGHT(bt);
924 snprintf(p, 32, "%ux%u%s%u",
925 bt->width, bt->height, bt->interlaced ? "i" : "p",
926 (u32)bt->pixelclock / (htot * vtot));
927 }
928
929 /* disable invalid ioctls based on the feature set */
930 if (!dev->has_audio_inputs) {
931 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_S_AUDIO);
932 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_G_AUDIO);
933 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_ENUMAUDIO);
934 v4l2_disable_ioctl(&dev->vbi_cap_dev, VIDIOC_S_AUDIO);
935 v4l2_disable_ioctl(&dev->vbi_cap_dev, VIDIOC_G_AUDIO);
936 v4l2_disable_ioctl(&dev->vbi_cap_dev, VIDIOC_ENUMAUDIO);
937 }
938 if (!dev->has_audio_outputs) {
939 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_S_AUDOUT);
940 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_G_AUDOUT);
941 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_ENUMAUDOUT);
942 v4l2_disable_ioctl(&dev->vbi_out_dev, VIDIOC_S_AUDOUT);
943 v4l2_disable_ioctl(&dev->vbi_out_dev, VIDIOC_G_AUDOUT);
944 v4l2_disable_ioctl(&dev->vbi_out_dev, VIDIOC_ENUMAUDOUT);
945 }
946 if (!in_type_counter[TV] && !in_type_counter[SVID]) {
947 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_S_STD);
948 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_G_STD);
949 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_ENUMSTD);
950 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_QUERYSTD);
951 }
952 if (!out_type_counter[SVID]) {
953 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_S_STD);
954 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_G_STD);
955 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_ENUMSTD);
956 }
957 if (!has_tuner && !has_modulator) {
958 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_S_FREQUENCY);
959 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_G_FREQUENCY);
960 v4l2_disable_ioctl(&dev->vbi_cap_dev, VIDIOC_S_FREQUENCY);
961 v4l2_disable_ioctl(&dev->vbi_cap_dev, VIDIOC_G_FREQUENCY);
962 }
963 if (!has_tuner) {
964 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_S_TUNER);
965 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_G_TUNER);
966 v4l2_disable_ioctl(&dev->vbi_cap_dev, VIDIOC_S_TUNER);
967 v4l2_disable_ioctl(&dev->vbi_cap_dev, VIDIOC_G_TUNER);
968 }
969 if (in_type_counter[HDMI] == 0) {
970 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_S_EDID);
971 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_G_EDID);
972 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_DV_TIMINGS_CAP);
973 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_G_DV_TIMINGS);
974 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_S_DV_TIMINGS);
975 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_ENUM_DV_TIMINGS);
976 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_QUERY_DV_TIMINGS);
977 }
978 if (out_type_counter[HDMI] == 0) {
979 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_G_EDID);
980 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_DV_TIMINGS_CAP);
981 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_G_DV_TIMINGS);
982 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_S_DV_TIMINGS);
983 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_ENUM_DV_TIMINGS);
984 }
985 if (!dev->has_fb) {
986 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_G_FBUF);
987 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_S_FBUF);
988 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_OVERLAY);
989 }
990 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_S_HW_FREQ_SEEK);
991 v4l2_disable_ioctl(&dev->vbi_cap_dev, VIDIOC_S_HW_FREQ_SEEK);
992 v4l2_disable_ioctl(&dev->sdr_cap_dev, VIDIOC_S_HW_FREQ_SEEK);
993 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_S_FREQUENCY);
994 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_G_FREQUENCY);
995 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_ENUM_FRAMESIZES);
996 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_ENUM_FRAMEINTERVALS);
997 v4l2_disable_ioctl(&dev->vbi_out_dev, VIDIOC_S_FREQUENCY);
998 v4l2_disable_ioctl(&dev->vbi_out_dev, VIDIOC_G_FREQUENCY);
999
1000 /* configure internal data */
1001 dev->fmt_cap = &vivid_formats[0];
1002 dev->fmt_out = &vivid_formats[0];
1003 if (!dev->multiplanar)
1004 vivid_formats[0].data_offset[0] = 0;
1005 dev->webcam_size_idx = 1;
1006 dev->webcam_ival_idx = 3;
1007 tpg_s_fourcc(&dev->tpg, dev->fmt_cap->fourcc);
1008 dev->std_out = V4L2_STD_PAL;
1009 if (dev->input_type[0] == TV || dev->input_type[0] == SVID)
1010 tvnorms_cap = V4L2_STD_ALL;
1011 if (dev->output_type[0] == SVID)
1012 tvnorms_out = V4L2_STD_ALL;
1013 for (i = 0; i < MAX_INPUTS; i++) {
1014 dev->dv_timings_cap[i] = def_dv_timings;
1015 dev->std_cap[i] = V4L2_STD_PAL;
1016 }
1017 dev->dv_timings_out = def_dv_timings;
1018 dev->tv_freq = 2804 /* 175.25 * 16 */;
1019 dev->tv_audmode = V4L2_TUNER_MODE_STEREO;
1020 dev->tv_field_cap = V4L2_FIELD_INTERLACED;
1021 dev->tv_field_out = V4L2_FIELD_INTERLACED;
1022 dev->radio_rx_freq = 95000 * 16;
1023 dev->radio_rx_audmode = V4L2_TUNER_MODE_STEREO;
1024 if (dev->has_radio_tx) {
1025 dev->radio_tx_freq = 95500 * 16;
1026 dev->radio_rds_loop = false;
1027 }
1028 dev->radio_tx_subchans = V4L2_TUNER_SUB_STEREO | V4L2_TUNER_SUB_RDS;
1029 dev->sdr_adc_freq = 300000;
1030 dev->sdr_fm_freq = 50000000;
1031 dev->sdr_pixelformat = V4L2_SDR_FMT_CU8;
1032 dev->sdr_buffersize = SDR_CAP_SAMPLES_PER_BUF * 2;
1033
1034 dev->edid_max_blocks = dev->edid_blocks = 2;
1035 memcpy(dev->edid, vivid_hdmi_edid, sizeof(vivid_hdmi_edid));
1036 dev->radio_rds_init_time = ktime_get();
1037
1038 /* create all controls */
1039 ret = vivid_create_controls(dev, ccs_cap == -1, ccs_out == -1, no_error_inj,
1040 in_type_counter[TV] || in_type_counter[SVID] ||
1041 out_type_counter[SVID],
1042 in_type_counter[HDMI] || out_type_counter[HDMI]);
1043 if (ret)
1044 goto unreg_dev;
1045
1046 /* enable/disable interface specific controls */
1047 if (dev->num_outputs && dev->output_type[0] != HDMI)
1048 v4l2_ctrl_activate(dev->ctrl_display_present, false);
1049 if (dev->num_inputs && dev->input_type[0] != HDMI) {
1050 v4l2_ctrl_activate(dev->ctrl_dv_timings_signal_mode, false);
1051 v4l2_ctrl_activate(dev->ctrl_dv_timings, false);
1052 } else if (dev->num_inputs && dev->input_type[0] == HDMI) {
1053 v4l2_ctrl_activate(dev->ctrl_std_signal_mode, false);
1054 v4l2_ctrl_activate(dev->ctrl_standard, false);
1055 }
1056
1057 /*
1058 * update the capture and output formats to do a proper initial
1059 * configuration.
1060 */
1061 vivid_update_format_cap(dev, false);
1062 vivid_update_format_out(dev);
1063
1064 /* initialize overlay */
1065 dev->fb_cap.fmt.width = dev->src_rect.width;
1066 dev->fb_cap.fmt.height = dev->src_rect.height;
1067 dev->fb_cap.fmt.pixelformat = dev->fmt_cap->fourcc;
1068 dev->fb_cap.fmt.bytesperline = dev->src_rect.width * tpg_g_twopixelsize(&dev->tpg, 0) / 2;
1069 dev->fb_cap.fmt.sizeimage = dev->src_rect.height * dev->fb_cap.fmt.bytesperline;
1070
1071 /* initialize locks */
1072 spin_lock_init(&dev->slock);
1073 mutex_init(&dev->mutex);
1074
1075 /* init dma queues */
1076 INIT_LIST_HEAD(&dev->vid_cap_active);
1077 INIT_LIST_HEAD(&dev->vid_out_active);
1078 INIT_LIST_HEAD(&dev->vbi_cap_active);
1079 INIT_LIST_HEAD(&dev->vbi_out_active);
1080 INIT_LIST_HEAD(&dev->sdr_cap_active);
1081
1082 INIT_LIST_HEAD(&dev->cec_work_list);
1083 spin_lock_init(&dev->cec_slock);
1084 /*
1085 * Same as create_singlethread_workqueue, but now I can use the
1086 * string formatting of alloc_ordered_workqueue.
1087 */
1088 dev->cec_workqueue =
1089 alloc_ordered_workqueue("vivid-%03d-cec", WQ_MEM_RECLAIM, inst);
1090 if (!dev->cec_workqueue) {
1091 ret = -ENOMEM;
1092 goto unreg_dev;
1093 }
1094
1095 if (allocator == 1)
1096 dma_coerce_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32));
1097 else if (allocator >= ARRAY_SIZE(vivid_mem_ops))
1098 allocator = 0;
1099
1100 /* start creating the vb2 queues */
1101 if (dev->has_vid_cap) {
1102 snprintf(dev->vid_cap_dev.name, sizeof(dev->vid_cap_dev.name),
1103 "vivid-%03d-vid-cap", inst);
1104 /* initialize vid_cap queue */
1105 q = &dev->vb_vid_cap_q;
1106 q->type = dev->multiplanar ? V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE :
1107 V4L2_BUF_TYPE_VIDEO_CAPTURE;
1108 q->io_modes = VB2_MMAP | VB2_DMABUF | VB2_READ;
1109 if (!allocator)
1110 q->io_modes |= VB2_USERPTR;
1111 q->drv_priv = dev;
1112 q->buf_struct_size = sizeof(struct vivid_buffer);
1113 q->ops = &vivid_vid_cap_qops;
1114 q->mem_ops = vivid_mem_ops[allocator];
1115 q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1116 q->min_buffers_needed = 2;
1117 q->lock = &dev->mutex;
1118 q->dev = dev->v4l2_dev.dev;
1119 q->supports_requests = true;
1120
1121 ret = vb2_queue_init(q);
1122 if (ret)
1123 goto unreg_dev;
1124 }
1125
1126 if (dev->has_vid_out) {
1127 snprintf(dev->vid_out_dev.name, sizeof(dev->vid_out_dev.name),
1128 "vivid-%03d-vid-out", inst);
1129 /* initialize vid_out queue */
1130 q = &dev->vb_vid_out_q;
1131 q->type = dev->multiplanar ? V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE :
1132 V4L2_BUF_TYPE_VIDEO_OUTPUT;
1133 q->io_modes = VB2_MMAP | VB2_DMABUF | VB2_WRITE;
1134 if (!allocator)
1135 q->io_modes |= VB2_USERPTR;
1136 q->drv_priv = dev;
1137 q->buf_struct_size = sizeof(struct vivid_buffer);
1138 q->ops = &vivid_vid_out_qops;
1139 q->mem_ops = vivid_mem_ops[allocator];
1140 q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1141 q->min_buffers_needed = 2;
1142 q->lock = &dev->mutex;
1143 q->dev = dev->v4l2_dev.dev;
1144 q->supports_requests = true;
1145
1146 ret = vb2_queue_init(q);
1147 if (ret)
1148 goto unreg_dev;
1149 }
1150
1151 if (dev->has_vbi_cap) {
1152 /* initialize vbi_cap queue */
1153 q = &dev->vb_vbi_cap_q;
1154 q->type = dev->has_raw_vbi_cap ? V4L2_BUF_TYPE_VBI_CAPTURE :
1155 V4L2_BUF_TYPE_SLICED_VBI_CAPTURE;
1156 q->io_modes = VB2_MMAP | VB2_DMABUF | VB2_READ;
1157 if (!allocator)
1158 q->io_modes |= VB2_USERPTR;
1159 q->drv_priv = dev;
1160 q->buf_struct_size = sizeof(struct vivid_buffer);
1161 q->ops = &vivid_vbi_cap_qops;
1162 q->mem_ops = vivid_mem_ops[allocator];
1163 q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1164 q->min_buffers_needed = 2;
1165 q->lock = &dev->mutex;
1166 q->dev = dev->v4l2_dev.dev;
1167 q->supports_requests = true;
1168
1169 ret = vb2_queue_init(q);
1170 if (ret)
1171 goto unreg_dev;
1172 }
1173
1174 if (dev->has_vbi_out) {
1175 /* initialize vbi_out queue */
1176 q = &dev->vb_vbi_out_q;
1177 q->type = dev->has_raw_vbi_out ? V4L2_BUF_TYPE_VBI_OUTPUT :
1178 V4L2_BUF_TYPE_SLICED_VBI_OUTPUT;
1179 q->io_modes = VB2_MMAP | VB2_DMABUF | VB2_WRITE;
1180 if (!allocator)
1181 q->io_modes |= VB2_USERPTR;
1182 q->drv_priv = dev;
1183 q->buf_struct_size = sizeof(struct vivid_buffer);
1184 q->ops = &vivid_vbi_out_qops;
1185 q->mem_ops = vivid_mem_ops[allocator];
1186 q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1187 q->min_buffers_needed = 2;
1188 q->lock = &dev->mutex;
1189 q->dev = dev->v4l2_dev.dev;
1190 q->supports_requests = true;
1191
1192 ret = vb2_queue_init(q);
1193 if (ret)
1194 goto unreg_dev;
1195 }
1196
1197 if (dev->has_sdr_cap) {
1198 /* initialize sdr_cap queue */
1199 q = &dev->vb_sdr_cap_q;
1200 q->type = V4L2_BUF_TYPE_SDR_CAPTURE;
1201 q->io_modes = VB2_MMAP | VB2_DMABUF | VB2_READ;
1202 if (!allocator)
1203 q->io_modes |= VB2_USERPTR;
1204 q->drv_priv = dev;
1205 q->buf_struct_size = sizeof(struct vivid_buffer);
1206 q->ops = &vivid_sdr_cap_qops;
1207 q->mem_ops = vivid_mem_ops[allocator];
1208 q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1209 q->min_buffers_needed = 8;
1210 q->lock = &dev->mutex;
1211 q->dev = dev->v4l2_dev.dev;
1212 q->supports_requests = true;
1213
1214 ret = vb2_queue_init(q);
1215 if (ret)
1216 goto unreg_dev;
1217 }
1218
1219 if (dev->has_fb) {
1220 /* Create framebuffer for testing capture/output overlay */
1221 ret = vivid_fb_init(dev);
1222 if (ret)
1223 goto unreg_dev;
1224 v4l2_info(&dev->v4l2_dev, "Framebuffer device registered as fb%d\n",
1225 dev->fb_info.node);
1226 }
1227
1228 #ifdef CONFIG_VIDEO_VIVID_CEC
1229 if (dev->has_vid_cap && in_type_counter[HDMI]) {
1230 struct cec_adapter *adap;
1231
1232 adap = vivid_cec_alloc_adap(dev, 0, false);
1233 ret = PTR_ERR_OR_ZERO(adap);
1234 if (ret < 0)
1235 goto unreg_dev;
1236 dev->cec_rx_adap = adap;
1237 }
1238
1239 if (dev->has_vid_out) {
1240 for (i = 0; i < dev->num_outputs; i++) {
1241 struct cec_adapter *adap;
1242
1243 if (dev->output_type[i] != HDMI)
1244 continue;
1245
1246 dev->cec_output2bus_map[i] = cec_tx_bus_cnt;
1247 adap = vivid_cec_alloc_adap(dev, cec_tx_bus_cnt, true);
1248 ret = PTR_ERR_OR_ZERO(adap);
1249 if (ret < 0) {
1250 for (i = 0; i < dev->num_outputs; i++)
1251 cec_delete_adapter(dev->cec_tx_adap[i]);
1252 goto unreg_dev;
1253 }
1254
1255 dev->cec_tx_adap[cec_tx_bus_cnt] = adap;
1256 cec_tx_bus_cnt++;
1257 }
1258 }
1259 #endif
1260
1261 v4l2_ctrl_handler_setup(&dev->ctrl_hdl_vid_cap);
1262 v4l2_ctrl_handler_setup(&dev->ctrl_hdl_vid_out);
1263 v4l2_ctrl_handler_setup(&dev->ctrl_hdl_vbi_cap);
1264 v4l2_ctrl_handler_setup(&dev->ctrl_hdl_vbi_out);
1265 v4l2_ctrl_handler_setup(&dev->ctrl_hdl_radio_rx);
1266 v4l2_ctrl_handler_setup(&dev->ctrl_hdl_radio_tx);
1267 v4l2_ctrl_handler_setup(&dev->ctrl_hdl_sdr_cap);
1268
1269 /* finally start creating the device nodes */
1270 if (dev->has_vid_cap) {
1271 vfd = &dev->vid_cap_dev;
1272 vfd->fops = &vivid_fops;
1273 vfd->ioctl_ops = &vivid_ioctl_ops;
1274 vfd->device_caps = dev->vid_cap_caps;
1275 vfd->release = video_device_release_empty;
1276 vfd->v4l2_dev = &dev->v4l2_dev;
1277 vfd->queue = &dev->vb_vid_cap_q;
1278 vfd->tvnorms = tvnorms_cap;
1279
1280 /*
1281 * Provide a mutex to v4l2 core. It will be used to protect
1282 * all fops and v4l2 ioctls.
1283 */
1284 vfd->lock = &dev->mutex;
1285 video_set_drvdata(vfd, dev);
1286
1287 #ifdef CONFIG_MEDIA_CONTROLLER
1288 dev->vid_cap_pad.flags = MEDIA_PAD_FL_SINK;
1289 ret = media_entity_pads_init(&vfd->entity, 1, &dev->vid_cap_pad);
1290 if (ret)
1291 goto unreg_dev;
1292 #endif
1293
1294 #ifdef CONFIG_VIDEO_VIVID_CEC
1295 if (in_type_counter[HDMI]) {
1296 ret = cec_register_adapter(dev->cec_rx_adap, &pdev->dev);
1297 if (ret < 0) {
1298 cec_delete_adapter(dev->cec_rx_adap);
1299 dev->cec_rx_adap = NULL;
1300 goto unreg_dev;
1301 }
1302 cec_s_phys_addr(dev->cec_rx_adap, 0, false);
1303 v4l2_info(&dev->v4l2_dev, "CEC adapter %s registered for HDMI input 0\n",
1304 dev_name(&dev->cec_rx_adap->devnode.dev));
1305 }
1306 #endif
1307
1308 ret = video_register_device(vfd, VFL_TYPE_GRABBER, vid_cap_nr[inst]);
1309 if (ret < 0)
1310 goto unreg_dev;
1311 v4l2_info(&dev->v4l2_dev, "V4L2 capture device registered as %s\n",
1312 video_device_node_name(vfd));
1313 }
1314
1315 if (dev->has_vid_out) {
1316 vfd = &dev->vid_out_dev;
1317 vfd->vfl_dir = VFL_DIR_TX;
1318 vfd->fops = &vivid_fops;
1319 vfd->ioctl_ops = &vivid_ioctl_ops;
1320 vfd->device_caps = dev->vid_out_caps;
1321 vfd->release = video_device_release_empty;
1322 vfd->v4l2_dev = &dev->v4l2_dev;
1323 vfd->queue = &dev->vb_vid_out_q;
1324 vfd->tvnorms = tvnorms_out;
1325
1326 /*
1327 * Provide a mutex to v4l2 core. It will be used to protect
1328 * all fops and v4l2 ioctls.
1329 */
1330 vfd->lock = &dev->mutex;
1331 video_set_drvdata(vfd, dev);
1332
1333 #ifdef CONFIG_MEDIA_CONTROLLER
1334 dev->vid_out_pad.flags = MEDIA_PAD_FL_SOURCE;
1335 ret = media_entity_pads_init(&vfd->entity, 1, &dev->vid_out_pad);
1336 if (ret)
1337 goto unreg_dev;
1338 #endif
1339
1340 #ifdef CONFIG_VIDEO_VIVID_CEC
1341 for (i = 0; i < cec_tx_bus_cnt; i++) {
1342 ret = cec_register_adapter(dev->cec_tx_adap[i], &pdev->dev);
1343 if (ret < 0) {
1344 for (; i < cec_tx_bus_cnt; i++) {
1345 cec_delete_adapter(dev->cec_tx_adap[i]);
1346 dev->cec_tx_adap[i] = NULL;
1347 }
1348 goto unreg_dev;
1349 }
1350 v4l2_info(&dev->v4l2_dev, "CEC adapter %s registered for HDMI output %d\n",
1351 dev_name(&dev->cec_tx_adap[i]->devnode.dev), i);
1352 if (i <= out_type_counter[HDMI])
1353 cec_s_phys_addr(dev->cec_tx_adap[i], i << 12, false);
1354 else
1355 cec_s_phys_addr(dev->cec_tx_adap[i], 0x1000, false);
1356 }
1357 #endif
1358
1359 ret = video_register_device(vfd, VFL_TYPE_GRABBER, vid_out_nr[inst]);
1360 if (ret < 0)
1361 goto unreg_dev;
1362 v4l2_info(&dev->v4l2_dev, "V4L2 output device registered as %s\n",
1363 video_device_node_name(vfd));
1364 }
1365
1366 if (dev->has_vbi_cap) {
1367 vfd = &dev->vbi_cap_dev;
1368 snprintf(vfd->name, sizeof(vfd->name),
1369 "vivid-%03d-vbi-cap", inst);
1370 vfd->fops = &vivid_fops;
1371 vfd->ioctl_ops = &vivid_ioctl_ops;
1372 vfd->device_caps = dev->vbi_cap_caps;
1373 vfd->release = video_device_release_empty;
1374 vfd->v4l2_dev = &dev->v4l2_dev;
1375 vfd->queue = &dev->vb_vbi_cap_q;
1376 vfd->lock = &dev->mutex;
1377 vfd->tvnorms = tvnorms_cap;
1378 video_set_drvdata(vfd, dev);
1379
1380 #ifdef CONFIG_MEDIA_CONTROLLER
1381 dev->vbi_cap_pad.flags = MEDIA_PAD_FL_SINK;
1382 ret = media_entity_pads_init(&vfd->entity, 1, &dev->vbi_cap_pad);
1383 if (ret)
1384 goto unreg_dev;
1385 #endif
1386
1387 ret = video_register_device(vfd, VFL_TYPE_VBI, vbi_cap_nr[inst]);
1388 if (ret < 0)
1389 goto unreg_dev;
1390 v4l2_info(&dev->v4l2_dev, "V4L2 capture device registered as %s, supports %s VBI\n",
1391 video_device_node_name(vfd),
1392 (dev->has_raw_vbi_cap && dev->has_sliced_vbi_cap) ?
1393 "raw and sliced" :
1394 (dev->has_raw_vbi_cap ? "raw" : "sliced"));
1395 }
1396
1397 if (dev->has_vbi_out) {
1398 vfd = &dev->vbi_out_dev;
1399 snprintf(vfd->name, sizeof(vfd->name),
1400 "vivid-%03d-vbi-out", inst);
1401 vfd->vfl_dir = VFL_DIR_TX;
1402 vfd->fops = &vivid_fops;
1403 vfd->ioctl_ops = &vivid_ioctl_ops;
1404 vfd->device_caps = dev->vbi_out_caps;
1405 vfd->release = video_device_release_empty;
1406 vfd->v4l2_dev = &dev->v4l2_dev;
1407 vfd->queue = &dev->vb_vbi_out_q;
1408 vfd->lock = &dev->mutex;
1409 vfd->tvnorms = tvnorms_out;
1410 video_set_drvdata(vfd, dev);
1411
1412 #ifdef CONFIG_MEDIA_CONTROLLER
1413 dev->vbi_out_pad.flags = MEDIA_PAD_FL_SOURCE;
1414 ret = media_entity_pads_init(&vfd->entity, 1, &dev->vbi_out_pad);
1415 if (ret)
1416 goto unreg_dev;
1417 #endif
1418
1419 ret = video_register_device(vfd, VFL_TYPE_VBI, vbi_out_nr[inst]);
1420 if (ret < 0)
1421 goto unreg_dev;
1422 v4l2_info(&dev->v4l2_dev, "V4L2 output device registered as %s, supports %s VBI\n",
1423 video_device_node_name(vfd),
1424 (dev->has_raw_vbi_out && dev->has_sliced_vbi_out) ?
1425 "raw and sliced" :
1426 (dev->has_raw_vbi_out ? "raw" : "sliced"));
1427 }
1428
1429 if (dev->has_sdr_cap) {
1430 vfd = &dev->sdr_cap_dev;
1431 snprintf(vfd->name, sizeof(vfd->name),
1432 "vivid-%03d-sdr-cap", inst);
1433 vfd->fops = &vivid_fops;
1434 vfd->ioctl_ops = &vivid_ioctl_ops;
1435 vfd->device_caps = dev->sdr_cap_caps;
1436 vfd->release = video_device_release_empty;
1437 vfd->v4l2_dev = &dev->v4l2_dev;
1438 vfd->queue = &dev->vb_sdr_cap_q;
1439 vfd->lock = &dev->mutex;
1440 video_set_drvdata(vfd, dev);
1441
1442 #ifdef CONFIG_MEDIA_CONTROLLER
1443 dev->sdr_cap_pad.flags = MEDIA_PAD_FL_SINK;
1444 ret = media_entity_pads_init(&vfd->entity, 1, &dev->sdr_cap_pad);
1445 if (ret)
1446 goto unreg_dev;
1447 #endif
1448
1449 ret = video_register_device(vfd, VFL_TYPE_SDR, sdr_cap_nr[inst]);
1450 if (ret < 0)
1451 goto unreg_dev;
1452 v4l2_info(&dev->v4l2_dev, "V4L2 capture device registered as %s\n",
1453 video_device_node_name(vfd));
1454 }
1455
1456 if (dev->has_radio_rx) {
1457 vfd = &dev->radio_rx_dev;
1458 snprintf(vfd->name, sizeof(vfd->name),
1459 "vivid-%03d-rad-rx", inst);
1460 vfd->fops = &vivid_radio_fops;
1461 vfd->ioctl_ops = &vivid_ioctl_ops;
1462 vfd->device_caps = dev->radio_rx_caps;
1463 vfd->release = video_device_release_empty;
1464 vfd->v4l2_dev = &dev->v4l2_dev;
1465 vfd->lock = &dev->mutex;
1466 video_set_drvdata(vfd, dev);
1467
1468 ret = video_register_device(vfd, VFL_TYPE_RADIO, radio_rx_nr[inst]);
1469 if (ret < 0)
1470 goto unreg_dev;
1471 v4l2_info(&dev->v4l2_dev, "V4L2 receiver device registered as %s\n",
1472 video_device_node_name(vfd));
1473 }
1474
1475 if (dev->has_radio_tx) {
1476 vfd = &dev->radio_tx_dev;
1477 snprintf(vfd->name, sizeof(vfd->name),
1478 "vivid-%03d-rad-tx", inst);
1479 vfd->vfl_dir = VFL_DIR_TX;
1480 vfd->fops = &vivid_radio_fops;
1481 vfd->ioctl_ops = &vivid_ioctl_ops;
1482 vfd->device_caps = dev->radio_tx_caps;
1483 vfd->release = video_device_release_empty;
1484 vfd->v4l2_dev = &dev->v4l2_dev;
1485 vfd->lock = &dev->mutex;
1486 video_set_drvdata(vfd, dev);
1487
1488 ret = video_register_device(vfd, VFL_TYPE_RADIO, radio_tx_nr[inst]);
1489 if (ret < 0)
1490 goto unreg_dev;
1491 v4l2_info(&dev->v4l2_dev, "V4L2 transmitter device registered as %s\n",
1492 video_device_node_name(vfd));
1493 }
1494
1495 #ifdef CONFIG_MEDIA_CONTROLLER
1496 /* Register the media device */
1497 ret = media_device_register(&dev->mdev);
1498 if (ret) {
1499 dev_err(dev->mdev.dev,
1500 "media device register failed (err=%d)\n", ret);
1501 goto unreg_dev;
1502 }
1503 #endif
1504
1505 /* Now that everything is fine, let's add it to device list */
1506 vivid_devs[inst] = dev;
1507
1508 return 0;
1509
1510 unreg_dev:
1511 video_unregister_device(&dev->radio_tx_dev);
1512 video_unregister_device(&dev->radio_rx_dev);
1513 video_unregister_device(&dev->sdr_cap_dev);
1514 video_unregister_device(&dev->vbi_out_dev);
1515 video_unregister_device(&dev->vbi_cap_dev);
1516 video_unregister_device(&dev->vid_out_dev);
1517 video_unregister_device(&dev->vid_cap_dev);
1518 cec_unregister_adapter(dev->cec_rx_adap);
1519 for (i = 0; i < MAX_OUTPUTS; i++)
1520 cec_unregister_adapter(dev->cec_tx_adap[i]);
1521 if (dev->cec_workqueue) {
1522 vivid_cec_bus_free_work(dev);
1523 destroy_workqueue(dev->cec_workqueue);
1524 }
1525 free_dev:
1526 v4l2_device_put(&dev->v4l2_dev);
1527 return ret;
1528 }
1529
1530 /* This routine allocates from 1 to n_devs virtual drivers.
1531
1532 The real maximum number of virtual drivers will depend on how many drivers
1533 will succeed. This is limited to the maximum number of devices that
1534 videodev supports, which is equal to VIDEO_NUM_DEVICES.
1535 */
vivid_probe(struct platform_device * pdev)1536 static int vivid_probe(struct platform_device *pdev)
1537 {
1538 const struct font_desc *font = find_font("VGA8x16");
1539 int ret = 0, i;
1540
1541 if (font == NULL) {
1542 pr_err("vivid: could not find font\n");
1543 return -ENODEV;
1544 }
1545
1546 tpg_set_font(font->data);
1547
1548 n_devs = clamp_t(unsigned, n_devs, 1, VIVID_MAX_DEVS);
1549
1550 for (i = 0; i < n_devs; i++) {
1551 ret = vivid_create_instance(pdev, i);
1552 if (ret) {
1553 /* If some instantiations succeeded, keep driver */
1554 if (i)
1555 ret = 0;
1556 break;
1557 }
1558 }
1559
1560 if (ret < 0) {
1561 pr_err("vivid: error %d while loading driver\n", ret);
1562 return ret;
1563 }
1564
1565 /* n_devs will reflect the actual number of allocated devices */
1566 n_devs = i;
1567
1568 return ret;
1569 }
1570
vivid_remove(struct platform_device * pdev)1571 static int vivid_remove(struct platform_device *pdev)
1572 {
1573 struct vivid_dev *dev;
1574 unsigned int i, j;
1575
1576 for (i = 0; i < n_devs; i++) {
1577 dev = vivid_devs[i];
1578 if (!dev)
1579 continue;
1580
1581 #ifdef CONFIG_MEDIA_CONTROLLER
1582 media_device_unregister(&dev->mdev);
1583 media_device_cleanup(&dev->mdev);
1584 #endif
1585
1586 if (dev->has_vid_cap) {
1587 v4l2_info(&dev->v4l2_dev, "unregistering %s\n",
1588 video_device_node_name(&dev->vid_cap_dev));
1589 video_unregister_device(&dev->vid_cap_dev);
1590 }
1591 if (dev->has_vid_out) {
1592 v4l2_info(&dev->v4l2_dev, "unregistering %s\n",
1593 video_device_node_name(&dev->vid_out_dev));
1594 video_unregister_device(&dev->vid_out_dev);
1595 }
1596 if (dev->has_vbi_cap) {
1597 v4l2_info(&dev->v4l2_dev, "unregistering %s\n",
1598 video_device_node_name(&dev->vbi_cap_dev));
1599 video_unregister_device(&dev->vbi_cap_dev);
1600 }
1601 if (dev->has_vbi_out) {
1602 v4l2_info(&dev->v4l2_dev, "unregistering %s\n",
1603 video_device_node_name(&dev->vbi_out_dev));
1604 video_unregister_device(&dev->vbi_out_dev);
1605 }
1606 if (dev->has_sdr_cap) {
1607 v4l2_info(&dev->v4l2_dev, "unregistering %s\n",
1608 video_device_node_name(&dev->sdr_cap_dev));
1609 video_unregister_device(&dev->sdr_cap_dev);
1610 }
1611 if (dev->has_radio_rx) {
1612 v4l2_info(&dev->v4l2_dev, "unregistering %s\n",
1613 video_device_node_name(&dev->radio_rx_dev));
1614 video_unregister_device(&dev->radio_rx_dev);
1615 }
1616 if (dev->has_radio_tx) {
1617 v4l2_info(&dev->v4l2_dev, "unregistering %s\n",
1618 video_device_node_name(&dev->radio_tx_dev));
1619 video_unregister_device(&dev->radio_tx_dev);
1620 }
1621 if (dev->has_fb) {
1622 v4l2_info(&dev->v4l2_dev, "unregistering fb%d\n",
1623 dev->fb_info.node);
1624 unregister_framebuffer(&dev->fb_info);
1625 vivid_fb_release_buffers(dev);
1626 }
1627 cec_unregister_adapter(dev->cec_rx_adap);
1628 for (j = 0; j < MAX_OUTPUTS; j++)
1629 cec_unregister_adapter(dev->cec_tx_adap[j]);
1630 if (dev->cec_workqueue) {
1631 vivid_cec_bus_free_work(dev);
1632 destroy_workqueue(dev->cec_workqueue);
1633 }
1634 v4l2_device_put(&dev->v4l2_dev);
1635 vivid_devs[i] = NULL;
1636 }
1637 return 0;
1638 }
1639
vivid_pdev_release(struct device * dev)1640 static void vivid_pdev_release(struct device *dev)
1641 {
1642 }
1643
1644 static struct platform_device vivid_pdev = {
1645 .name = "vivid",
1646 .dev.release = vivid_pdev_release,
1647 };
1648
1649 static struct platform_driver vivid_pdrv = {
1650 .probe = vivid_probe,
1651 .remove = vivid_remove,
1652 .driver = {
1653 .name = "vivid",
1654 },
1655 };
1656
vivid_init(void)1657 static int __init vivid_init(void)
1658 {
1659 int ret;
1660
1661 ret = platform_device_register(&vivid_pdev);
1662 if (ret)
1663 return ret;
1664
1665 ret = platform_driver_register(&vivid_pdrv);
1666 if (ret)
1667 platform_device_unregister(&vivid_pdev);
1668
1669 return ret;
1670 }
1671
vivid_exit(void)1672 static void __exit vivid_exit(void)
1673 {
1674 platform_driver_unregister(&vivid_pdrv);
1675 platform_device_unregister(&vivid_pdev);
1676 }
1677
1678 module_init(vivid_init);
1679 module_exit(vivid_exit);
1680
