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         dev->num_hdmi_inputs = in_type_counter[HDMI];
 724
 725         /* how many outputs do we have and of what type? */
 726         dev->num_outputs = num_outputs[inst];
 727         if (dev->num_outputs < 1)
 728                 dev->num_outputs = 1;
 729         if (dev->num_outputs >= MAX_OUTPUTS)
 730                 dev->num_outputs = MAX_OUTPUTS;
 731         for (i = 0; i < dev->num_outputs; i++) {
 732                 dev->output_type[i] = ((output_types[inst] >> i) & 1) ? HDMI : SVID;
 733                 dev->output_name_counter[i] = out_type_counter[dev->output_type[i]]++;
 734                 dev->display_present[i] = true;
 735         }
 736         dev->has_audio_outputs = out_type_counter[SVID];
 737         if (out_type_counter[HDMI] == 16) {
 738                 /*
 739                  * The CEC physical address only allows for max 15 inputs,
 740                  * so outputs are also limited to 15 to allow for easy
 741                  * CEC output to input mapping.
 742                  */
 743                 out_type_counter[HDMI]--;
 744                 dev->num_outputs--;
 745         }
 746         dev->num_hdmi_outputs = out_type_counter[HDMI];
 747
 748         /* do we create a video capture device? */
 749         dev->has_vid_cap = node_type & 0x0001;
 750
 751         /* do we create a vbi capture device? */
 752         if (in_type_counter[TV] || in_type_counter[SVID]) {
 753                 dev->has_raw_vbi_cap = node_type & 0x0004;
 754                 dev->has_sliced_vbi_cap = node_type & 0x0008;
 755                 dev->has_vbi_cap = dev->has_raw_vbi_cap | dev->has_sliced_vbi_cap;
 756         }
 757
 758         /* do we create a video output device? */
 759         dev->has_vid_out = node_type & 0x0100;
 760
 761         /* do we create a vbi output device? */
 762         if (out_type_counter[SVID]) {
 763                 dev->has_raw_vbi_out = node_type & 0x0400;
 764                 dev->has_sliced_vbi_out = node_type & 0x0800;
 765                 dev->has_vbi_out = dev->has_raw_vbi_out | dev->has_sliced_vbi_out;
 766         }
 767
 768         /* do we create a radio receiver device? */
 769         dev->has_radio_rx = node_type & 0x0010;
 770
 771         /* do we create a radio transmitter device? */
 772         dev->has_radio_tx = node_type & 0x1000;
 773
 774         /* do we create a software defined radio capture device? */
 775         dev->has_sdr_cap = node_type & 0x0020;
 776
 777         /* do we have a tuner? */
 778         has_tuner = ((dev->has_vid_cap || dev->has_vbi_cap) && in_type_counter[TV]) ||
 779                     dev->has_radio_rx || dev->has_sdr_cap;
 780
 781         /* do we have a modulator? */
 782         has_modulator = dev->has_radio_tx;
 783
 784         if (dev->has_vid_cap)
 785                 /* do we have a framebuffer for overlay testing? */
 786                 dev->has_fb = node_type & 0x10000;
 787
 788         /* can we do crop/compose/scaling while capturing? */
 789         if (no_error_inj && ccs_cap == -1)
 790                 ccs_cap = 7;
 791
 792         /* if ccs_cap == -1, then the use can select it using controls */
 793         if (ccs_cap != -1) {
 794                 dev->has_crop_cap = ccs_cap & 1;
 795                 dev->has_compose_cap = ccs_cap & 2;
 796                 dev->has_scaler_cap = ccs_cap & 4;
 797                 v4l2_info(&dev->v4l2_dev, "Capture Crop: %c Compose: %c Scaler: %c\n",
 798                         dev->has_crop_cap ? 'Y' : 'N',
 799                         dev->has_compose_cap ? 'Y' : 'N',
 800                         dev->has_scaler_cap ? 'Y' : 'N');
 801         }
 802
 803         /* can we do crop/compose/scaling with video output? */
 804         if (no_error_inj && ccs_out == -1)
 805                 ccs_out = 7;
 806
 807         /* if ccs_out == -1, then the use can select it using controls */
 808         if (ccs_out != -1) {
 809                 dev->has_crop_out = ccs_out & 1;
 810                 dev->has_compose_out = ccs_out & 2;
 811                 dev->has_scaler_out = ccs_out & 4;
 812                 v4l2_info(&dev->v4l2_dev, "Output Crop: %c Compose: %c Scaler: %c\n",
 813                         dev->has_crop_out ? 'Y' : 'N',
 814                         dev->has_compose_out ? 'Y' : 'N',
 815                         dev->has_scaler_out ? 'Y' : 'N');
 816         }
 817
 818         /* end detecting feature set */
 819
 820         if (dev->has_vid_cap) {
 821                 /* set up the capabilities of the video capture device */
 822                 dev->vid_cap_caps = dev->multiplanar ?
 823                         V4L2_CAP_VIDEO_CAPTURE_MPLANE :
 824                         V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_VIDEO_OVERLAY;
 825                 dev->vid_cap_caps |= V4L2_CAP_STREAMING | V4L2_CAP_READWRITE;
 826                 if (dev->has_audio_inputs)
 827                         dev->vid_cap_caps |= V4L2_CAP_AUDIO;
 828                 if (in_type_counter[TV])
 829                         dev->vid_cap_caps |= V4L2_CAP_TUNER;
 830         }
 831         if (dev->has_vid_out) {
 832                 /* set up the capabilities of the video output device */
 833                 dev->vid_out_caps = dev->multiplanar ?
 834                         V4L2_CAP_VIDEO_OUTPUT_MPLANE :
 835                         V4L2_CAP_VIDEO_OUTPUT;
 836                 if (dev->has_fb)
 837                         dev->vid_out_caps |= V4L2_CAP_VIDEO_OUTPUT_OVERLAY;
 838                 dev->vid_out_caps |= V4L2_CAP_STREAMING | V4L2_CAP_READWRITE;
 839                 if (dev->has_audio_outputs)
 840                         dev->vid_out_caps |= V4L2_CAP_AUDIO;
 841         }
 842         if (dev->has_vbi_cap) {
 843                 /* set up the capabilities of the vbi capture device */
 844                 dev->vbi_cap_caps = (dev->has_raw_vbi_cap ? V4L2_CAP_VBI_CAPTURE : 0) |
 845                                     (dev->has_sliced_vbi_cap ? V4L2_CAP_SLICED_VBI_CAPTURE : 0);
 846                 dev->vbi_cap_caps |= V4L2_CAP_STREAMING | V4L2_CAP_READWRITE;
 847                 if (dev->has_audio_inputs)
 848                         dev->vbi_cap_caps |= V4L2_CAP_AUDIO;
 849                 if (in_type_counter[TV])
 850                         dev->vbi_cap_caps |= V4L2_CAP_TUNER;
 851         }
 852         if (dev->has_vbi_out) {
 853                 /* set up the capabilities of the vbi output device */
 854                 dev->vbi_out_caps = (dev->has_raw_vbi_out ? V4L2_CAP_VBI_OUTPUT : 0) |
 855                                     (dev->has_sliced_vbi_out ? V4L2_CAP_SLICED_VBI_OUTPUT : 0);
 856                 dev->vbi_out_caps |= V4L2_CAP_STREAMING | V4L2_CAP_READWRITE;
 857                 if (dev->has_audio_outputs)
 858                         dev->vbi_out_caps |= V4L2_CAP_AUDIO;
 859         }
 860         if (dev->has_sdr_cap) {
 861                 /* set up the capabilities of the sdr capture device */
 862                 dev->sdr_cap_caps = V4L2_CAP_SDR_CAPTURE | V4L2_CAP_TUNER;
 863                 dev->sdr_cap_caps |= V4L2_CAP_STREAMING | V4L2_CAP_READWRITE;
 864         }
 865         /* set up the capabilities of the radio receiver device */
 866         if (dev->has_radio_rx)
 867                 dev->radio_rx_caps = V4L2_CAP_RADIO | V4L2_CAP_RDS_CAPTURE |
 868                                      V4L2_CAP_HW_FREQ_SEEK | V4L2_CAP_TUNER |
 869                                      V4L2_CAP_READWRITE;
 870         /* set up the capabilities of the radio transmitter device */
 871         if (dev->has_radio_tx)
 872                 dev->radio_tx_caps = V4L2_CAP_RDS_OUTPUT | V4L2_CAP_MODULATOR |
 873                                      V4L2_CAP_READWRITE;
 874
 875         ret = -ENOMEM;
 876         /* initialize the test pattern generator */
 877         tpg_init(&dev->tpg, 640, 360);
 878         if (tpg_alloc(&dev->tpg, MAX_ZOOM * MAX_WIDTH))
 879                 goto free_dev;
 880         dev->scaled_line = vzalloc(array_size(MAX_WIDTH, MAX_ZOOM));
 881         if (!dev->scaled_line)
 882                 goto free_dev;
 883         dev->blended_line = vzalloc(array_size(MAX_WIDTH, MAX_ZOOM));
 884         if (!dev->blended_line)
 885                 goto free_dev;
 886
 887         /* load the edid */
 888         dev->edid = vmalloc(256 * 128);
 889         if (!dev->edid)
 890                 goto free_dev;
 891
 892         while (v4l2_dv_timings_presets[dev->query_dv_timings_size].bt.width)
 893                 dev->query_dv_timings_size++;
 894
 895         /*
 896          * Create a char pointer array that points to the names of all the
 897          * preset timings
 898          */
 899         dev->query_dv_timings_qmenu = kmalloc_array(dev->query_dv_timings_size,
 900                                                     sizeof(char *), GFP_KERNEL);
 901         /*
 902          * Create a string array containing the names of all the preset
 903          * timings. Each name is max 31 chars long (+ terminating 0).
 904          */
 905         dev->query_dv_timings_qmenu_strings =
 906                 kmalloc_array(dev->query_dv_timings_size, 32, GFP_KERNEL);
 907
 908         if (!dev->query_dv_timings_qmenu ||
 909             !dev->query_dv_timings_qmenu_strings)
 910                 goto free_dev;
 911
 912         for (i = 0; i < dev->query_dv_timings_size; i++) {
 913                 const struct v4l2_bt_timings *bt = &v4l2_dv_timings_presets[i].bt;
 914                 char *p = dev->query_dv_timings_qmenu_strings + i * 32;
 915                 u32 htot, vtot;
 916
 917                 dev->query_dv_timings_qmenu[i] = p;
 918
 919                 htot = V4L2_DV_BT_FRAME_WIDTH(bt);
 920                 vtot = V4L2_DV_BT_FRAME_HEIGHT(bt);
 921                 snprintf(p, 32, "%ux%u%s%u",
 922                         bt->width, bt->height, bt->interlaced ? "i" : "p",
 923                         (u32)bt->pixelclock / (htot * vtot));
 924         }
 925
 926         /* disable invalid ioctls based on the feature set */
 927         if (!dev->has_audio_inputs) {
 928                 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_S_AUDIO);
 929                 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_G_AUDIO);
 930                 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_ENUMAUDIO);
 931                 v4l2_disable_ioctl(&dev->vbi_cap_dev, VIDIOC_S_AUDIO);
 932                 v4l2_disable_ioctl(&dev->vbi_cap_dev, VIDIOC_G_AUDIO);
 933                 v4l2_disable_ioctl(&dev->vbi_cap_dev, VIDIOC_ENUMAUDIO);
 934         }
 935         if (!dev->has_audio_outputs) {
 936                 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_S_AUDOUT);
 937                 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_G_AUDOUT);
 938                 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_ENUMAUDOUT);
 939                 v4l2_disable_ioctl(&dev->vbi_out_dev, VIDIOC_S_AUDOUT);
 940                 v4l2_disable_ioctl(&dev->vbi_out_dev, VIDIOC_G_AUDOUT);
 941                 v4l2_disable_ioctl(&dev->vbi_out_dev, VIDIOC_ENUMAUDOUT);
 942         }
 943         if (!in_type_counter[TV] && !in_type_counter[SVID]) {
 944                 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_S_STD);
 945                 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_G_STD);
 946                 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_ENUMSTD);
 947                 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_QUERYSTD);
 948         }
 949         if (!out_type_counter[SVID]) {
 950                 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_S_STD);
 951                 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_G_STD);
 952                 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_ENUMSTD);
 953         }
 954         if (!has_tuner && !has_modulator) {
 955                 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_S_FREQUENCY);
 956                 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_G_FREQUENCY);
 957                 v4l2_disable_ioctl(&dev->vbi_cap_dev, VIDIOC_S_FREQUENCY);
 958                 v4l2_disable_ioctl(&dev->vbi_cap_dev, VIDIOC_G_FREQUENCY);
 959         }
 960         if (!has_tuner) {
 961                 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_S_TUNER);
 962                 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_G_TUNER);
 963                 v4l2_disable_ioctl(&dev->vbi_cap_dev, VIDIOC_S_TUNER);
 964                 v4l2_disable_ioctl(&dev->vbi_cap_dev, VIDIOC_G_TUNER);
 965         }
 966         if (in_type_counter[HDMI] == 0) {
 967                 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_S_EDID);
 968                 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_G_EDID);
 969                 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_DV_TIMINGS_CAP);
 970                 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_G_DV_TIMINGS);
 971                 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_S_DV_TIMINGS);
 972                 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_ENUM_DV_TIMINGS);
 973                 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_QUERY_DV_TIMINGS);
 974         }
 975         if (out_type_counter[HDMI] == 0) {
 976                 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_G_EDID);
 977                 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_DV_TIMINGS_CAP);
 978                 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_G_DV_TIMINGS);
 979                 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_S_DV_TIMINGS);
 980                 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_ENUM_DV_TIMINGS);
 981         }
 982         if (!dev->has_fb) {
 983                 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_G_FBUF);
 984                 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_S_FBUF);
 985                 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_OVERLAY);
 986         }
 987         v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_S_HW_FREQ_SEEK);
 988         v4l2_disable_ioctl(&dev->vbi_cap_dev, VIDIOC_S_HW_FREQ_SEEK);
 989         v4l2_disable_ioctl(&dev->sdr_cap_dev, VIDIOC_S_HW_FREQ_SEEK);
 990         v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_S_FREQUENCY);
 991         v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_G_FREQUENCY);
 992         v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_ENUM_FRAMESIZES);
 993         v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_ENUM_FRAMEINTERVALS);
 994         v4l2_disable_ioctl(&dev->vbi_out_dev, VIDIOC_S_FREQUENCY);
 995         v4l2_disable_ioctl(&dev->vbi_out_dev, VIDIOC_G_FREQUENCY);
 996
 997         /* configure internal data */
 998         dev->fmt_cap = &vivid_formats[0];
 999         dev->fmt_out = &vivid_formats[0];
1000         if (!dev->multiplanar)
1001                 vivid_formats[0].data_offset[0] = 0;
1002         dev->webcam_size_idx = 1;
1003         dev->webcam_ival_idx = 3;
1004         tpg_s_fourcc(&dev->tpg, dev->fmt_cap->fourcc);
1005         dev->std_out = V4L2_STD_PAL;
1006         if (dev->input_type[0] == TV || dev->input_type[0] == SVID)
1007                 tvnorms_cap = V4L2_STD_ALL;
1008         if (dev->output_type[0] == SVID)
1009                 tvnorms_out = V4L2_STD_ALL;
1010         for (i = 0; i < MAX_INPUTS; i++) {
1011                 dev->dv_timings_cap[i] = def_dv_timings;
1012                 dev->std_cap[i] = V4L2_STD_PAL;
1013         }
1014         dev->dv_timings_out = def_dv_timings;
1015         dev->tv_freq = 2804 /* 175.25 * 16 */;
1016         dev->tv_audmode = V4L2_TUNER_MODE_STEREO;
1017         dev->tv_field_cap = V4L2_FIELD_INTERLACED;
1018         dev->tv_field_out = V4L2_FIELD_INTERLACED;
1019         dev->radio_rx_freq = 95000 * 16;
1020         dev->radio_rx_audmode = V4L2_TUNER_MODE_STEREO;
1021         if (dev->has_radio_tx) {
1022                 dev->radio_tx_freq = 95500 * 16;
1023                 dev->radio_rds_loop = false;
1024         }
1025         dev->radio_tx_subchans = V4L2_TUNER_SUB_STEREO | V4L2_TUNER_SUB_RDS;
1026         dev->sdr_adc_freq = 300000;
1027         dev->sdr_fm_freq = 50000000;
1028         dev->sdr_pixelformat = V4L2_SDR_FMT_CU8;
1029         dev->sdr_buffersize = SDR_CAP_SAMPLES_PER_BUF * 2;
1030
1031         dev->edid_max_blocks = dev->edid_blocks = 2;
1032         memcpy(dev->edid, vivid_hdmi_edid, sizeof(vivid_hdmi_edid));
1033         dev->radio_rds_init_time = ktime_get();
1034
1035         /* create all controls */
1036         ret = vivid_create_controls(dev, ccs_cap == -1, ccs_out == -1, no_error_inj,
1037                         in_type_counter[TV] || in_type_counter[SVID] ||
1038                         out_type_counter[SVID],
1039                         in_type_counter[HDMI] || out_type_counter[HDMI]);
1040         if (ret)
1041                 goto unreg_dev;
1042
1043         /* enable/disable interface specific controls */
1044         if (dev->num_outputs && dev->output_type[0] != HDMI)
1045                 v4l2_ctrl_activate(dev->ctrl_display_present, false);
1046         if (dev->num_inputs && dev->input_type[0] != HDMI) {
1047                 v4l2_ctrl_activate(dev->ctrl_dv_timings_signal_mode, false);
1048                 v4l2_ctrl_activate(dev->ctrl_dv_timings, false);
1049         } else if (dev->num_inputs && dev->input_type[0] == HDMI) {
1050                 v4l2_ctrl_activate(dev->ctrl_std_signal_mode, false);
1051                 v4l2_ctrl_activate(dev->ctrl_standard, false);
1052         }
1053
1054         /*
1055          * update the capture and output formats to do a proper initial
1056          * configuration.
1057          */
1058         vivid_update_format_cap(dev, false);
1059         vivid_update_format_out(dev);
1060
1061         v4l2_ctrl_handler_setup(&dev->ctrl_hdl_vid_cap);
1062         v4l2_ctrl_handler_setup(&dev->ctrl_hdl_vid_out);
1063         v4l2_ctrl_handler_setup(&dev->ctrl_hdl_vbi_cap);
1064         v4l2_ctrl_handler_setup(&dev->ctrl_hdl_vbi_out);
1065         v4l2_ctrl_handler_setup(&dev->ctrl_hdl_radio_rx);
1066         v4l2_ctrl_handler_setup(&dev->ctrl_hdl_radio_tx);
1067         v4l2_ctrl_handler_setup(&dev->ctrl_hdl_sdr_cap);
1068
1069         /* initialize overlay */
1070         dev->fb_cap.fmt.width = dev->src_rect.width;
1071         dev->fb_cap.fmt.height = dev->src_rect.height;
1072         dev->fb_cap.fmt.pixelformat = dev->fmt_cap->fourcc;
1073         dev->fb_cap.fmt.bytesperline = dev->src_rect.width * tpg_g_twopixelsize(&dev->tpg, 0) / 2;
1074         dev->fb_cap.fmt.sizeimage = dev->src_rect.height * dev->fb_cap.fmt.bytesperline;
1075
1076         /* initialize locks */
1077         spin_lock_init(&dev->slock);
1078         mutex_init(&dev->mutex);
1079
1080         /* init dma queues */
1081         INIT_LIST_HEAD(&dev->vid_cap_active);
1082         INIT_LIST_HEAD(&dev->vid_out_active);
1083         INIT_LIST_HEAD(&dev->vbi_cap_active);
1084         INIT_LIST_HEAD(&dev->vbi_out_active);
1085         INIT_LIST_HEAD(&dev->sdr_cap_active);
1086
1087         INIT_LIST_HEAD(&dev->cec_work_list);
1088         spin_lock_init(&dev->cec_slock);
1089         /*
1090          * Same as create_singlethread_workqueue, but now I can use the
1091          * string formatting of alloc_ordered_workqueue.
1092          */
1093         dev->cec_workqueue =
1094                 alloc_ordered_workqueue("vivid-%03d-cec", WQ_MEM_RECLAIM, inst);
1095         if (!dev->cec_workqueue) {
1096                 ret = -ENOMEM;
1097                 goto unreg_dev;
1098         }
1099
1100         if (allocator == 1)
1101                 dma_coerce_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32));
1102         else if (allocator >= ARRAY_SIZE(vivid_mem_ops))
1103                 allocator = 0;
1104
1105         /* start creating the vb2 queues */
1106         if (dev->has_vid_cap) {
1107                 /* initialize vid_cap queue */
1108                 q = &dev->vb_vid_cap_q;
1109                 q->type = dev->multiplanar ? V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE :
1110                         V4L2_BUF_TYPE_VIDEO_CAPTURE;
1111                 q->io_modes = VB2_MMAP | VB2_DMABUF | VB2_READ;
1112                 if (!allocator)
1113                         q->io_modes |= VB2_USERPTR;
1114                 q->drv_priv = dev;
1115                 q->buf_struct_size = sizeof(struct vivid_buffer);
1116                 q->ops = &vivid_vid_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_vid_out) {
1130                 /* initialize vid_out queue */
1131                 q = &dev->vb_vid_out_q;
1132                 q->type = dev->multiplanar ? V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE :
1133                         V4L2_BUF_TYPE_VIDEO_OUTPUT;
1134                 q->io_modes = VB2_MMAP | VB2_DMABUF | VB2_WRITE;
1135                 if (!allocator)
1136                         q->io_modes |= VB2_USERPTR;
1137                 q->drv_priv = dev;
1138                 q->buf_struct_size = sizeof(struct vivid_buffer);
1139                 q->ops = &vivid_vid_out_qops;
1140                 q->mem_ops = vivid_mem_ops[allocator];
1141                 q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1142                 q->min_buffers_needed = 2;
1143                 q->lock = &dev->mutex;
1144                 q->dev = dev->v4l2_dev.dev;
1145                 q->supports_requests = true;
1146
1147                 ret = vb2_queue_init(q);
1148                 if (ret)
1149                         goto unreg_dev;
1150         }
1151
1152         if (dev->has_vbi_cap) {
1153                 /* initialize vbi_cap queue */
1154                 q = &dev->vb_vbi_cap_q;
1155                 q->type = dev->has_raw_vbi_cap ? V4L2_BUF_TYPE_VBI_CAPTURE :
1156                                               V4L2_BUF_TYPE_SLICED_VBI_CAPTURE;
1157                 q->io_modes = VB2_MMAP | VB2_DMABUF | VB2_READ;
1158                 if (!allocator)
1159                         q->io_modes |= VB2_USERPTR;
1160                 q->drv_priv = dev;
1161                 q->buf_struct_size = sizeof(struct vivid_buffer);
1162                 q->ops = &vivid_vbi_cap_qops;
1163                 q->mem_ops = vivid_mem_ops[allocator];
1164                 q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1165                 q->min_buffers_needed = 2;
1166                 q->lock = &dev->mutex;
1167                 q->dev = dev->v4l2_dev.dev;
1168                 q->supports_requests = true;
1169
1170                 ret = vb2_queue_init(q);
1171                 if (ret)
1172                         goto unreg_dev;
1173         }
1174
1175         if (dev->has_vbi_out) {
1176                 /* initialize vbi_out queue */
1177                 q = &dev->vb_vbi_out_q;
1178                 q->type = dev->has_raw_vbi_out ? V4L2_BUF_TYPE_VBI_OUTPUT :
1179                                               V4L2_BUF_TYPE_SLICED_VBI_OUTPUT;
1180                 q->io_modes = VB2_MMAP | VB2_DMABUF | VB2_WRITE;
1181                 if (!allocator)
1182                         q->io_modes |= VB2_USERPTR;
1183                 q->drv_priv = dev;
1184                 q->buf_struct_size = sizeof(struct vivid_buffer);
1185                 q->ops = &vivid_vbi_out_qops;
1186                 q->mem_ops = vivid_mem_ops[allocator];
1187                 q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1188                 q->min_buffers_needed = 2;
1189                 q->lock = &dev->mutex;
1190                 q->dev = dev->v4l2_dev.dev;
1191                 q->supports_requests = true;
1192
1193                 ret = vb2_queue_init(q);
1194                 if (ret)
1195                         goto unreg_dev;
1196         }
1197
1198         if (dev->has_sdr_cap) {
1199                 /* initialize sdr_cap queue */
1200                 q = &dev->vb_sdr_cap_q;
1201                 q->type = V4L2_BUF_TYPE_SDR_CAPTURE;
1202                 q->io_modes = VB2_MMAP | VB2_DMABUF | VB2_READ;
1203                 if (!allocator)
1204                         q->io_modes |= VB2_USERPTR;
1205                 q->drv_priv = dev;
1206                 q->buf_struct_size = sizeof(struct vivid_buffer);
1207                 q->ops = &vivid_sdr_cap_qops;
1208                 q->mem_ops = vivid_mem_ops[allocator];
1209                 q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1210                 q->min_buffers_needed = 8;
1211                 q->lock = &dev->mutex;
1212                 q->dev = dev->v4l2_dev.dev;
1213                 q->supports_requests = true;
1214
1215                 ret = vb2_queue_init(q);
1216                 if (ret)
1217                         goto unreg_dev;
1218         }
1219
1220         if (dev->has_fb) {
1221                 /* Create framebuffer for testing capture/output overlay */
1222                 ret = vivid_fb_init(dev);
1223                 if (ret)
1224                         goto unreg_dev;
1225                 v4l2_info(&dev->v4l2_dev, "Framebuffer device registered as fb%d\n",
1226                                 dev->fb_info.node);
1227         }
1228
1229         /* finally start creating the device nodes */
1230         if (dev->has_vid_cap) {
1231                 vfd = &dev->vid_cap_dev;
1232                 snprintf(vfd->name, sizeof(vfd->name),
1233                          "vivid-%03d-vid-cap", inst);
1234                 vfd->fops = &vivid_fops;
1235                 vfd->ioctl_ops = &vivid_ioctl_ops;
1236                 vfd->device_caps = dev->vid_cap_caps;
1237                 vfd->release = video_device_release_empty;
1238                 vfd->v4l2_dev = &dev->v4l2_dev;
1239                 vfd->queue = &dev->vb_vid_cap_q;
1240                 vfd->tvnorms = tvnorms_cap;
1241
1242                 /*
1243                  * Provide a mutex to v4l2 core. It will be used to protect
1244                  * all fops and v4l2 ioctls.
1245                  */
1246                 vfd->lock = &dev->mutex;
1247                 video_set_drvdata(vfd, dev);
1248
1249 #ifdef CONFIG_MEDIA_CONTROLLER
1250                 dev->vid_cap_pad.flags = MEDIA_PAD_FL_SINK;
1251                 ret = media_entity_pads_init(&vfd->entity, 1, &dev->vid_cap_pad);
1252                 if (ret)
1253                         goto unreg_dev;
1254 #endif
1255
1256 #ifdef CONFIG_VIDEO_VIVID_CEC
1257                 if (in_type_counter[HDMI]) {
1258                         struct cec_adapter *adap;
1259
1260                         adap = vivid_cec_alloc_adap(dev, 0, false);
1261                         ret = PTR_ERR_OR_ZERO(adap);
1262                         if (ret < 0)
1263                                 goto unreg_dev;
1264                         dev->cec_rx_adap = adap;
1265                         ret = cec_register_adapter(adap, &pdev->dev);
1266                         if (ret < 0) {
1267                                 cec_delete_adapter(adap);
1268                                 dev->cec_rx_adap = NULL;
1269                                 goto unreg_dev;
1270                         }
1271                         cec_s_phys_addr(adap, 0, false);
1272                         v4l2_info(&dev->v4l2_dev, "CEC adapter %s registered for HDMI input 0\n",
1273                                   dev_name(&adap->devnode.dev));
1274                 }
1275 #endif
1276
1277                 ret = video_register_device(vfd, VFL_TYPE_GRABBER, vid_cap_nr[inst]);
1278                 if (ret < 0)
1279                         goto unreg_dev;
1280                 v4l2_info(&dev->v4l2_dev, "V4L2 capture device registered as %s\n",
1281                                           video_device_node_name(vfd));
1282         }
1283
1284         if (dev->has_vid_out) {
1285 #ifdef CONFIG_VIDEO_VIVID_CEC
1286                 unsigned int bus_cnt = 0;
1287 #endif
1288
1289                 vfd = &dev->vid_out_dev;
1290                 snprintf(vfd->name, sizeof(vfd->name),
1291                          "vivid-%03d-vid-out", inst);
1292                 vfd->vfl_dir = VFL_DIR_TX;
1293                 vfd->fops = &vivid_fops;
1294                 vfd->ioctl_ops = &vivid_ioctl_ops;
1295                 vfd->device_caps = dev->vid_out_caps;
1296                 vfd->release = video_device_release_empty;
1297                 vfd->v4l2_dev = &dev->v4l2_dev;
1298                 vfd->queue = &dev->vb_vid_out_q;
1299                 vfd->tvnorms = tvnorms_out;
1300
1301                 /*
1302                  * Provide a mutex to v4l2 core. It will be used to protect
1303                  * all fops and v4l2 ioctls.
1304                  */
1305                 vfd->lock = &dev->mutex;
1306                 video_set_drvdata(vfd, dev);
1307
1308 #ifdef CONFIG_MEDIA_CONTROLLER
1309                 dev->vid_out_pad.flags = MEDIA_PAD_FL_SOURCE;
1310                 ret = media_entity_pads_init(&vfd->entity, 1, &dev->vid_out_pad);
1311                 if (ret)
1312                         goto unreg_dev;
1313 #endif
1314
1315 #ifdef CONFIG_VIDEO_VIVID_CEC
1316                 for (i = 0; i < dev->num_outputs; i++) {
1317                         struct cec_adapter *adap;
1318
1319                         if (dev->output_type[i] != HDMI)
1320                                 continue;
1321                         dev->cec_output2bus_map[i] = bus_cnt;
1322                         adap = vivid_cec_alloc_adap(dev, bus_cnt, true);
1323                         ret = PTR_ERR_OR_ZERO(adap);
1324                         if (ret < 0)
1325                                 goto unreg_dev;
1326                         dev->cec_tx_adap[bus_cnt] = adap;
1327                         ret = cec_register_adapter(adap, &pdev->dev);
1328                         if (ret < 0) {
1329                                 cec_delete_adapter(adap);
1330                                 dev->cec_tx_adap[bus_cnt] = NULL;
1331                                 goto unreg_dev;
1332                         }
1333                         v4l2_info(&dev->v4l2_dev, "CEC adapter %s registered for HDMI output %d\n",
1334                                   dev_name(&adap->devnode.dev), bus_cnt);
1335                         bus_cnt++;
1336                         if (bus_cnt <= out_type_counter[HDMI])
1337                                 cec_s_phys_addr(adap, bus_cnt << 12, false);
1338                         else
1339                                 cec_s_phys_addr(adap, 0x1000, false);
1340                 }
1341 #endif
1342
1343                 ret = video_register_device(vfd, VFL_TYPE_GRABBER, vid_out_nr[inst]);
1344                 if (ret < 0)
1345                         goto unreg_dev;
1346                 v4l2_info(&dev->v4l2_dev, "V4L2 output device registered as %s\n",
1347                                           video_device_node_name(vfd));
1348         }
1349
1350         if (dev->has_vbi_cap) {
1351                 vfd = &dev->vbi_cap_dev;
1352                 snprintf(vfd->name, sizeof(vfd->name),
1353                          "vivid-%03d-vbi-cap", inst);
1354                 vfd->fops = &vivid_fops;
1355                 vfd->ioctl_ops = &vivid_ioctl_ops;
1356                 vfd->device_caps = dev->vbi_cap_caps;
1357                 vfd->release = video_device_release_empty;
1358                 vfd->v4l2_dev = &dev->v4l2_dev;
1359                 vfd->queue = &dev->vb_vbi_cap_q;
1360                 vfd->lock = &dev->mutex;
1361                 vfd->tvnorms = tvnorms_cap;
1362                 video_set_drvdata(vfd, dev);
1363
1364 #ifdef CONFIG_MEDIA_CONTROLLER
1365                 dev->vbi_cap_pad.flags = MEDIA_PAD_FL_SINK;
1366                 ret = media_entity_pads_init(&vfd->entity, 1, &dev->vbi_cap_pad);
1367                 if (ret)
1368                         goto unreg_dev;
1369 #endif
1370
1371                 ret = video_register_device(vfd, VFL_TYPE_VBI, vbi_cap_nr[inst]);
1372                 if (ret < 0)
1373                         goto unreg_dev;
1374                 v4l2_info(&dev->v4l2_dev, "V4L2 capture device registered as %s, supports %s VBI\n",
1375                                           video_device_node_name(vfd),
1376                                           (dev->has_raw_vbi_cap && dev->has_sliced_vbi_cap) ?
1377                                           "raw and sliced" :
1378                                           (dev->has_raw_vbi_cap ? "raw" : "sliced"));
1379         }
1380
1381         if (dev->has_vbi_out) {
1382                 vfd = &dev->vbi_out_dev;
1383                 snprintf(vfd->name, sizeof(vfd->name),
1384                          "vivid-%03d-vbi-out", inst);
1385                 vfd->vfl_dir = VFL_DIR_TX;
1386                 vfd->fops = &vivid_fops;
1387                 vfd->ioctl_ops = &vivid_ioctl_ops;
1388                 vfd->device_caps = dev->vbi_out_caps;
1389                 vfd->release = video_device_release_empty;
1390                 vfd->v4l2_dev = &dev->v4l2_dev;
1391                 vfd->queue = &dev->vb_vbi_out_q;
1392                 vfd->lock = &dev->mutex;
1393                 vfd->tvnorms = tvnorms_out;
1394                 video_set_drvdata(vfd, dev);
1395
1396 #ifdef CONFIG_MEDIA_CONTROLLER
1397                 dev->vbi_out_pad.flags = MEDIA_PAD_FL_SOURCE;
1398                 ret = media_entity_pads_init(&vfd->entity, 1, &dev->vbi_out_pad);
1399                 if (ret)
1400                         goto unreg_dev;
1401 #endif
1402
1403                 ret = video_register_device(vfd, VFL_TYPE_VBI, vbi_out_nr[inst]);
1404                 if (ret < 0)
1405                         goto unreg_dev;
1406                 v4l2_info(&dev->v4l2_dev, "V4L2 output device registered as %s, supports %s VBI\n",
1407                                           video_device_node_name(vfd),
1408                                           (dev->has_raw_vbi_out && dev->has_sliced_vbi_out) ?
1409                                           "raw and sliced" :
1410                                           (dev->has_raw_vbi_out ? "raw" : "sliced"));
1411         }
1412
1413         if (dev->has_sdr_cap) {
1414                 vfd = &dev->sdr_cap_dev;
1415                 snprintf(vfd->name, sizeof(vfd->name),
1416                          "vivid-%03d-sdr-cap", inst);
1417                 vfd->fops = &vivid_fops;
1418                 vfd->ioctl_ops = &vivid_ioctl_ops;
1419                 vfd->device_caps = dev->sdr_cap_caps;
1420                 vfd->release = video_device_release_empty;
1421                 vfd->v4l2_dev = &dev->v4l2_dev;
1422                 vfd->queue = &dev->vb_sdr_cap_q;
1423                 vfd->lock = &dev->mutex;
1424                 video_set_drvdata(vfd, dev);
1425
1426 #ifdef CONFIG_MEDIA_CONTROLLER
1427                 dev->sdr_cap_pad.flags = MEDIA_PAD_FL_SINK;
1428                 ret = media_entity_pads_init(&vfd->entity, 1, &dev->sdr_cap_pad);
1429                 if (ret)
1430                         goto unreg_dev;
1431 #endif
1432
1433                 ret = video_register_device(vfd, VFL_TYPE_SDR, sdr_cap_nr[inst]);
1434                 if (ret < 0)
1435                         goto unreg_dev;
1436                 v4l2_info(&dev->v4l2_dev, "V4L2 capture device registered as %s\n",
1437                                           video_device_node_name(vfd));
1438         }
1439
1440         if (dev->has_radio_rx) {
1441                 vfd = &dev->radio_rx_dev;
1442                 snprintf(vfd->name, sizeof(vfd->name),
1443                          "vivid-%03d-rad-rx", inst);
1444                 vfd->fops = &vivid_radio_fops;
1445                 vfd->ioctl_ops = &vivid_ioctl_ops;
1446                 vfd->device_caps = dev->radio_rx_caps;
1447                 vfd->release = video_device_release_empty;
1448                 vfd->v4l2_dev = &dev->v4l2_dev;
1449                 vfd->lock = &dev->mutex;
1450                 video_set_drvdata(vfd, dev);
1451
1452                 ret = video_register_device(vfd, VFL_TYPE_RADIO, radio_rx_nr[inst]);
1453                 if (ret < 0)
1454                         goto unreg_dev;
1455                 v4l2_info(&dev->v4l2_dev, "V4L2 receiver device registered as %s\n",
1456                                           video_device_node_name(vfd));
1457         }
1458
1459         if (dev->has_radio_tx) {
1460                 vfd = &dev->radio_tx_dev;
1461                 snprintf(vfd->name, sizeof(vfd->name),
1462                          "vivid-%03d-rad-tx", inst);
1463                 vfd->vfl_dir = VFL_DIR_TX;
1464                 vfd->fops = &vivid_radio_fops;
1465                 vfd->ioctl_ops = &vivid_ioctl_ops;
1466                 vfd->device_caps = dev->radio_tx_caps;
1467                 vfd->release = video_device_release_empty;
1468                 vfd->v4l2_dev = &dev->v4l2_dev;
1469                 vfd->lock = &dev->mutex;
1470                 video_set_drvdata(vfd, dev);
1471
1472                 ret = video_register_device(vfd, VFL_TYPE_RADIO, radio_tx_nr[inst]);
1473                 if (ret < 0)
1474                         goto unreg_dev;
1475                 v4l2_info(&dev->v4l2_dev, "V4L2 transmitter device registered as %s\n",
1476                                           video_device_node_name(vfd));
1477         }
1478
1479 #ifdef CONFIG_MEDIA_CONTROLLER
1480         /* Register the media device */
1481         ret = media_device_register(&dev->mdev);
1482         if (ret) {
1483                 dev_err(dev->mdev.dev,
1484                         "media device register failed (err=%d)\n", ret);
1485                 goto unreg_dev;
1486         }
1487 #endif
1488
1489         /* Now that everything is fine, let's add it to device list */
1490         vivid_devs[inst] = dev;
1491
1492         return 0;
1493
1494 unreg_dev:
1495         video_unregister_device(&dev->radio_tx_dev);
1496         video_unregister_device(&dev->radio_rx_dev);
1497         video_unregister_device(&dev->sdr_cap_dev);
1498         video_unregister_device(&dev->vbi_out_dev);
1499         video_unregister_device(&dev->vbi_cap_dev);
1500         video_unregister_device(&dev->vid_out_dev);
1501         video_unregister_device(&dev->vid_cap_dev);
1502         cec_unregister_adapter(dev->cec_rx_adap);
1503         for (i = 0; i < MAX_OUTPUTS; i++)
1504                 cec_unregister_adapter(dev->cec_tx_adap[i]);
1505         if (dev->cec_workqueue) {
1506                 vivid_cec_bus_free_work(dev);
1507                 destroy_workqueue(dev->cec_workqueue);
1508         }
1509 free_dev:
1510         v4l2_device_put(&dev->v4l2_dev);
1511         return ret;
1512 }
1513
1514 /* This routine allocates from 1 to n_devs virtual drivers.
1515
1516    The real maximum number of virtual drivers will depend on how many drivers
1517    will succeed. This is limited to the maximum number of devices that
1518    videodev supports, which is equal to VIDEO_NUM_DEVICES.
1519  */
1520 static int vivid_probe(struct platform_device *pdev)
1521 {
1522         const struct font_desc *font = find_font("VGA8x16");
1523         int ret = 0, i;
1524
1525         if (font == NULL) {
1526                 pr_err("vivid: could not find font\n");
1527                 return -ENODEV;
1528         }
1529
1530         tpg_set_font(font->data);
1531
1532         n_devs = clamp_t(unsigned, n_devs, 1, VIVID_MAX_DEVS);
1533
1534         for (i = 0; i < n_devs; i++) {
1535                 ret = vivid_create_instance(pdev, i);
1536                 if (ret) {
1537                         /* If some instantiations succeeded, keep driver */
1538                         if (i)
1539                                 ret = 0;
1540                         break;
1541                 }
1542         }
1543
1544         if (ret < 0) {
1545                 pr_err("vivid: error %d while loading driver\n", ret);
1546                 return ret;
1547         }
1548
1549         /* n_devs will reflect the actual number of allocated devices */
1550         n_devs = i;
1551
1552         return ret;
1553 }
1554
1555 static int vivid_remove(struct platform_device *pdev)
1556 {
1557         struct vivid_dev *dev;
1558         unsigned int i, j;
1559
1560         for (i = 0; i < n_devs; i++) {
1561                 dev = vivid_devs[i];
1562                 if (!dev)
1563                         continue;
1564
1565 #ifdef CONFIG_MEDIA_CONTROLLER
1566                 media_device_unregister(&dev->mdev);
1567                 media_device_cleanup(&dev->mdev);
1568 #endif
1569
1570                 if (dev->has_vid_cap) {
1571                         v4l2_info(&dev->v4l2_dev, "unregistering %s\n",
1572                                 video_device_node_name(&dev->vid_cap_dev));
1573                         video_unregister_device(&dev->vid_cap_dev);
1574                 }
1575                 if (dev->has_vid_out) {
1576                         v4l2_info(&dev->v4l2_dev, "unregistering %s\n",
1577                                 video_device_node_name(&dev->vid_out_dev));
1578                         video_unregister_device(&dev->vid_out_dev);
1579                 }
1580                 if (dev->has_vbi_cap) {
1581                         v4l2_info(&dev->v4l2_dev, "unregistering %s\n",
1582                                 video_device_node_name(&dev->vbi_cap_dev));
1583                         video_unregister_device(&dev->vbi_cap_dev);
1584                 }
1585                 if (dev->has_vbi_out) {
1586                         v4l2_info(&dev->v4l2_dev, "unregistering %s\n",
1587                                 video_device_node_name(&dev->vbi_out_dev));
1588                         video_unregister_device(&dev->vbi_out_dev);
1589                 }
1590                 if (dev->has_sdr_cap) {
1591                         v4l2_info(&dev->v4l2_dev, "unregistering %s\n",
1592                                 video_device_node_name(&dev->sdr_cap_dev));
1593                         video_unregister_device(&dev->sdr_cap_dev);
1594                 }
1595                 if (dev->has_radio_rx) {
1596                         v4l2_info(&dev->v4l2_dev, "unregistering %s\n",
1597                                 video_device_node_name(&dev->radio_rx_dev));
1598                         video_unregister_device(&dev->radio_rx_dev);
1599                 }
1600                 if (dev->has_radio_tx) {
1601                         v4l2_info(&dev->v4l2_dev, "unregistering %s\n",
1602                                 video_device_node_name(&dev->radio_tx_dev));
1603                         video_unregister_device(&dev->radio_tx_dev);
1604                 }
1605                 if (dev->has_fb) {
1606                         v4l2_info(&dev->v4l2_dev, "unregistering fb%d\n",
1607                                 dev->fb_info.node);
1608                         unregister_framebuffer(&dev->fb_info);
1609                         vivid_fb_release_buffers(dev);
1610                 }
1611                 cec_unregister_adapter(dev->cec_rx_adap);
1612                 for (j = 0; j < MAX_OUTPUTS; j++)
1613                         cec_unregister_adapter(dev->cec_tx_adap[j]);
1614                 if (dev->cec_workqueue) {
1615                         vivid_cec_bus_free_work(dev);
1616                         destroy_workqueue(dev->cec_workqueue);
1617                 }
1618                 v4l2_device_put(&dev->v4l2_dev);
1619                 vivid_devs[i] = NULL;
1620         }
1621         return 0;
1622 }
1623
1624 static void vivid_pdev_release(struct device *dev)
1625 {
1626 }
1627
1628 static struct platform_device vivid_pdev = {
1629         .name           = "vivid",
1630         .dev.release    = vivid_pdev_release,
1631 };
1632
1633 static struct platform_driver vivid_pdrv = {
1634         .probe          = vivid_probe,
1635         .remove         = vivid_remove,
1636         .driver         = {
1637                 .name   = "vivid",
1638         },
1639 };
1640
1641 static int __init vivid_init(void)
1642 {
1643         int ret;
1644
1645         ret = platform_device_register(&vivid_pdev);
1646         if (ret)
1647                 return ret;
1648
1649         ret = platform_driver_register(&vivid_pdrv);
1650         if (ret)
1651                 platform_device_unregister(&vivid_pdev);
1652
1653         return ret;
1654 }
1655
1656 static void __exit vivid_exit(void)
1657 {
1658         platform_driver_unregister(&vivid_pdrv);
1659         platform_device_unregister(&vivid_pdev);
1660 }
1661
1662 module_init(vivid_init);
1663 module_exit(vivid_exit);