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