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