linux/drivers/media/platform/vivid/vivid-core.c
<<
>>
Prefs
   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
  46MODULE_DESCRIPTION("Virtual Video Test Driver");
  47MODULE_AUTHOR("Hans Verkuil");
  48MODULE_LICENSE("GPL");
  49
  50static unsigned n_devs = 1;
  51module_param(n_devs, uint, 0444);
  52MODULE_PARM_DESC(n_devs, " number of driver instances to create");
  53
  54static int vid_cap_nr[VIVID_MAX_DEVS] = { [0 ... (VIVID_MAX_DEVS - 1)] = -1 };
  55module_param_array(vid_cap_nr, int, NULL, 0444);
  56MODULE_PARM_DESC(vid_cap_nr, " videoX start number, -1 is autodetect");
  57
  58static int vid_out_nr[VIVID_MAX_DEVS] = { [0 ... (VIVID_MAX_DEVS - 1)] = -1 };
  59module_param_array(vid_out_nr, int, NULL, 0444);
  60MODULE_PARM_DESC(vid_out_nr, " videoX start number, -1 is autodetect");
  61
  62static int vbi_cap_nr[VIVID_MAX_DEVS] = { [0 ... (VIVID_MAX_DEVS - 1)] = -1 };
  63module_param_array(vbi_cap_nr, int, NULL, 0444);
  64MODULE_PARM_DESC(vbi_cap_nr, " vbiX start number, -1 is autodetect");
  65
  66static int vbi_out_nr[VIVID_MAX_DEVS] = { [0 ... (VIVID_MAX_DEVS - 1)] = -1 };
  67module_param_array(vbi_out_nr, int, NULL, 0444);
  68MODULE_PARM_DESC(vbi_out_nr, " vbiX start number, -1 is autodetect");
  69
  70static int sdr_cap_nr[VIVID_MAX_DEVS] = { [0 ... (VIVID_MAX_DEVS - 1)] = -1 };
  71module_param_array(sdr_cap_nr, int, NULL, 0444);
  72MODULE_PARM_DESC(sdr_cap_nr, " swradioX start number, -1 is autodetect");
  73
  74static int radio_rx_nr[VIVID_MAX_DEVS] = { [0 ... (VIVID_MAX_DEVS - 1)] = -1 };
  75module_param_array(radio_rx_nr, int, NULL, 0444);
  76MODULE_PARM_DESC(radio_rx_nr, " radioX start number, -1 is autodetect");
  77
  78static int radio_tx_nr[VIVID_MAX_DEVS] = { [0 ... (VIVID_MAX_DEVS - 1)] = -1 };
  79module_param_array(radio_tx_nr, int, NULL, 0444);
  80MODULE_PARM_DESC(radio_tx_nr, " radioX start number, -1 is autodetect");
  81
  82static int ccs_cap_mode[VIVID_MAX_DEVS] = { [0 ... (VIVID_MAX_DEVS - 1)] = -1 };
  83module_param_array(ccs_cap_mode, int, NULL, 0444);
  84MODULE_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
  88static int ccs_out_mode[VIVID_MAX_DEVS] = { [0 ... (VIVID_MAX_DEVS - 1)] = -1 };
  89module_param_array(ccs_out_mode, int, NULL, 0444);
  90MODULE_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
  94static unsigned multiplanar[VIVID_MAX_DEVS] = { [0 ... (VIVID_MAX_DEVS - 1)] = 1 };
  95module_param_array(multiplanar, uint, NULL, 0444);
  96MODULE_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 */
  99static unsigned node_types[VIVID_MAX_DEVS] = { [0 ... (VIVID_MAX_DEVS - 1)] = 0x1d3d };
 100module_param_array(node_types, uint, NULL, 0444);
 101MODULE_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 */
 112static unsigned num_inputs[VIVID_MAX_DEVS] = { [0 ... (VIVID_MAX_DEVS - 1)] = 4 };
 113module_param_array(num_inputs, uint, NULL, 0444);
 114MODULE_PARM_DESC(num_inputs, " number of inputs, default is 4");
 115
 116/* Default: input 0 = WEBCAM, 1 = TV, 2 = SVID, 3 = HDMI */
 117static unsigned input_types[VIVID_MAX_DEVS] = { [0 ... (VIVID_MAX_DEVS - 1)] = 0xe4 };
 118module_param_array(input_types, uint, NULL, 0444);
 119MODULE_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 */
 124static unsigned num_outputs[VIVID_MAX_DEVS] = { [0 ... (VIVID_MAX_DEVS - 1)] = 2 };
 125module_param_array(num_outputs, uint, NULL, 0444);
 126MODULE_PARM_DESC(num_outputs, " number of outputs, default is 2");
 127
 128/* Default: output 0 = SVID, 1 = HDMI */
 129static unsigned output_types[VIVID_MAX_DEVS] = { [0 ... (VIVID_MAX_DEVS - 1)] = 2 };
 130module_param_array(output_types, uint, NULL, 0444);
 131MODULE_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
 135unsigned vivid_debug;
 136module_param(vivid_debug, uint, 0644);
 137MODULE_PARM_DESC(vivid_debug, " activates debug info");
 138
 139static bool no_error_inj;
 140module_param(no_error_inj, bool, 0444);
 141MODULE_PARM_DESC(no_error_inj, " if set disable the error injecting controls");
 142
 143static unsigned int allocators[VIVID_MAX_DEVS] = { [0 ... (VIVID_MAX_DEVS - 1)] = 0 };
 144module_param_array(allocators, uint, NULL, 0444);
 145MODULE_PARM_DESC(allocators, " memory allocator selection, default is 0.\n"
 146                             "\t\t    0 == vmalloc\n"
 147                             "\t\t    1 == dma-contig");
 148
 149static struct vivid_dev *vivid_devs[VIVID_MAX_DEVS];
 150
 151const struct v4l2_rect vivid_min_rect = {
 152        0, 0, MIN_WIDTH, MIN_HEIGHT
 153};
 154
 155const struct v4l2_rect vivid_max_rect = {
 156        0, 0, MAX_WIDTH * MAX_ZOOM, MAX_HEIGHT * MAX_ZOOM
 157};
 158
 159static 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
 195static 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
 212static 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
 221static 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
 232static 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
 243static 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
 254static 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
 268static 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
 282static 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
 291static 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
 300static 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
 309static 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
 318static 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
 327static 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
 337static 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
 347static 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
 357static 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
 367static 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
 377static 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
 388static 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
 398static 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
 408static __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
 417static 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
 428static 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
 441static 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
 479static 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
 490static 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
 500static 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
 613static 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
 631static 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
 642static const struct media_device_ops vivid_media_ops = {
 643        .req_validate = vivid_req_validate,
 644        .req_queue = vb2_request_queue,
 645};
 646#endif
 647
 648static 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 user 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 user 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                snprintf(dev->vid_cap_dev.name, sizeof(dev->vid_cap_dev.name),
1103                         "vivid-%03d-vid-cap", inst);
1104                /* initialize vid_cap queue */
1105                q = &dev->vb_vid_cap_q;
1106                q->type = dev->multiplanar ? V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE :
1107                        V4L2_BUF_TYPE_VIDEO_CAPTURE;
1108                q->io_modes = VB2_MMAP | VB2_DMABUF | VB2_READ;
1109                if (!allocator)
1110                        q->io_modes |= VB2_USERPTR;
1111                q->drv_priv = dev;
1112                q->buf_struct_size = sizeof(struct vivid_buffer);
1113                q->ops = &vivid_vid_cap_qops;
1114                q->mem_ops = vivid_mem_ops[allocator];
1115                q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1116                q->min_buffers_needed = 2;
1117                q->lock = &dev->mutex;
1118                q->dev = dev->v4l2_dev.dev;
1119                q->supports_requests = true;
1120
1121                ret = vb2_queue_init(q);
1122                if (ret)
1123                        goto unreg_dev;
1124        }
1125
1126        if (dev->has_vid_out) {
1127                snprintf(dev->vid_out_dev.name, sizeof(dev->vid_out_dev.name),
1128                         "vivid-%03d-vid-out", inst);
1129                /* initialize vid_out queue */
1130                q = &dev->vb_vid_out_q;
1131                q->type = dev->multiplanar ? V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE :
1132                        V4L2_BUF_TYPE_VIDEO_OUTPUT;
1133                q->io_modes = VB2_MMAP | VB2_DMABUF | VB2_WRITE;
1134                if (!allocator)
1135                        q->io_modes |= VB2_USERPTR;
1136                q->drv_priv = dev;
1137                q->buf_struct_size = sizeof(struct vivid_buffer);
1138                q->ops = &vivid_vid_out_qops;
1139                q->mem_ops = vivid_mem_ops[allocator];
1140                q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1141                q->min_buffers_needed = 2;
1142                q->lock = &dev->mutex;
1143                q->dev = dev->v4l2_dev.dev;
1144                q->supports_requests = true;
1145
1146                ret = vb2_queue_init(q);
1147                if (ret)
1148                        goto unreg_dev;
1149        }
1150
1151        if (dev->has_vbi_cap) {
1152                /* initialize vbi_cap queue */
1153                q = &dev->vb_vbi_cap_q;
1154                q->type = dev->has_raw_vbi_cap ? V4L2_BUF_TYPE_VBI_CAPTURE :
1155                                              V4L2_BUF_TYPE_SLICED_VBI_CAPTURE;
1156                q->io_modes = VB2_MMAP | VB2_DMABUF | VB2_READ;
1157                if (!allocator)
1158                        q->io_modes |= VB2_USERPTR;
1159                q->drv_priv = dev;
1160                q->buf_struct_size = sizeof(struct vivid_buffer);
1161                q->ops = &vivid_vbi_cap_qops;
1162                q->mem_ops = vivid_mem_ops[allocator];
1163                q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1164                q->min_buffers_needed = 2;
1165                q->lock = &dev->mutex;
1166                q->dev = dev->v4l2_dev.dev;
1167                q->supports_requests = true;
1168
1169                ret = vb2_queue_init(q);
1170                if (ret)
1171                        goto unreg_dev;
1172        }
1173
1174        if (dev->has_vbi_out) {
1175                /* initialize vbi_out queue */
1176                q = &dev->vb_vbi_out_q;
1177                q->type = dev->has_raw_vbi_out ? V4L2_BUF_TYPE_VBI_OUTPUT :
1178                                              V4L2_BUF_TYPE_SLICED_VBI_OUTPUT;
1179                q->io_modes = VB2_MMAP | VB2_DMABUF | VB2_WRITE;
1180                if (!allocator)
1181                        q->io_modes |= VB2_USERPTR;
1182                q->drv_priv = dev;
1183                q->buf_struct_size = sizeof(struct vivid_buffer);
1184                q->ops = &vivid_vbi_out_qops;
1185                q->mem_ops = vivid_mem_ops[allocator];
1186                q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1187                q->min_buffers_needed = 2;
1188                q->lock = &dev->mutex;
1189                q->dev = dev->v4l2_dev.dev;
1190                q->supports_requests = true;
1191
1192                ret = vb2_queue_init(q);
1193                if (ret)
1194                        goto unreg_dev;
1195        }
1196
1197        if (dev->has_sdr_cap) {
1198                /* initialize sdr_cap queue */
1199                q = &dev->vb_sdr_cap_q;
1200                q->type = V4L2_BUF_TYPE_SDR_CAPTURE;
1201                q->io_modes = VB2_MMAP | VB2_DMABUF | VB2_READ;
1202                if (!allocator)
1203                        q->io_modes |= VB2_USERPTR;
1204                q->drv_priv = dev;
1205                q->buf_struct_size = sizeof(struct vivid_buffer);
1206                q->ops = &vivid_sdr_cap_qops;
1207                q->mem_ops = vivid_mem_ops[allocator];
1208                q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1209                q->min_buffers_needed = 8;
1210                q->lock = &dev->mutex;
1211                q->dev = dev->v4l2_dev.dev;
1212                q->supports_requests = true;
1213
1214                ret = vb2_queue_init(q);
1215                if (ret)
1216                        goto unreg_dev;
1217        }
1218
1219        if (dev->has_fb) {
1220                /* Create framebuffer for testing capture/output overlay */
1221                ret = vivid_fb_init(dev);
1222                if (ret)
1223                        goto unreg_dev;
1224                v4l2_info(&dev->v4l2_dev, "Framebuffer device registered as fb%d\n",
1225                                dev->fb_info.node);
1226        }
1227
1228#ifdef CONFIG_VIDEO_VIVID_CEC
1229        if (dev->has_vid_cap && in_type_counter[HDMI]) {
1230                struct cec_adapter *adap;
1231
1232                adap = vivid_cec_alloc_adap(dev, 0, false);
1233                ret = PTR_ERR_OR_ZERO(adap);
1234                if (ret < 0)
1235                        goto unreg_dev;
1236                dev->cec_rx_adap = adap;
1237        }
1238
1239        if (dev->has_vid_out) {
1240                for (i = 0; i < dev->num_outputs; i++) {
1241                        struct cec_adapter *adap;
1242
1243                        if (dev->output_type[i] != HDMI)
1244                                continue;
1245
1246                        dev->cec_output2bus_map[i] = cec_tx_bus_cnt;
1247                        adap = vivid_cec_alloc_adap(dev, cec_tx_bus_cnt, true);
1248                        ret = PTR_ERR_OR_ZERO(adap);
1249                        if (ret < 0) {
1250                                for (i = 0; i < dev->num_outputs; i++)
1251                                        cec_delete_adapter(dev->cec_tx_adap[i]);
1252                                goto unreg_dev;
1253                        }
1254
1255                        dev->cec_tx_adap[cec_tx_bus_cnt] = adap;
1256                        cec_tx_bus_cnt++;
1257                }
1258        }
1259#endif
1260
1261        v4l2_ctrl_handler_setup(&dev->ctrl_hdl_vid_cap);
1262        v4l2_ctrl_handler_setup(&dev->ctrl_hdl_vid_out);
1263        v4l2_ctrl_handler_setup(&dev->ctrl_hdl_vbi_cap);
1264        v4l2_ctrl_handler_setup(&dev->ctrl_hdl_vbi_out);
1265        v4l2_ctrl_handler_setup(&dev->ctrl_hdl_radio_rx);
1266        v4l2_ctrl_handler_setup(&dev->ctrl_hdl_radio_tx);
1267        v4l2_ctrl_handler_setup(&dev->ctrl_hdl_sdr_cap);
1268
1269        /* finally start creating the device nodes */
1270        if (dev->has_vid_cap) {
1271                vfd = &dev->vid_cap_dev;
1272                vfd->fops = &vivid_fops;
1273                vfd->ioctl_ops = &vivid_ioctl_ops;
1274                vfd->device_caps = dev->vid_cap_caps;
1275                vfd->release = video_device_release_empty;
1276                vfd->v4l2_dev = &dev->v4l2_dev;
1277                vfd->queue = &dev->vb_vid_cap_q;
1278                vfd->tvnorms = tvnorms_cap;
1279
1280                /*
1281                 * Provide a mutex to v4l2 core. It will be used to protect
1282                 * all fops and v4l2 ioctls.
1283                 */
1284                vfd->lock = &dev->mutex;
1285                video_set_drvdata(vfd, dev);
1286
1287#ifdef CONFIG_MEDIA_CONTROLLER
1288                dev->vid_cap_pad.flags = MEDIA_PAD_FL_SINK;
1289                ret = media_entity_pads_init(&vfd->entity, 1, &dev->vid_cap_pad);
1290                if (ret)
1291                        goto unreg_dev;
1292#endif
1293
1294#ifdef CONFIG_VIDEO_VIVID_CEC
1295                if (in_type_counter[HDMI]) {
1296                        ret = cec_register_adapter(dev->cec_rx_adap, &pdev->dev);
1297                        if (ret < 0) {
1298                                cec_delete_adapter(dev->cec_rx_adap);
1299                                dev->cec_rx_adap = NULL;
1300                                goto unreg_dev;
1301                        }
1302                        cec_s_phys_addr(dev->cec_rx_adap, 0, false);
1303                        v4l2_info(&dev->v4l2_dev, "CEC adapter %s registered for HDMI input 0\n",
1304                                  dev_name(&dev->cec_rx_adap->devnode.dev));
1305                }
1306#endif
1307
1308                ret = video_register_device(vfd, VFL_TYPE_GRABBER, vid_cap_nr[inst]);
1309                if (ret < 0)
1310                        goto unreg_dev;
1311                v4l2_info(&dev->v4l2_dev, "V4L2 capture device registered as %s\n",
1312                                          video_device_node_name(vfd));
1313        }
1314
1315        if (dev->has_vid_out) {
1316                vfd = &dev->vid_out_dev;
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
1510unreg_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        }
1525free_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 */
1536static 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
1571static 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
1640static void vivid_pdev_release(struct device *dev)
1641{
1642}
1643
1644static struct platform_device vivid_pdev = {
1645        .name           = "vivid",
1646        .dev.release    = vivid_pdev_release,
1647};
1648
1649static struct platform_driver vivid_pdrv = {
1650        .probe          = vivid_probe,
1651        .remove         = vivid_remove,
1652        .driver         = {
1653                .name   = "vivid",
1654        },
1655};
1656
1657static 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
1672static void __exit vivid_exit(void)
1673{
1674        platform_driver_unregister(&vivid_pdrv);
1675        platform_device_unregister(&vivid_pdev);
1676}
1677
1678module_init(vivid_init);
1679module_exit(vivid_exit);
1680