drivers/media/platform/vivid/vivid-core.c

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