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