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

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