kernel/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 ssize_t vivid_radio_read(struct file *file, char __user *buf,
 396                          size_t size, loff_t *offset)
 397 {
 398         struct video_device *vdev = video_devdata(file);
 399
 400         if (vdev->vfl_dir == VFL_DIR_TX)
 401                 return -EINVAL;
 402         return vivid_radio_rx_read(file, buf, size, offset);
 403 }
 404
 405 static ssize_t vivid_radio_write(struct file *file, const char __user *buf,
 406                           size_t size, loff_t *offset)
 407 {
 408         struct video_device *vdev = video_devdata(file);
 409
 410         if (vdev->vfl_dir == VFL_DIR_RX)
 411                 return -EINVAL;
 412         return vivid_radio_tx_write(file, buf, size, offset);
 413 }
 414
 415 static unsigned int vivid_radio_poll(struct file *file, struct poll_table_struct *wait)
 416 {
 417         struct video_device *vdev = video_devdata(file);
 418
 419         if (vdev->vfl_dir == VFL_DIR_RX)
 420                 return vivid_radio_rx_poll(file, wait);
 421         return vivid_radio_tx_poll(file, wait);
 422 }
 423
 424 static bool vivid_is_in_use(struct video_device *vdev)
 425 {
 426         unsigned long flags;
 427         bool res;
 428
 429         spin_lock_irqsave(&vdev->fh_lock, flags);
 430         res = !list_empty(&vdev->fh_list);
 431         spin_unlock_irqrestore(&vdev->fh_lock, flags);
 432         return res;
 433 }
 434
 435 static bool vivid_is_last_user(struct vivid_dev *dev)
 436 {
 437         unsigned uses = vivid_is_in_use(&dev->vid_cap_dev) +
 438                         vivid_is_in_use(&dev->vid_out_dev) +
 439                         vivid_is_in_use(&dev->vbi_cap_dev) +
 440                         vivid_is_in_use(&dev->vbi_out_dev) +
 441                         vivid_is_in_use(&dev->sdr_cap_dev) +
 442                         vivid_is_in_use(&dev->radio_rx_dev) +
 443                         vivid_is_in_use(&dev->radio_tx_dev);
 444
 445         return uses == 1;
 446 }
 447
 448 static int vivid_fop_release(struct file *file)
 449 {
 450         struct vivid_dev *dev = video_drvdata(file);
 451         struct video_device *vdev = video_devdata(file);
 452
 453         mutex_lock(&dev->mutex);
 454         if (!no_error_inj && v4l2_fh_is_singular_file(file) &&
 455             !video_is_registered(vdev) && vivid_is_last_user(dev)) {
 456                 /*
 457                  * I am the last user of this driver, and a disconnect
 458                  * was forced (since this video_device is unregistered),
 459                  * so re-register all video_device's again.
 460                  */
 461                 v4l2_info(&dev->v4l2_dev, "reconnect\n");
 462                 set_bit(V4L2_FL_REGISTERED, &dev->vid_cap_dev.flags);
 463                 set_bit(V4L2_FL_REGISTERED, &dev->vid_out_dev.flags);
 464                 set_bit(V4L2_FL_REGISTERED, &dev->vbi_cap_dev.flags);
 465                 set_bit(V4L2_FL_REGISTERED, &dev->vbi_out_dev.flags);
 466                 set_bit(V4L2_FL_REGISTERED, &dev->sdr_cap_dev.flags);
 467                 set_bit(V4L2_FL_REGISTERED, &dev->radio_rx_dev.flags);
 468                 set_bit(V4L2_FL_REGISTERED, &dev->radio_tx_dev.flags);
 469         }
 470         mutex_unlock(&dev->mutex);
 471         if (file->private_data == dev->overlay_cap_owner)
 472                 dev->overlay_cap_owner = NULL;
 473         if (file->private_data == dev->radio_rx_rds_owner) {
 474                 dev->radio_rx_rds_last_block = 0;
 475                 dev->radio_rx_rds_owner = NULL;
 476         }
 477         if (file->private_data == dev->radio_tx_rds_owner) {
 478                 dev->radio_tx_rds_last_block = 0;
 479                 dev->radio_tx_rds_owner = NULL;
 480         }
 481         if (vdev->queue)
 482                 return vb2_fop_release(file);
 483         return v4l2_fh_release(file);
 484 }
 485
 486 static const struct v4l2_file_operations vivid_fops = {
 487         .owner          = THIS_MODULE,
 488         .open           = v4l2_fh_open,
 489         .release        = vivid_fop_release,
 490         .read           = vb2_fop_read,
 491         .write          = vb2_fop_write,
 492         .poll           = vb2_fop_poll,
 493         .unlocked_ioctl = video_ioctl2,
 494         .mmap           = vb2_fop_mmap,
 495 };
 496
 497 static const struct v4l2_file_operations vivid_radio_fops = {
 498         .owner          = THIS_MODULE,
 499         .open           = v4l2_fh_open,
 500         .release        = vivid_fop_release,
 501         .read           = vivid_radio_read,
 502         .write          = vivid_radio_write,
 503         .poll           = vivid_radio_poll,
 504         .unlocked_ioctl = video_ioctl2,
 505 };
 506
 507 static const struct v4l2_ioctl_ops vivid_ioctl_ops = {
 508         .vidioc_querycap                = vidioc_querycap,
 509
 510         .vidioc_enum_fmt_vid_cap        = vidioc_enum_fmt_vid,
 511         .vidioc_g_fmt_vid_cap           = vidioc_g_fmt_vid_cap,
 512         .vidioc_try_fmt_vid_cap         = vidioc_try_fmt_vid_cap,
 513         .vidioc_s_fmt_vid_cap           = vidioc_s_fmt_vid_cap,
 514         .vidioc_enum_fmt_vid_cap_mplane = vidioc_enum_fmt_vid_mplane,
 515         .vidioc_g_fmt_vid_cap_mplane    = vidioc_g_fmt_vid_cap_mplane,
 516         .vidioc_try_fmt_vid_cap_mplane  = vidioc_try_fmt_vid_cap_mplane,
 517         .vidioc_s_fmt_vid_cap_mplane    = vidioc_s_fmt_vid_cap_mplane,
 518
 519         .vidioc_enum_fmt_vid_out        = vidioc_enum_fmt_vid,
 520         .vidioc_g_fmt_vid_out           = vidioc_g_fmt_vid_out,
 521         .vidioc_try_fmt_vid_out         = vidioc_try_fmt_vid_out,
 522         .vidioc_s_fmt_vid_out           = vidioc_s_fmt_vid_out,
 523         .vidioc_enum_fmt_vid_out_mplane = vidioc_enum_fmt_vid_mplane,
 524         .vidioc_g_fmt_vid_out_mplane    = vidioc_g_fmt_vid_out_mplane,
 525         .vidioc_try_fmt_vid_out_mplane  = vidioc_try_fmt_vid_out_mplane,
 526         .vidioc_s_fmt_vid_out_mplane    = vidioc_s_fmt_vid_out_mplane,
 527
 528         .vidioc_g_selection             = vidioc_g_selection,
 529         .vidioc_s_selection             = vidioc_s_selection,
 530         .vidioc_cropcap                 = vidioc_cropcap,
 531
 532         .vidioc_g_fmt_vbi_cap           = vidioc_g_fmt_vbi_cap,
 533         .vidioc_try_fmt_vbi_cap         = vidioc_g_fmt_vbi_cap,
 534         .vidioc_s_fmt_vbi_cap           = vidioc_s_fmt_vbi_cap,
 535
 536         .vidioc_g_fmt_sliced_vbi_cap    = vidioc_g_fmt_sliced_vbi_cap,
 537         .vidioc_try_fmt_sliced_vbi_cap  = vidioc_try_fmt_sliced_vbi_cap,
 538         .vidioc_s_fmt_sliced_vbi_cap    = vidioc_s_fmt_sliced_vbi_cap,
 539         .vidioc_g_sliced_vbi_cap        = vidioc_g_sliced_vbi_cap,
 540
 541         .vidioc_g_fmt_vbi_out           = vidioc_g_fmt_vbi_out,
 542         .vidioc_try_fmt_vbi_out         = vidioc_g_fmt_vbi_out,
 543         .vidioc_s_fmt_vbi_out           = vidioc_s_fmt_vbi_out,
 544
 545         .vidioc_g_fmt_sliced_vbi_out    = vidioc_g_fmt_sliced_vbi_out,
 546         .vidioc_try_fmt_sliced_vbi_out  = vidioc_try_fmt_sliced_vbi_out,
 547         .vidioc_s_fmt_sliced_vbi_out    = vidioc_s_fmt_sliced_vbi_out,
 548
 549         .vidioc_enum_fmt_sdr_cap        = vidioc_enum_fmt_sdr_cap,
 550         .vidioc_g_fmt_sdr_cap           = vidioc_g_fmt_sdr_cap,
 551         .vidioc_try_fmt_sdr_cap         = vidioc_g_fmt_sdr_cap,
 552         .vidioc_s_fmt_sdr_cap           = vidioc_g_fmt_sdr_cap,
 553
 554         .vidioc_overlay                 = vidioc_overlay,
 555         .vidioc_enum_framesizes         = vidioc_enum_framesizes,
 556         .vidioc_enum_frameintervals     = vidioc_enum_frameintervals,
 557         .vidioc_g_parm                  = vidioc_g_parm,
 558         .vidioc_s_parm                  = vidioc_s_parm,
 559
 560         .vidioc_enum_fmt_vid_overlay    = vidioc_enum_fmt_vid_overlay,
 561         .vidioc_g_fmt_vid_overlay       = vidioc_g_fmt_vid_overlay,
 562         .vidioc_try_fmt_vid_overlay     = vidioc_try_fmt_vid_overlay,
 563         .vidioc_s_fmt_vid_overlay       = vidioc_s_fmt_vid_overlay,
 564         .vidioc_g_fmt_vid_out_overlay   = vidioc_g_fmt_vid_out_overlay,
 565         .vidioc_try_fmt_vid_out_overlay = vidioc_try_fmt_vid_out_overlay,
 566         .vidioc_s_fmt_vid_out_overlay   = vidioc_s_fmt_vid_out_overlay,
 567         .vidioc_g_fbuf                  = vidioc_g_fbuf,
 568         .vidioc_s_fbuf                  = vidioc_s_fbuf,
 569
 570         .vidioc_reqbufs                 = vb2_ioctl_reqbufs,
 571         .vidioc_create_bufs             = vb2_ioctl_create_bufs,
 572         .vidioc_prepare_buf             = vb2_ioctl_prepare_buf,
 573         .vidioc_querybuf                = vb2_ioctl_querybuf,
 574         .vidioc_qbuf                    = vb2_ioctl_qbuf,
 575         .vidioc_dqbuf                   = vb2_ioctl_dqbuf,
 576         .vidioc_expbuf                  = vb2_ioctl_expbuf,
 577         .vidioc_streamon                = vb2_ioctl_streamon,
 578         .vidioc_streamoff               = vb2_ioctl_streamoff,
 579
 580         .vidioc_enum_input              = vidioc_enum_input,
 581         .vidioc_g_input                 = vidioc_g_input,
 582         .vidioc_s_input                 = vidioc_s_input,
 583         .vidioc_s_audio                 = vidioc_s_audio,
 584         .vidioc_g_audio                 = vidioc_g_audio,
 585         .vidioc_enumaudio               = vidioc_enumaudio,
 586         .vidioc_s_frequency             = vidioc_s_frequency,
 587         .vidioc_g_frequency             = vidioc_g_frequency,
 588         .vidioc_s_tuner                 = vidioc_s_tuner,
 589         .vidioc_g_tuner                 = vidioc_g_tuner,
 590         .vidioc_s_modulator             = vidioc_s_modulator,
 591         .vidioc_g_modulator             = vidioc_g_modulator,
 592         .vidioc_s_hw_freq_seek          = vidioc_s_hw_freq_seek,
 593         .vidioc_enum_freq_bands         = vidioc_enum_freq_bands,
 594
 595         .vidioc_enum_output             = vidioc_enum_output,
 596         .vidioc_g_output                = vidioc_g_output,
 597         .vidioc_s_output                = vidioc_s_output,
 598         .vidioc_s_audout                = vidioc_s_audout,
 599         .vidioc_g_audout                = vidioc_g_audout,
 600         .vidioc_enumaudout              = vidioc_enumaudout,
 601
 602         .vidioc_querystd                = vidioc_querystd,
 603         .vidioc_g_std                   = vidioc_g_std,
 604         .vidioc_s_std                   = vidioc_s_std,
 605         .vidioc_s_dv_timings            = vidioc_s_dv_timings,
 606         .vidioc_g_dv_timings            = vidioc_g_dv_timings,
 607         .vidioc_query_dv_timings        = vidioc_query_dv_timings,
 608         .vidioc_enum_dv_timings         = vidioc_enum_dv_timings,
 609         .vidioc_dv_timings_cap          = vidioc_dv_timings_cap,
 610         .vidioc_g_edid                  = vidioc_g_edid,
 611         .vidioc_s_edid                  = vidioc_s_edid,
 612
 613         .vidioc_log_status              = v4l2_ctrl_log_status,
 614         .vidioc_subscribe_event         = vidioc_subscribe_event,
 615         .vidioc_unsubscribe_event       = v4l2_event_unsubscribe,
 616 };
 617
 618 /* -----------------------------------------------------------------
 619         Initialization and module stuff
 620    ------------------------------------------------------------------*/
 621
 622 static void vivid_dev_release(struct v4l2_device *v4l2_dev)
 623 {
 624         struct vivid_dev *dev = container_of(v4l2_dev, struct vivid_dev, v4l2_dev);
 625
 626         vivid_free_controls(dev);
 627         v4l2_device_unregister(&dev->v4l2_dev);
 628         vfree(dev->scaled_line);
 629         vfree(dev->blended_line);
 630         vfree(dev->edid);
 631         vfree(dev->bitmap_cap);
 632         vfree(dev->bitmap_out);
 633         tpg_free(&dev->tpg);
 634         kfree(dev->query_dv_timings_qmenu);
 635         kfree(dev);
 636 }
 637
 638 static int vivid_create_instance(struct platform_device *pdev, int inst)
 639 {
 640         static const struct v4l2_dv_timings def_dv_timings =
 641                                         V4L2_DV_BT_CEA_1280X720P60;
 642         unsigned in_type_counter[4] = { 0, 0, 0, 0 };
 643         unsigned out_type_counter[4] = { 0, 0, 0, 0 };
 644         int ccs_cap = ccs_cap_mode[inst];
 645         int ccs_out = ccs_out_mode[inst];
 646         bool has_tuner;
 647         bool has_modulator;
 648         struct vivid_dev *dev;
 649         struct video_device *vfd;
 650         struct vb2_queue *q;
 651         unsigned node_type = node_types[inst];
 652         v4l2_std_id tvnorms_cap = 0, tvnorms_out = 0;
 653         int ret;
 654         int i;
 655
 656         /* allocate main vivid state structure */
 657         dev = kzalloc(sizeof(*dev), GFP_KERNEL);
 658         if (!dev)
 659                 return -ENOMEM;
 660
 661         dev->inst = inst;
 662
 663         /* register v4l2_device */
 664         snprintf(dev->v4l2_dev.name, sizeof(dev->v4l2_dev.name),
 665                         "%s-%03d", VIVID_MODULE_NAME, inst);
 666         ret = v4l2_device_register(&pdev->dev, &dev->v4l2_dev);
 667         if (ret) {
 668                 kfree(dev);
 669                 return ret;
 670         }
 671         dev->v4l2_dev.release = vivid_dev_release;
 672
 673         /* start detecting feature set */
 674
 675         /* do we use single- or multi-planar? */
 676         dev->multiplanar = multiplanar[inst] > 1;
 677         v4l2_info(&dev->v4l2_dev, "using %splanar format API\n",
 678                         dev->multiplanar ? "multi" : "single ");
 679
 680         /* how many inputs do we have and of what type? */
 681         dev->num_inputs = num_inputs[inst];
 682         if (dev->num_inputs < 1)
 683                 dev->num_inputs = 1;
 684         if (dev->num_inputs >= MAX_INPUTS)
 685                 dev->num_inputs = MAX_INPUTS;
 686         for (i = 0; i < dev->num_inputs; i++) {
 687                 dev->input_type[i] = (input_types[inst] >> (i * 2)) & 0x3;
 688                 dev->input_name_counter[i] = in_type_counter[dev->input_type[i]]++;
 689         }
 690         dev->has_audio_inputs = in_type_counter[TV] && in_type_counter[SVID];
 691
 692         /* how many outputs do we have and of what type? */
 693         dev->num_outputs = num_outputs[inst];
 694         if (dev->num_outputs < 1)
 695                 dev->num_outputs = 1;
 696         if (dev->num_outputs >= MAX_OUTPUTS)
 697                 dev->num_outputs = MAX_OUTPUTS;
 698         for (i = 0; i < dev->num_outputs; i++) {
 699                 dev->output_type[i] = ((output_types[inst] >> i) & 1) ? HDMI : SVID;
 700                 dev->output_name_counter[i] = out_type_counter[dev->output_type[i]]++;
 701         }
 702         dev->has_audio_outputs = out_type_counter[SVID];
 703
 704         /* do we create a video capture device? */
 705         dev->has_vid_cap = node_type & 0x0001;
 706
 707         /* do we create a vbi capture device? */
 708         if (in_type_counter[TV] || in_type_counter[SVID]) {
 709                 dev->has_raw_vbi_cap = node_type & 0x0004;
 710                 dev->has_sliced_vbi_cap = node_type & 0x0008;
 711                 dev->has_vbi_cap = dev->has_raw_vbi_cap | dev->has_sliced_vbi_cap;
 712         }
 713
 714         /* do we create a video output device? */
 715         dev->has_vid_out = node_type & 0x0100;
 716
 717         /* do we create a vbi output device? */
 718         if (out_type_counter[SVID]) {
 719                 dev->has_raw_vbi_out = node_type & 0x0400;
 720                 dev->has_sliced_vbi_out = node_type & 0x0800;
 721                 dev->has_vbi_out = dev->has_raw_vbi_out | dev->has_sliced_vbi_out;
 722         }
 723
 724         /* do we create a radio receiver device? */
 725         dev->has_radio_rx = node_type & 0x0010;
 726
 727         /* do we create a radio transmitter device? */
 728         dev->has_radio_tx = node_type & 0x1000;
 729
 730         /* do we create a software defined radio capture device? */
 731         dev->has_sdr_cap = node_type & 0x0020;
 732
 733         /* do we have a tuner? */
 734         has_tuner = ((dev->has_vid_cap || dev->has_vbi_cap) && in_type_counter[TV]) ||
 735                     dev->has_radio_rx || dev->has_sdr_cap;
 736
 737         /* do we have a modulator? */
 738         has_modulator = dev->has_radio_tx;
 739
 740         if (dev->has_vid_cap)
 741                 /* do we have a framebuffer for overlay testing? */
 742                 dev->has_fb = node_type & 0x10000;
 743
 744         /* can we do crop/compose/scaling while capturing? */
 745         if (no_error_inj && ccs_cap == -1)
 746                 ccs_cap = 7;
 747
 748         /* if ccs_cap == -1, then the use can select it using controls */
 749         if (ccs_cap != -1) {
 750                 dev->has_crop_cap = ccs_cap & 1;
 751                 dev->has_compose_cap = ccs_cap & 2;
 752                 dev->has_scaler_cap = ccs_cap & 4;
 753                 v4l2_info(&dev->v4l2_dev, "Capture Crop: %c Compose: %c Scaler: %c\n",
 754                         dev->has_crop_cap ? 'Y' : 'N',
 755                         dev->has_compose_cap ? 'Y' : 'N',
 756                         dev->has_scaler_cap ? 'Y' : 'N');
 757         }
 758
 759         /* can we do crop/compose/scaling with video output? */
 760         if (no_error_inj && ccs_out == -1)
 761                 ccs_out = 7;
 762
 763         /* if ccs_out == -1, then the use can select it using controls */
 764         if (ccs_out != -1) {
 765                 dev->has_crop_out = ccs_out & 1;
 766                 dev->has_compose_out = ccs_out & 2;
 767                 dev->has_scaler_out = ccs_out & 4;
 768                 v4l2_info(&dev->v4l2_dev, "Output Crop: %c Compose: %c Scaler: %c\n",
 769                         dev->has_crop_out ? 'Y' : 'N',
 770                         dev->has_compose_out ? 'Y' : 'N',
 771                         dev->has_scaler_out ? 'Y' : 'N');
 772         }
 773
 774         /* end detecting feature set */
 775
 776         if (dev->has_vid_cap) {
 777                 /* set up the capabilities of the video capture device */
 778                 dev->vid_cap_caps = dev->multiplanar ?
 779                         V4L2_CAP_VIDEO_CAPTURE_MPLANE :
 780                         V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_VIDEO_OVERLAY;
 781                 dev->vid_cap_caps |= V4L2_CAP_STREAMING | V4L2_CAP_READWRITE;
 782                 if (dev->has_audio_inputs)
 783                         dev->vid_cap_caps |= V4L2_CAP_AUDIO;
 784                 if (in_type_counter[TV])
 785                         dev->vid_cap_caps |= V4L2_CAP_TUNER;
 786         }
 787         if (dev->has_vid_out) {
 788                 /* set up the capabilities of the video output device */
 789                 dev->vid_out_caps = dev->multiplanar ?
 790                         V4L2_CAP_VIDEO_OUTPUT_MPLANE :
 791                         V4L2_CAP_VIDEO_OUTPUT;
 792                 if (dev->has_fb)
 793                         dev->vid_out_caps |= V4L2_CAP_VIDEO_OUTPUT_OVERLAY;
 794                 dev->vid_out_caps |= V4L2_CAP_STREAMING | V4L2_CAP_READWRITE;
 795                 if (dev->has_audio_outputs)
 796                         dev->vid_out_caps |= V4L2_CAP_AUDIO;
 797         }
 798         if (dev->has_vbi_cap) {
 799                 /* set up the capabilities of the vbi capture device */
 800                 dev->vbi_cap_caps = (dev->has_raw_vbi_cap ? V4L2_CAP_VBI_CAPTURE : 0) |
 801                                     (dev->has_sliced_vbi_cap ? V4L2_CAP_SLICED_VBI_CAPTURE : 0);
 802                 dev->vbi_cap_caps |= V4L2_CAP_STREAMING | V4L2_CAP_READWRITE;
 803                 if (dev->has_audio_inputs)
 804                         dev->vbi_cap_caps |= V4L2_CAP_AUDIO;
 805                 if (in_type_counter[TV])
 806                         dev->vbi_cap_caps |= V4L2_CAP_TUNER;
 807         }
 808         if (dev->has_vbi_out) {
 809                 /* set up the capabilities of the vbi output device */
 810                 dev->vbi_out_caps = (dev->has_raw_vbi_out ? V4L2_CAP_VBI_OUTPUT : 0) |
 811                                     (dev->has_sliced_vbi_out ? V4L2_CAP_SLICED_VBI_OUTPUT : 0);
 812                 dev->vbi_out_caps |= V4L2_CAP_STREAMING | V4L2_CAP_READWRITE;
 813                 if (dev->has_audio_outputs)
 814                         dev->vbi_out_caps |= V4L2_CAP_AUDIO;
 815         }
 816         if (dev->has_sdr_cap) {
 817                 /* set up the capabilities of the sdr capture device */
 818                 dev->sdr_cap_caps = V4L2_CAP_SDR_CAPTURE | V4L2_CAP_TUNER;
 819                 dev->sdr_cap_caps |= V4L2_CAP_STREAMING | V4L2_CAP_READWRITE;
 820         }
 821         /* set up the capabilities of the radio receiver device */
 822         if (dev->has_radio_rx)
 823                 dev->radio_rx_caps = V4L2_CAP_RADIO | V4L2_CAP_RDS_CAPTURE |
 824                                      V4L2_CAP_HW_FREQ_SEEK | V4L2_CAP_TUNER |
 825                                      V4L2_CAP_READWRITE;
 826         /* set up the capabilities of the radio transmitter device */
 827         if (dev->has_radio_tx)
 828                 dev->radio_tx_caps = V4L2_CAP_RDS_OUTPUT | V4L2_CAP_MODULATOR |
 829                                      V4L2_CAP_READWRITE;
 830
 831         /* initialize the test pattern generator */
 832         tpg_init(&dev->tpg, 640, 360);
 833         if (tpg_alloc(&dev->tpg, MAX_ZOOM * MAX_WIDTH))
 834                 goto free_dev;
 835         dev->scaled_line = vzalloc(MAX_ZOOM * MAX_WIDTH);
 836         if (!dev->scaled_line)
 837                 goto free_dev;
 838         dev->blended_line = vzalloc(MAX_ZOOM * MAX_WIDTH);
 839         if (!dev->blended_line)
 840                 goto free_dev;
 841
 842         /* load the edid */
 843         dev->edid = vmalloc(256 * 128);
 844         if (!dev->edid)
 845                 goto free_dev;
 846
 847         /* create a string array containing the names of all the preset timings */
 848         while (v4l2_dv_timings_presets[dev->query_dv_timings_size].bt.width)
 849                 dev->query_dv_timings_size++;
 850         dev->query_dv_timings_qmenu = kmalloc(dev->query_dv_timings_size *
 851                                            (sizeof(void *) + 32), GFP_KERNEL);
 852         if (dev->query_dv_timings_qmenu == NULL)
 853                 goto free_dev;
 854         for (i = 0; i < dev->query_dv_timings_size; i++) {
 855                 const struct v4l2_bt_timings *bt = &v4l2_dv_timings_presets[i].bt;
 856                 char *p = (char *)&dev->query_dv_timings_qmenu[dev->query_dv_timings_size];
 857                 u32 htot, vtot;
 858
 859                 p += i * 32;
 860                 dev->query_dv_timings_qmenu[i] = p;
 861
 862                 htot = V4L2_DV_BT_FRAME_WIDTH(bt);
 863                 vtot = V4L2_DV_BT_FRAME_HEIGHT(bt);
 864                 snprintf(p, 32, "%ux%u%s%u",
 865                         bt->width, bt->height, bt->interlaced ? "i" : "p",
 866                         (u32)bt->pixelclock / (htot * vtot));
 867         }
 868
 869         /* disable invalid ioctls based on the feature set */
 870         if (!dev->has_audio_inputs) {
 871                 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_S_AUDIO);
 872                 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_G_AUDIO);
 873                 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_ENUMAUDIO);
 874                 v4l2_disable_ioctl(&dev->vbi_cap_dev, VIDIOC_S_AUDIO);
 875                 v4l2_disable_ioctl(&dev->vbi_cap_dev, VIDIOC_G_AUDIO);
 876                 v4l2_disable_ioctl(&dev->vbi_cap_dev, VIDIOC_ENUMAUDIO);
 877         }
 878         if (!dev->has_audio_outputs) {
 879                 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_S_AUDOUT);
 880                 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_G_AUDOUT);
 881                 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_ENUMAUDOUT);
 882                 v4l2_disable_ioctl(&dev->vbi_out_dev, VIDIOC_S_AUDOUT);
 883                 v4l2_disable_ioctl(&dev->vbi_out_dev, VIDIOC_G_AUDOUT);
 884                 v4l2_disable_ioctl(&dev->vbi_out_dev, VIDIOC_ENUMAUDOUT);
 885         }
 886         if (!in_type_counter[TV] && !in_type_counter[SVID]) {
 887                 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_S_STD);
 888                 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_G_STD);
 889                 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_ENUMSTD);
 890                 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_QUERYSTD);
 891         }
 892         if (!out_type_counter[SVID]) {
 893                 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_S_STD);
 894                 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_G_STD);
 895                 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_ENUMSTD);
 896         }
 897         if (!has_tuner && !has_modulator) {
 898                 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_S_FREQUENCY);
 899                 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_G_FREQUENCY);
 900                 v4l2_disable_ioctl(&dev->vbi_cap_dev, VIDIOC_S_FREQUENCY);
 901                 v4l2_disable_ioctl(&dev->vbi_cap_dev, VIDIOC_G_FREQUENCY);
 902         }
 903         if (!has_tuner) {
 904                 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_S_TUNER);
 905                 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_G_TUNER);
 906                 v4l2_disable_ioctl(&dev->vbi_cap_dev, VIDIOC_S_TUNER);
 907                 v4l2_disable_ioctl(&dev->vbi_cap_dev, VIDIOC_G_TUNER);
 908         }
 909         if (in_type_counter[HDMI] == 0) {
 910                 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_S_EDID);
 911                 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_G_EDID);
 912                 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_DV_TIMINGS_CAP);
 913                 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_G_DV_TIMINGS);
 914                 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_S_DV_TIMINGS);
 915                 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_ENUM_DV_TIMINGS);
 916                 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_QUERY_DV_TIMINGS);
 917         }
 918         if (out_type_counter[HDMI] == 0) {
 919                 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_G_EDID);
 920                 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_DV_TIMINGS_CAP);
 921                 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_G_DV_TIMINGS);
 922                 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_S_DV_TIMINGS);
 923                 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_ENUM_DV_TIMINGS);
 924         }
 925         if (!dev->has_fb) {
 926                 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_G_FBUF);
 927                 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_S_FBUF);
 928                 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_OVERLAY);
 929         }
 930         v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_S_HW_FREQ_SEEK);
 931         v4l2_disable_ioctl(&dev->vbi_cap_dev, VIDIOC_S_HW_FREQ_SEEK);
 932         v4l2_disable_ioctl(&dev->sdr_cap_dev, VIDIOC_S_HW_FREQ_SEEK);
 933         v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_S_FREQUENCY);
 934         v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_G_FREQUENCY);
 935         v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_ENUM_FRAMESIZES);
 936         v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_ENUM_FRAMEINTERVALS);
 937         v4l2_disable_ioctl(&dev->vbi_out_dev, VIDIOC_S_FREQUENCY);
 938         v4l2_disable_ioctl(&dev->vbi_out_dev, VIDIOC_G_FREQUENCY);
 939
 940         /* configure internal data */
 941         dev->fmt_cap = &vivid_formats[0];
 942         dev->fmt_out = &vivid_formats[0];
 943         if (!dev->multiplanar)
 944                 vivid_formats[0].data_offset[0] = 0;
 945         dev->webcam_size_idx = 1;
 946         dev->webcam_ival_idx = 3;
 947         tpg_s_fourcc(&dev->tpg, dev->fmt_cap->fourcc);
 948         dev->std_cap = V4L2_STD_PAL;
 949         dev->std_out = V4L2_STD_PAL;
 950         if (dev->input_type[0] == TV || dev->input_type[0] == SVID)
 951                 tvnorms_cap = V4L2_STD_ALL;
 952         if (dev->output_type[0] == SVID)
 953                 tvnorms_out = V4L2_STD_ALL;
 954         dev->dv_timings_cap = def_dv_timings;
 955         dev->dv_timings_out = def_dv_timings;
 956         dev->tv_freq = 2804 /* 175.25 * 16 */;
 957         dev->tv_audmode = V4L2_TUNER_MODE_STEREO;
 958         dev->tv_field_cap = V4L2_FIELD_INTERLACED;
 959         dev->tv_field_out = V4L2_FIELD_INTERLACED;
 960         dev->radio_rx_freq = 95000 * 16;
 961         dev->radio_rx_audmode = V4L2_TUNER_MODE_STEREO;
 962         if (dev->has_radio_tx) {
 963                 dev->radio_tx_freq = 95500 * 16;
 964                 dev->radio_rds_loop = false;
 965         }
 966         dev->radio_tx_subchans = V4L2_TUNER_SUB_STEREO | V4L2_TUNER_SUB_RDS;
 967         dev->sdr_adc_freq = 300000;
 968         dev->sdr_fm_freq = 50000000;
 969         dev->edid_max_blocks = dev->edid_blocks = 2;
 970         memcpy(dev->edid, vivid_hdmi_edid, sizeof(vivid_hdmi_edid));
 971         ktime_get_ts(&dev->radio_rds_init_ts);
 972
 973         /* create all controls */
 974         ret = vivid_create_controls(dev, ccs_cap == -1, ccs_out == -1, no_error_inj,
 975                         in_type_counter[TV] || in_type_counter[SVID] ||
 976                         out_type_counter[SVID],
 977                         in_type_counter[HDMI] || out_type_counter[HDMI]);
 978         if (ret)
 979                 goto unreg_dev;
 980
 981         /*
 982          * update the capture and output formats to do a proper initial
 983          * configuration.
 984          */
 985         vivid_update_format_cap(dev, false);
 986         vivid_update_format_out(dev);
 987
 988         v4l2_ctrl_handler_setup(&dev->ctrl_hdl_vid_cap);
 989         v4l2_ctrl_handler_setup(&dev->ctrl_hdl_vid_out);
 990         v4l2_ctrl_handler_setup(&dev->ctrl_hdl_vbi_cap);
 991         v4l2_ctrl_handler_setup(&dev->ctrl_hdl_vbi_out);
 992         v4l2_ctrl_handler_setup(&dev->ctrl_hdl_radio_rx);
 993         v4l2_ctrl_handler_setup(&dev->ctrl_hdl_radio_tx);
 994         v4l2_ctrl_handler_setup(&dev->ctrl_hdl_sdr_cap);
 995
 996         /* initialize overlay */
 997         dev->fb_cap.fmt.width = dev->src_rect.width;
 998         dev->fb_cap.fmt.height = dev->src_rect.height;
 999         dev->fb_cap.fmt.pixelformat = dev->fmt_cap->fourcc;
1000         dev->fb_cap.fmt.bytesperline = dev->src_rect.width * tpg_g_twopixelsize(&dev->tpg, 0) / 2;
1001         dev->fb_cap.fmt.sizeimage = dev->src_rect.height * dev->fb_cap.fmt.bytesperline;
1002
1003         /* initialize locks */
1004         spin_lock_init(&dev->slock);
1005         mutex_init(&dev->mutex);
1006
1007         /* init dma queues */
1008         INIT_LIST_HEAD(&dev->vid_cap_active);
1009         INIT_LIST_HEAD(&dev->vid_out_active);
1010         INIT_LIST_HEAD(&dev->vbi_cap_active);
1011         INIT_LIST_HEAD(&dev->vbi_out_active);
1012         INIT_LIST_HEAD(&dev->sdr_cap_active);
1013
1014         /* start creating the vb2 queues */
1015         if (dev->has_vid_cap) {
1016                 /* initialize vid_cap queue */
1017                 q = &dev->vb_vid_cap_q;
1018                 q->type = dev->multiplanar ? V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE :
1019                         V4L2_BUF_TYPE_VIDEO_CAPTURE;
1020                 q->io_modes = VB2_MMAP | VB2_USERPTR | VB2_DMABUF | VB2_READ;
1021                 q->drv_priv = dev;
1022                 q->buf_struct_size = sizeof(struct vivid_buffer);
1023                 q->ops = &vivid_vid_cap_qops;
1024                 q->mem_ops = &vb2_vmalloc_memops;
1025                 q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1026                 q->min_buffers_needed = 2;
1027                 q->lock = &dev->mutex;
1028
1029                 ret = vb2_queue_init(q);
1030                 if (ret)
1031                         goto unreg_dev;
1032         }
1033
1034         if (dev->has_vid_out) {
1035                 /* initialize vid_out queue */
1036                 q = &dev->vb_vid_out_q;
1037                 q->type = dev->multiplanar ? V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE :
1038                         V4L2_BUF_TYPE_VIDEO_OUTPUT;
1039                 q->io_modes = VB2_MMAP | VB2_USERPTR | VB2_DMABUF | VB2_WRITE;
1040                 q->drv_priv = dev;
1041                 q->buf_struct_size = sizeof(struct vivid_buffer);
1042                 q->ops = &vivid_vid_out_qops;
1043                 q->mem_ops = &vb2_vmalloc_memops;
1044                 q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1045                 q->min_buffers_needed = 2;
1046                 q->lock = &dev->mutex;
1047
1048                 ret = vb2_queue_init(q);
1049                 if (ret)
1050                         goto unreg_dev;
1051         }
1052
1053         if (dev->has_vbi_cap) {
1054                 /* initialize vbi_cap queue */
1055                 q = &dev->vb_vbi_cap_q;
1056                 q->type = dev->has_raw_vbi_cap ? V4L2_BUF_TYPE_VBI_CAPTURE :
1057                                               V4L2_BUF_TYPE_SLICED_VBI_CAPTURE;
1058                 q->io_modes = VB2_MMAP | VB2_USERPTR | VB2_DMABUF | VB2_READ;
1059                 q->drv_priv = dev;
1060                 q->buf_struct_size = sizeof(struct vivid_buffer);
1061                 q->ops = &vivid_vbi_cap_qops;
1062                 q->mem_ops = &vb2_vmalloc_memops;
1063                 q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1064                 q->min_buffers_needed = 2;
1065                 q->lock = &dev->mutex;
1066
1067                 ret = vb2_queue_init(q);
1068                 if (ret)
1069                         goto unreg_dev;
1070         }
1071
1072         if (dev->has_vbi_out) {
1073                 /* initialize vbi_out queue */
1074                 q = &dev->vb_vbi_out_q;
1075                 q->type = dev->has_raw_vbi_out ? V4L2_BUF_TYPE_VBI_OUTPUT :
1076                                               V4L2_BUF_TYPE_SLICED_VBI_OUTPUT;
1077                 q->io_modes = VB2_MMAP | VB2_USERPTR | VB2_DMABUF | VB2_WRITE;
1078                 q->drv_priv = dev;
1079                 q->buf_struct_size = sizeof(struct vivid_buffer);
1080                 q->ops = &vivid_vbi_out_qops;
1081                 q->mem_ops = &vb2_vmalloc_memops;
1082                 q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1083                 q->min_buffers_needed = 2;
1084                 q->lock = &dev->mutex;
1085
1086                 ret = vb2_queue_init(q);
1087                 if (ret)
1088                         goto unreg_dev;
1089         }
1090
1091         if (dev->has_sdr_cap) {
1092                 /* initialize sdr_cap queue */
1093                 q = &dev->vb_sdr_cap_q;
1094                 q->type = V4L2_BUF_TYPE_SDR_CAPTURE;
1095                 q->io_modes = VB2_MMAP | VB2_USERPTR | VB2_DMABUF | VB2_READ;
1096                 q->drv_priv = dev;
1097                 q->buf_struct_size = sizeof(struct vivid_buffer);
1098                 q->ops = &vivid_sdr_cap_qops;
1099                 q->mem_ops = &vb2_vmalloc_memops;
1100                 q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1101                 q->min_buffers_needed = 8;
1102                 q->lock = &dev->mutex;
1103
1104                 ret = vb2_queue_init(q);
1105                 if (ret)
1106                         goto unreg_dev;
1107         }
1108
1109         if (dev->has_fb) {
1110                 /* Create framebuffer for testing capture/output overlay */
1111                 ret = vivid_fb_init(dev);
1112                 if (ret)
1113                         goto unreg_dev;
1114                 v4l2_info(&dev->v4l2_dev, "Framebuffer device registered as fb%d\n",
1115                                 dev->fb_info.node);
1116         }
1117
1118         /* finally start creating the device nodes */
1119         if (dev->has_vid_cap) {
1120                 vfd = &dev->vid_cap_dev;
1121                 strlcpy(vfd->name, "vivid-vid-cap", sizeof(vfd->name));
1122                 vfd->fops = &vivid_fops;
1123                 vfd->ioctl_ops = &vivid_ioctl_ops;
1124                 vfd->release = video_device_release_empty;
1125                 vfd->v4l2_dev = &dev->v4l2_dev;
1126                 vfd->queue = &dev->vb_vid_cap_q;
1127                 vfd->tvnorms = tvnorms_cap;
1128
1129                 /*
1130                  * Provide a mutex to v4l2 core. It will be used to protect
1131                  * all fops and v4l2 ioctls.
1132                  */
1133                 vfd->lock = &dev->mutex;
1134                 video_set_drvdata(vfd, dev);
1135
1136                 ret = video_register_device(vfd, VFL_TYPE_GRABBER, vid_cap_nr[inst]);
1137                 if (ret < 0)
1138                         goto unreg_dev;
1139                 v4l2_info(&dev->v4l2_dev, "V4L2 capture device registered as %s\n",
1140                                           video_device_node_name(vfd));
1141         }
1142
1143         if (dev->has_vid_out) {
1144                 vfd = &dev->vid_out_dev;
1145                 strlcpy(vfd->name, "vivid-vid-out", sizeof(vfd->name));
1146                 vfd->vfl_dir = VFL_DIR_TX;
1147                 vfd->fops = &vivid_fops;
1148                 vfd->ioctl_ops = &vivid_ioctl_ops;
1149                 vfd->release = video_device_release_empty;
1150                 vfd->v4l2_dev = &dev->v4l2_dev;
1151                 vfd->queue = &dev->vb_vid_out_q;
1152                 vfd->tvnorms = tvnorms_out;
1153
1154                 /*
1155                  * Provide a mutex to v4l2 core. It will be used to protect
1156                  * all fops and v4l2 ioctls.
1157                  */
1158                 vfd->lock = &dev->mutex;
1159                 video_set_drvdata(vfd, dev);
1160
1161                 ret = video_register_device(vfd, VFL_TYPE_GRABBER, vid_out_nr[inst]);
1162                 if (ret < 0)
1163                         goto unreg_dev;
1164                 v4l2_info(&dev->v4l2_dev, "V4L2 output device registered as %s\n",
1165                                           video_device_node_name(vfd));
1166         }
1167
1168         if (dev->has_vbi_cap) {
1169                 vfd = &dev->vbi_cap_dev;
1170                 strlcpy(vfd->name, "vivid-vbi-cap", sizeof(vfd->name));
1171                 vfd->fops = &vivid_fops;
1172                 vfd->ioctl_ops = &vivid_ioctl_ops;
1173                 vfd->release = video_device_release_empty;
1174                 vfd->v4l2_dev = &dev->v4l2_dev;
1175                 vfd->queue = &dev->vb_vbi_cap_q;
1176                 vfd->lock = &dev->mutex;
1177                 vfd->tvnorms = tvnorms_cap;
1178                 video_set_drvdata(vfd, dev);
1179
1180                 ret = video_register_device(vfd, VFL_TYPE_VBI, vbi_cap_nr[inst]);
1181                 if (ret < 0)
1182                         goto unreg_dev;
1183                 v4l2_info(&dev->v4l2_dev, "V4L2 capture device registered as %s, supports %s VBI\n",
1184                                           video_device_node_name(vfd),
1185                                           (dev->has_raw_vbi_cap && dev->has_sliced_vbi_cap) ?
1186                                           "raw and sliced" :
1187                                           (dev->has_raw_vbi_cap ? "raw" : "sliced"));
1188         }
1189
1190         if (dev->has_vbi_out) {
1191                 vfd = &dev->vbi_out_dev;
1192                 strlcpy(vfd->name, "vivid-vbi-out", sizeof(vfd->name));
1193                 vfd->vfl_dir = VFL_DIR_TX;
1194                 vfd->fops = &vivid_fops;
1195                 vfd->ioctl_ops = &vivid_ioctl_ops;
1196                 vfd->release = video_device_release_empty;
1197                 vfd->v4l2_dev = &dev->v4l2_dev;
1198                 vfd->queue = &dev->vb_vbi_out_q;
1199                 vfd->lock = &dev->mutex;
1200                 vfd->tvnorms = tvnorms_out;
1201                 video_set_drvdata(vfd, dev);
1202
1203                 ret = video_register_device(vfd, VFL_TYPE_VBI, vbi_out_nr[inst]);
1204                 if (ret < 0)
1205                         goto unreg_dev;
1206                 v4l2_info(&dev->v4l2_dev, "V4L2 output device registered as %s, supports %s VBI\n",
1207                                           video_device_node_name(vfd),
1208                                           (dev->has_raw_vbi_out && dev->has_sliced_vbi_out) ?
1209                                           "raw and sliced" :
1210                                           (dev->has_raw_vbi_out ? "raw" : "sliced"));
1211         }
1212
1213         if (dev->has_sdr_cap) {
1214                 vfd = &dev->sdr_cap_dev;
1215                 strlcpy(vfd->name, "vivid-sdr-cap", sizeof(vfd->name));
1216                 vfd->fops = &vivid_fops;
1217                 vfd->ioctl_ops = &vivid_ioctl_ops;
1218                 vfd->release = video_device_release_empty;
1219                 vfd->v4l2_dev = &dev->v4l2_dev;
1220                 vfd->queue = &dev->vb_sdr_cap_q;
1221                 vfd->lock = &dev->mutex;
1222                 video_set_drvdata(vfd, dev);
1223
1224                 ret = video_register_device(vfd, VFL_TYPE_SDR, sdr_cap_nr[inst]);
1225                 if (ret < 0)
1226                         goto unreg_dev;
1227                 v4l2_info(&dev->v4l2_dev, "V4L2 capture device registered as %s\n",
1228                                           video_device_node_name(vfd));
1229         }
1230
1231         if (dev->has_radio_rx) {
1232                 vfd = &dev->radio_rx_dev;
1233                 strlcpy(vfd->name, "vivid-rad-rx", sizeof(vfd->name));
1234                 vfd->fops = &vivid_radio_fops;
1235                 vfd->ioctl_ops = &vivid_ioctl_ops;
1236                 vfd->release = video_device_release_empty;
1237                 vfd->v4l2_dev = &dev->v4l2_dev;
1238                 vfd->lock = &dev->mutex;
1239                 video_set_drvdata(vfd, dev);
1240
1241                 ret = video_register_device(vfd, VFL_TYPE_RADIO, radio_rx_nr[inst]);
1242                 if (ret < 0)
1243                         goto unreg_dev;
1244                 v4l2_info(&dev->v4l2_dev, "V4L2 receiver device registered as %s\n",
1245                                           video_device_node_name(vfd));
1246         }
1247
1248         if (dev->has_radio_tx) {
1249                 vfd = &dev->radio_tx_dev;
1250                 strlcpy(vfd->name, "vivid-rad-tx", sizeof(vfd->name));
1251                 vfd->vfl_dir = VFL_DIR_TX;
1252                 vfd->fops = &vivid_radio_fops;
1253                 vfd->ioctl_ops = &vivid_ioctl_ops;
1254                 vfd->release = video_device_release_empty;
1255                 vfd->v4l2_dev = &dev->v4l2_dev;
1256                 vfd->lock = &dev->mutex;
1257                 video_set_drvdata(vfd, dev);
1258
1259                 ret = video_register_device(vfd, VFL_TYPE_RADIO, radio_tx_nr[inst]);
1260                 if (ret < 0)
1261                         goto unreg_dev;
1262                 v4l2_info(&dev->v4l2_dev, "V4L2 transmitter device registered as %s\n",
1263                                           video_device_node_name(vfd));
1264         }
1265
1266         /* Now that everything is fine, let's add it to device list */
1267         vivid_devs[inst] = dev;
1268
1269         return 0;
1270
1271 unreg_dev:
1272         video_unregister_device(&dev->radio_tx_dev);
1273         video_unregister_device(&dev->radio_rx_dev);
1274         video_unregister_device(&dev->sdr_cap_dev);
1275         video_unregister_device(&dev->vbi_out_dev);
1276         video_unregister_device(&dev->vbi_cap_dev);
1277         video_unregister_device(&dev->vid_out_dev);
1278         video_unregister_device(&dev->vid_cap_dev);
1279 free_dev:
1280         v4l2_device_put(&dev->v4l2_dev);
1281         return ret;
1282 }
1283
1284 /* This routine allocates from 1 to n_devs virtual drivers.
1285
1286    The real maximum number of virtual drivers will depend on how many drivers
1287    will succeed. This is limited to the maximum number of devices that
1288    videodev supports, which is equal to VIDEO_NUM_DEVICES.
1289  */
1290 static int vivid_probe(struct platform_device *pdev)
1291 {
1292         const struct font_desc *font = find_font("VGA8x16");
1293         int ret = 0, i;
1294
1295         if (font == NULL) {
1296                 pr_err("vivid: could not find font\n");
1297                 return -ENODEV;
1298         }
1299
1300         tpg_set_font(font->data);
1301
1302         n_devs = clamp_t(unsigned, n_devs, 1, VIVID_MAX_DEVS);
1303
1304         for (i = 0; i < n_devs; i++) {
1305                 ret = vivid_create_instance(pdev, i);
1306                 if (ret) {
1307                         /* If some instantiations succeeded, keep driver */
1308                         if (i)
1309                                 ret = 0;
1310                         break;
1311                 }
1312         }
1313
1314         if (ret < 0) {
1315                 pr_err("vivid: error %d while loading driver\n", ret);
1316                 return ret;
1317         }
1318
1319         /* n_devs will reflect the actual number of allocated devices */
1320         n_devs = i;
1321
1322         return ret;
1323 }
1324
1325 static int vivid_remove(struct platform_device *pdev)
1326 {
1327         struct vivid_dev *dev;
1328         unsigned i;
1329
1330         for (i = 0; vivid_devs[i]; i++) {
1331                 dev = vivid_devs[i];
1332
1333                 if (dev->has_vid_cap) {
1334                         v4l2_info(&dev->v4l2_dev, "unregistering %s\n",
1335                                 video_device_node_name(&dev->vid_cap_dev));
1336                         video_unregister_device(&dev->vid_cap_dev);
1337                 }
1338                 if (dev->has_vid_out) {
1339                         v4l2_info(&dev->v4l2_dev, "unregistering %s\n",
1340                                 video_device_node_name(&dev->vid_out_dev));
1341                         video_unregister_device(&dev->vid_out_dev);
1342                 }
1343                 if (dev->has_vbi_cap) {
1344                         v4l2_info(&dev->v4l2_dev, "unregistering %s\n",
1345                                 video_device_node_name(&dev->vbi_cap_dev));
1346                         video_unregister_device(&dev->vbi_cap_dev);
1347                 }
1348                 if (dev->has_vbi_out) {
1349                         v4l2_info(&dev->v4l2_dev, "unregistering %s\n",
1350                                 video_device_node_name(&dev->vbi_out_dev));
1351                         video_unregister_device(&dev->vbi_out_dev);
1352                 }
1353                 if (dev->has_sdr_cap) {
1354                         v4l2_info(&dev->v4l2_dev, "unregistering %s\n",
1355                                 video_device_node_name(&dev->sdr_cap_dev));
1356                         video_unregister_device(&dev->sdr_cap_dev);
1357                 }
1358                 if (dev->has_radio_rx) {
1359                         v4l2_info(&dev->v4l2_dev, "unregistering %s\n",
1360                                 video_device_node_name(&dev->radio_rx_dev));
1361                         video_unregister_device(&dev->radio_rx_dev);
1362                 }
1363                 if (dev->has_radio_tx) {
1364                         v4l2_info(&dev->v4l2_dev, "unregistering %s\n",
1365                                 video_device_node_name(&dev->radio_tx_dev));
1366                         video_unregister_device(&dev->radio_tx_dev);
1367                 }
1368                 if (dev->has_fb) {
1369                         v4l2_info(&dev->v4l2_dev, "unregistering fb%d\n",
1370                                 dev->fb_info.node);
1371                         unregister_framebuffer(&dev->fb_info);
1372                         vivid_fb_release_buffers(dev);
1373                 }
1374                 v4l2_device_put(&dev->v4l2_dev);
1375                 vivid_devs[i] = NULL;
1376         }
1377         return 0;
1378 }
1379
1380 static void vivid_pdev_release(struct device *dev)
1381 {
1382 }
1383
1384 static struct platform_device vivid_pdev = {
1385         .name           = "vivid",
1386         .dev.release    = vivid_pdev_release,
1387 };
1388
1389 static struct platform_driver vivid_pdrv = {
1390         .probe          = vivid_probe,
1391         .remove         = vivid_remove,
1392         .driver         = {
1393                 .name   = "vivid",
1394         },
1395 };
1396
1397 static int __init vivid_init(void)
1398 {
1399         int ret;
1400
1401         ret = platform_device_register(&vivid_pdev);
1402         if (ret)
1403                 return ret;
1404
1405         ret = platform_driver_register(&vivid_pdrv);
1406         if (ret)
1407                 platform_device_unregister(&vivid_pdev);
1408
1409         return ret;
1410 }
1411
1412 static void __exit vivid_exit(void)
1413 {
1414         platform_driver_unregister(&vivid_pdrv);
1415         platform_device_unregister(&vivid_pdev);
1416 }
1417
1418 module_init(vivid_init);
1419 module_exit(vivid_exit);