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