1/* 2 * vivid-core.c - A Virtual Video Test Driver, core initialization 3 * 4 * Copyright 2014 Cisco Systems, Inc. and/or its affiliates. All rights reserved. 5 * 6 * This program is free software; you may redistribute it and/or modify 7 * it under the terms of the GNU General Public License as published by 8 * the Free Software Foundation; version 2 of the License. 9 * 10 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 11 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 12 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 13 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS 14 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN 15 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 16 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 17 * SOFTWARE. 18 */ 19 20#include <linux/module.h> 21#include <linux/errno.h> 22#include <linux/kernel.h> 23#include <linux/init.h> 24#include <linux/sched.h> 25#include <linux/slab.h> 26#include <linux/vmalloc.h> 27#include <linux/font.h> 28#include <linux/mutex.h> 29#include <linux/platform_device.h> 30#include <linux/videodev2.h> 31#include <linux/v4l2-dv-timings.h> 32#include <media/videobuf2-vmalloc.h> 33#include <media/v4l2-dv-timings.h> 34#include <media/v4l2-ioctl.h> 35#include <media/v4l2-fh.h> 36#include <media/v4l2-event.h> 37 38#include "vivid-core.h" 39#include "vivid-vid-common.h" 40#include "vivid-vid-cap.h" 41#include "vivid-vid-out.h" 42#include "vivid-radio-common.h" 43#include "vivid-radio-rx.h" 44#include "vivid-radio-tx.h" 45#include "vivid-sdr-cap.h" 46#include "vivid-vbi-cap.h" 47#include "vivid-vbi-out.h" 48#include "vivid-osd.h" 49#include "vivid-ctrls.h" 50 51#define VIVID_MODULE_NAME "vivid" 52 53/* The maximum number of vivid devices */ 54#define VIVID_MAX_DEVS 64 55 56MODULE_DESCRIPTION("Virtual Video Test Driver"); 57MODULE_AUTHOR("Hans Verkuil"); 58MODULE_LICENSE("GPL"); 59 60static unsigned n_devs = 1; 61module_param(n_devs, uint, 0444); 62MODULE_PARM_DESC(n_devs, " number of driver instances to create"); 63 64static int vid_cap_nr[VIVID_MAX_DEVS] = { [0 ... (VIVID_MAX_DEVS - 1)] = -1 }; 65module_param_array(vid_cap_nr, int, NULL, 0444); 66MODULE_PARM_DESC(vid_cap_nr, " videoX start number, -1 is autodetect"); 67 68static int vid_out_nr[VIVID_MAX_DEVS] = { [0 ... (VIVID_MAX_DEVS - 1)] = -1 }; 69module_param_array(vid_out_nr, int, NULL, 0444); 70MODULE_PARM_DESC(vid_out_nr, " videoX start number, -1 is autodetect"); 71 72static int vbi_cap_nr[VIVID_MAX_DEVS] = { [0 ... (VIVID_MAX_DEVS - 1)] = -1 }; 73module_param_array(vbi_cap_nr, int, NULL, 0444); 74MODULE_PARM_DESC(vbi_cap_nr, " vbiX start number, -1 is autodetect"); 75 76static int vbi_out_nr[VIVID_MAX_DEVS] = { [0 ... (VIVID_MAX_DEVS - 1)] = -1 }; 77module_param_array(vbi_out_nr, int, NULL, 0444); 78MODULE_PARM_DESC(vbi_out_nr, " vbiX start number, -1 is autodetect"); 79 80static int sdr_cap_nr[VIVID_MAX_DEVS] = { [0 ... (VIVID_MAX_DEVS - 1)] = -1 }; 81module_param_array(sdr_cap_nr, int, NULL, 0444); 82MODULE_PARM_DESC(sdr_cap_nr, " swradioX start number, -1 is autodetect"); 83 84static int radio_rx_nr[VIVID_MAX_DEVS] = { [0 ... (VIVID_MAX_DEVS - 1)] = -1 }; 85module_param_array(radio_rx_nr, int, NULL, 0444); 86MODULE_PARM_DESC(radio_rx_nr, " radioX start number, -1 is autodetect"); 87 88static int radio_tx_nr[VIVID_MAX_DEVS] = { [0 ... (VIVID_MAX_DEVS - 1)] = -1 }; 89module_param_array(radio_tx_nr, int, NULL, 0444); 90MODULE_PARM_DESC(radio_tx_nr, " radioX start number, -1 is autodetect"); 91 92static int ccs_cap_mode[VIVID_MAX_DEVS] = { [0 ... (VIVID_MAX_DEVS - 1)] = -1 }; 93module_param_array(ccs_cap_mode, int, NULL, 0444); 94MODULE_PARM_DESC(ccs_cap_mode, " capture crop/compose/scale mode:\n" 95 "\t\t bit 0=crop, 1=compose, 2=scale,\n" 96 "\t\t -1=user-controlled (default)"); 97 98static int ccs_out_mode[VIVID_MAX_DEVS] = { [0 ... (VIVID_MAX_DEVS - 1)] = -1 }; 99module_param_array(ccs_out_mode, int, NULL, 0444); 100MODULE_PARM_DESC(ccs_out_mode, " output crop/compose/scale mode:\n" 101 "\t\t bit 0=crop, 1=compose, 2=scale,\n" 102 "\t\t -1=user-controlled (default)"); 103 104static unsigned multiplanar[VIVID_MAX_DEVS] = { [0 ... (VIVID_MAX_DEVS - 1)] = 1 }; 105module_param_array(multiplanar, uint, NULL, 0444); 106MODULE_PARM_DESC(multiplanar, " 1 (default) creates a single planar device, 2 creates a multiplanar device."); 107 108/* Default: video + vbi-cap (raw and sliced) + radio rx + radio tx + sdr + vbi-out + vid-out */ 109static unsigned node_types[VIVID_MAX_DEVS] = { [0 ... (VIVID_MAX_DEVS - 1)] = 0x1d3d }; 110module_param_array(node_types, uint, NULL, 0444); 111MODULE_PARM_DESC(node_types, " node types, default is 0x1d3d. Bitmask with the following meaning:\n" 112 "\t\t bit 0: Video Capture node\n" 113 "\t\t bit 2-3: VBI Capture node: 0 = none, 1 = raw vbi, 2 = sliced vbi, 3 = both\n" 114 "\t\t bit 4: Radio Receiver node\n" 115 "\t\t bit 5: Software Defined Radio Receiver node\n" 116 "\t\t bit 8: Video Output node\n" 117 "\t\t bit 10-11: VBI Output node: 0 = none, 1 = raw vbi, 2 = sliced vbi, 3 = both\n" 118 "\t\t bit 12: Radio Transmitter node\n" 119 "\t\t bit 16: Framebuffer for testing overlays"); 120 121/* Default: 4 inputs */ 122static unsigned num_inputs[VIVID_MAX_DEVS] = { [0 ... (VIVID_MAX_DEVS - 1)] = 4 }; 123module_param_array(num_inputs, uint, NULL, 0444); 124MODULE_PARM_DESC(num_inputs, " number of inputs, default is 4"); 125 126/* Default: input 0 = WEBCAM, 1 = TV, 2 = SVID, 3 = HDMI */ 127static unsigned input_types[VIVID_MAX_DEVS] = { [0 ... (VIVID_MAX_DEVS - 1)] = 0xe4 }; 128module_param_array(input_types, uint, NULL, 0444); 129MODULE_PARM_DESC(input_types, " input types, default is 0xe4. Two bits per input,\n" 130 "\t\t bits 0-1 == input 0, bits 31-30 == input 15.\n" 131 "\t\t Type 0 == webcam, 1 == TV, 2 == S-Video, 3 == HDMI"); 132 133/* Default: 2 outputs */ 134static unsigned num_outputs[VIVID_MAX_DEVS] = { [0 ... (VIVID_MAX_DEVS - 1)] = 2 }; 135module_param_array(num_outputs, uint, NULL, 0444); 136MODULE_PARM_DESC(num_outputs, " number of outputs, default is 2"); 137 138/* Default: output 0 = SVID, 1 = HDMI */ 139static unsigned output_types[VIVID_MAX_DEVS] = { [0 ... (VIVID_MAX_DEVS - 1)] = 2 }; 140module_param_array(output_types, uint, NULL, 0444); 141MODULE_PARM_DESC(output_types, " output types, default is 0x02. One bit per output,\n" 142 "\t\t bit 0 == output 0, bit 15 == output 15.\n" 143 "\t\t Type 0 == S-Video, 1 == HDMI"); 144 145unsigned vivid_debug; 146module_param(vivid_debug, uint, 0644); 147MODULE_PARM_DESC(vivid_debug, " activates debug info"); 148 149static bool no_error_inj; 150module_param(no_error_inj, bool, 0444); 151MODULE_PARM_DESC(no_error_inj, " if set disable the error injecting controls"); 152 153static struct vivid_dev *vivid_devs[VIVID_MAX_DEVS]; 154 155const struct v4l2_rect vivid_min_rect = { 156 0, 0, MIN_WIDTH, MIN_HEIGHT 157}; 158 159const struct v4l2_rect vivid_max_rect = { 160 0, 0, MAX_WIDTH * MAX_ZOOM, MAX_HEIGHT * MAX_ZOOM 161}; 162 163static const u8 vivid_hdmi_edid[256] = { 164 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 165 0x63, 0x3a, 0xaa, 0x55, 0x00, 0x00, 0x00, 0x00, 166 0x0a, 0x18, 0x01, 0x03, 0x80, 0x10, 0x09, 0x78, 167 0x0e, 0x00, 0xb2, 0xa0, 0x57, 0x49, 0x9b, 0x26, 168 0x10, 0x48, 0x4f, 0x2f, 0xcf, 0x00, 0x31, 0x59, 169 0x45, 0x59, 0x81, 0x80, 0x81, 0x40, 0x90, 0x40, 170 0x95, 0x00, 0xa9, 0x40, 0xb3, 0x00, 0x02, 0x3a, 171 0x80, 0x18, 0x71, 0x38, 0x2d, 0x40, 0x58, 0x2c, 172 0x46, 0x00, 0x10, 0x09, 0x00, 0x00, 0x00, 0x1e, 173 0x00, 0x00, 0x00, 0xfd, 0x00, 0x18, 0x55, 0x18, 174 0x5e, 0x11, 0x00, 0x0a, 0x20, 0x20, 0x20, 0x20, 175 0x20, 0x20, 0x00, 0x00, 0x00, 0xfc, 0x00, 'v', 176 '4', 'l', '2', '-', 'h', 'd', 'm', 'i', 177 0x0a, 0x0a, 0x0a, 0x0a, 0x00, 0x00, 0x00, 0x10, 178 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 179 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0xf0, 180 181 0x02, 0x03, 0x1a, 0xc0, 0x48, 0xa2, 0x10, 0x04, 182 0x02, 0x01, 0x21, 0x14, 0x13, 0x23, 0x09, 0x07, 183 0x07, 0x65, 0x03, 0x0c, 0x00, 0x10, 0x00, 0xe2, 184 0x00, 0x2a, 0x01, 0x1d, 0x00, 0x80, 0x51, 0xd0, 185 0x1c, 0x20, 0x40, 0x80, 0x35, 0x00, 0x00, 0x00, 186 0x00, 0x00, 0x00, 0x1e, 0x8c, 0x0a, 0xd0, 0x8a, 187 0x20, 0xe0, 0x2d, 0x10, 0x10, 0x3e, 0x96, 0x00, 188 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 189 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 190 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 191 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 192 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 193 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 194 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 195 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 196 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xd7 197}; 198 199static int vidioc_querycap(struct file *file, void *priv, 200 struct v4l2_capability *cap) 201{ 202 struct vivid_dev *dev = video_drvdata(file); 203 struct video_device *vdev = video_devdata(file); 204 205 strcpy(cap->driver, "vivid"); 206 strcpy(cap->card, "vivid"); 207 snprintf(cap->bus_info, sizeof(cap->bus_info), 208 "platform:%s", dev->v4l2_dev.name); 209 210 if (vdev->vfl_type == VFL_TYPE_GRABBER && vdev->vfl_dir == VFL_DIR_RX) 211 cap->device_caps = dev->vid_cap_caps; 212 if (vdev->vfl_type == VFL_TYPE_GRABBER && vdev->vfl_dir == VFL_DIR_TX) 213 cap->device_caps = dev->vid_out_caps; 214 else if (vdev->vfl_type == VFL_TYPE_VBI && vdev->vfl_dir == VFL_DIR_RX) 215 cap->device_caps = dev->vbi_cap_caps; 216 else if (vdev->vfl_type == VFL_TYPE_VBI && vdev->vfl_dir == VFL_DIR_TX) 217 cap->device_caps = dev->vbi_out_caps; 218 else if (vdev->vfl_type == VFL_TYPE_SDR) 219 cap->device_caps = dev->sdr_cap_caps; 220 else if (vdev->vfl_type == VFL_TYPE_RADIO && vdev->vfl_dir == VFL_DIR_RX) 221 cap->device_caps = dev->radio_rx_caps; 222 else if (vdev->vfl_type == VFL_TYPE_RADIO && vdev->vfl_dir == VFL_DIR_TX) 223 cap->device_caps = dev->radio_tx_caps; 224 cap->capabilities = dev->vid_cap_caps | dev->vid_out_caps | 225 dev->vbi_cap_caps | dev->vbi_out_caps | 226 dev->radio_rx_caps | dev->radio_tx_caps | 227 dev->sdr_cap_caps | V4L2_CAP_DEVICE_CAPS; 228 return 0; 229} 230 231static int vidioc_s_hw_freq_seek(struct file *file, void *fh, const struct v4l2_hw_freq_seek *a) 232{ 233 struct video_device *vdev = video_devdata(file); 234 235 if (vdev->vfl_type == VFL_TYPE_RADIO) 236 return vivid_radio_rx_s_hw_freq_seek(file, fh, a); 237 return -ENOTTY; 238} 239 240static int vidioc_enum_freq_bands(struct file *file, void *fh, struct v4l2_frequency_band *band) 241{ 242 struct video_device *vdev = video_devdata(file); 243 244 if (vdev->vfl_type == VFL_TYPE_RADIO) 245 return vivid_radio_rx_enum_freq_bands(file, fh, band); 246 if (vdev->vfl_type == VFL_TYPE_SDR) 247 return vivid_sdr_enum_freq_bands(file, fh, band); 248 return -ENOTTY; 249} 250 251static int vidioc_g_tuner(struct file *file, void *fh, struct v4l2_tuner *vt) 252{ 253 struct video_device *vdev = video_devdata(file); 254 255 if (vdev->vfl_type == VFL_TYPE_RADIO) 256 return vivid_radio_rx_g_tuner(file, fh, vt); 257 if (vdev->vfl_type == VFL_TYPE_SDR) 258 return vivid_sdr_g_tuner(file, fh, vt); 259 return vivid_video_g_tuner(file, fh, vt); 260} 261 262static int vidioc_s_tuner(struct file *file, void *fh, const struct v4l2_tuner *vt) 263{ 264 struct video_device *vdev = video_devdata(file); 265 266 if (vdev->vfl_type == VFL_TYPE_RADIO) 267 return vivid_radio_rx_s_tuner(file, fh, vt); 268 if (vdev->vfl_type == VFL_TYPE_SDR) 269 return vivid_sdr_s_tuner(file, fh, vt); 270 return vivid_video_s_tuner(file, fh, vt); 271} 272 273static int vidioc_g_frequency(struct file *file, void *fh, struct v4l2_frequency *vf) 274{ 275 struct vivid_dev *dev = video_drvdata(file); 276 struct video_device *vdev = video_devdata(file); 277 278 if (vdev->vfl_type == VFL_TYPE_RADIO) 279 return vivid_radio_g_frequency(file, 280 vdev->vfl_dir == VFL_DIR_RX ? 281 &dev->radio_rx_freq : &dev->radio_tx_freq, vf); 282 if (vdev->vfl_type == VFL_TYPE_SDR) 283 return vivid_sdr_g_frequency(file, fh, vf); 284 return vivid_video_g_frequency(file, fh, vf); 285} 286 287static int vidioc_s_frequency(struct file *file, void *fh, const struct v4l2_frequency *vf) 288{ 289 struct vivid_dev *dev = video_drvdata(file); 290 struct video_device *vdev = video_devdata(file); 291 292 if (vdev->vfl_type == VFL_TYPE_RADIO) 293 return vivid_radio_s_frequency(file, 294 vdev->vfl_dir == VFL_DIR_RX ? 295 &dev->radio_rx_freq : &dev->radio_tx_freq, vf); 296 if (vdev->vfl_type == VFL_TYPE_SDR) 297 return vivid_sdr_s_frequency(file, fh, vf); 298 return vivid_video_s_frequency(file, fh, vf); 299} 300 301static int vidioc_overlay(struct file *file, void *fh, unsigned i) 302{ 303 struct video_device *vdev = video_devdata(file); 304 305 if (vdev->vfl_dir == VFL_DIR_RX) 306 return vivid_vid_cap_overlay(file, fh, i); 307 return vivid_vid_out_overlay(file, fh, i); 308} 309 310static int vidioc_g_fbuf(struct file *file, void *fh, struct v4l2_framebuffer *a) 311{ 312 struct video_device *vdev = video_devdata(file); 313 314 if (vdev->vfl_dir == VFL_DIR_RX) 315 return vivid_vid_cap_g_fbuf(file, fh, a); 316 return vivid_vid_out_g_fbuf(file, fh, a); 317} 318 319static int vidioc_s_fbuf(struct file *file, void *fh, const struct v4l2_framebuffer *a) 320{ 321 struct video_device *vdev = video_devdata(file); 322 323 if (vdev->vfl_dir == VFL_DIR_RX) 324 return vivid_vid_cap_s_fbuf(file, fh, a); 325 return vivid_vid_out_s_fbuf(file, fh, a); 326} 327 328static int vidioc_s_std(struct file *file, void *fh, v4l2_std_id id) 329{ 330 struct video_device *vdev = video_devdata(file); 331 332 if (vdev->vfl_dir == VFL_DIR_RX) 333 return vivid_vid_cap_s_std(file, fh, id); 334 return vivid_vid_out_s_std(file, fh, id); 335} 336 337static int vidioc_s_dv_timings(struct file *file, void *fh, struct v4l2_dv_timings *timings) 338{ 339 struct video_device *vdev = video_devdata(file); 340 341 if (vdev->vfl_dir == VFL_DIR_RX) 342 return vivid_vid_cap_s_dv_timings(file, fh, timings); 343 return vivid_vid_out_s_dv_timings(file, fh, timings); 344} 345 346static int vidioc_cropcap(struct file *file, void *fh, struct v4l2_cropcap *cc) 347{ 348 struct video_device *vdev = video_devdata(file); 349 350 if (vdev->vfl_dir == VFL_DIR_RX) 351 return vivid_vid_cap_cropcap(file, fh, cc); 352 return vivid_vid_out_cropcap(file, fh, cc); 353} 354 355static int vidioc_g_selection(struct file *file, void *fh, 356 struct v4l2_selection *sel) 357{ 358 struct video_device *vdev = video_devdata(file); 359 360 if (vdev->vfl_dir == VFL_DIR_RX) 361 return vivid_vid_cap_g_selection(file, fh, sel); 362 return vivid_vid_out_g_selection(file, fh, sel); 363} 364 365static int vidioc_s_selection(struct file *file, void *fh, 366 struct v4l2_selection *sel) 367{ 368 struct video_device *vdev = video_devdata(file); 369 370 if (vdev->vfl_dir == VFL_DIR_RX) 371 return vivid_vid_cap_s_selection(file, fh, sel); 372 return vivid_vid_out_s_selection(file, fh, sel); 373} 374 375static int vidioc_g_parm(struct file *file, void *fh, 376 struct v4l2_streamparm *parm) 377{ 378 struct video_device *vdev = video_devdata(file); 379 380 if (vdev->vfl_dir == VFL_DIR_RX) 381 return vivid_vid_cap_g_parm(file, fh, parm); 382 return vivid_vid_out_g_parm(file, fh, parm); 383} 384 385static int vidioc_s_parm(struct file *file, void *fh, 386 struct v4l2_streamparm *parm) 387{ 388 struct video_device *vdev = video_devdata(file); 389 390 if (vdev->vfl_dir == VFL_DIR_RX) 391 return vivid_vid_cap_s_parm(file, fh, parm); 392 return vivid_vid_out_g_parm(file, fh, parm); 393} 394 395static ssize_t vivid_radio_read(struct file *file, char __user *buf, 396 size_t size, loff_t *offset) 397{ 398 struct video_device *vdev = video_devdata(file); 399 400 if (vdev->vfl_dir == VFL_DIR_TX) 401 return -EINVAL; 402 return vivid_radio_rx_read(file, buf, size, offset); 403} 404 405static ssize_t vivid_radio_write(struct file *file, const char __user *buf, 406 size_t size, loff_t *offset) 407{ 408 struct video_device *vdev = video_devdata(file); 409 410 if (vdev->vfl_dir == VFL_DIR_RX) 411 return -EINVAL; 412 return vivid_radio_tx_write(file, buf, size, offset); 413} 414 415static unsigned int vivid_radio_poll(struct file *file, struct poll_table_struct *wait) 416{ 417 struct video_device *vdev = video_devdata(file); 418 419 if (vdev->vfl_dir == VFL_DIR_RX) 420 return vivid_radio_rx_poll(file, wait); 421 return vivid_radio_tx_poll(file, wait); 422} 423 424static bool vivid_is_in_use(struct video_device *vdev) 425{ 426 unsigned long flags; 427 bool res; 428 429 spin_lock_irqsave(&vdev->fh_lock, flags); 430 res = !list_empty(&vdev->fh_list); 431 spin_unlock_irqrestore(&vdev->fh_lock, flags); 432 return res; 433} 434 435static bool vivid_is_last_user(struct vivid_dev *dev) 436{ 437 unsigned uses = vivid_is_in_use(&dev->vid_cap_dev) + 438 vivid_is_in_use(&dev->vid_out_dev) + 439 vivid_is_in_use(&dev->vbi_cap_dev) + 440 vivid_is_in_use(&dev->vbi_out_dev) + 441 vivid_is_in_use(&dev->sdr_cap_dev) + 442 vivid_is_in_use(&dev->radio_rx_dev) + 443 vivid_is_in_use(&dev->radio_tx_dev); 444 445 return uses == 1; 446} 447 448static int vivid_fop_release(struct file *file) 449{ 450 struct vivid_dev *dev = video_drvdata(file); 451 struct video_device *vdev = video_devdata(file); 452 453 mutex_lock(&dev->mutex); 454 if (!no_error_inj && v4l2_fh_is_singular_file(file) && 455 !video_is_registered(vdev) && vivid_is_last_user(dev)) { 456 /* 457 * I am the last user of this driver, and a disconnect 458 * was forced (since this video_device is unregistered), 459 * so re-register all video_device's again. 460 */ 461 v4l2_info(&dev->v4l2_dev, "reconnect\n"); 462 set_bit(V4L2_FL_REGISTERED, &dev->vid_cap_dev.flags); 463 set_bit(V4L2_FL_REGISTERED, &dev->vid_out_dev.flags); 464 set_bit(V4L2_FL_REGISTERED, &dev->vbi_cap_dev.flags); 465 set_bit(V4L2_FL_REGISTERED, &dev->vbi_out_dev.flags); 466 set_bit(V4L2_FL_REGISTERED, &dev->sdr_cap_dev.flags); 467 set_bit(V4L2_FL_REGISTERED, &dev->radio_rx_dev.flags); 468 set_bit(V4L2_FL_REGISTERED, &dev->radio_tx_dev.flags); 469 } 470 mutex_unlock(&dev->mutex); 471 if (file->private_data == dev->overlay_cap_owner) 472 dev->overlay_cap_owner = NULL; 473 if (file->private_data == dev->radio_rx_rds_owner) { 474 dev->radio_rx_rds_last_block = 0; 475 dev->radio_rx_rds_owner = NULL; 476 } 477 if (file->private_data == dev->radio_tx_rds_owner) { 478 dev->radio_tx_rds_last_block = 0; 479 dev->radio_tx_rds_owner = NULL; 480 } 481 if (vdev->queue) 482 return vb2_fop_release(file); 483 return v4l2_fh_release(file); 484} 485 486static const struct v4l2_file_operations vivid_fops = { 487 .owner = THIS_MODULE, 488 .open = v4l2_fh_open, 489 .release = vivid_fop_release, 490 .read = vb2_fop_read, 491 .write = vb2_fop_write, 492 .poll = vb2_fop_poll, 493 .unlocked_ioctl = video_ioctl2, 494 .mmap = vb2_fop_mmap, 495}; 496 497static const struct v4l2_file_operations vivid_radio_fops = { 498 .owner = THIS_MODULE, 499 .open = v4l2_fh_open, 500 .release = vivid_fop_release, 501 .read = vivid_radio_read, 502 .write = vivid_radio_write, 503 .poll = vivid_radio_poll, 504 .unlocked_ioctl = video_ioctl2, 505}; 506 507static const struct v4l2_ioctl_ops vivid_ioctl_ops = { 508 .vidioc_querycap = vidioc_querycap, 509 510 .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid, 511 .vidioc_g_fmt_vid_cap = vidioc_g_fmt_vid_cap, 512 .vidioc_try_fmt_vid_cap = vidioc_try_fmt_vid_cap, 513 .vidioc_s_fmt_vid_cap = vidioc_s_fmt_vid_cap, 514 .vidioc_enum_fmt_vid_cap_mplane = vidioc_enum_fmt_vid_mplane, 515 .vidioc_g_fmt_vid_cap_mplane = vidioc_g_fmt_vid_cap_mplane, 516 .vidioc_try_fmt_vid_cap_mplane = vidioc_try_fmt_vid_cap_mplane, 517 .vidioc_s_fmt_vid_cap_mplane = vidioc_s_fmt_vid_cap_mplane, 518 519 .vidioc_enum_fmt_vid_out = vidioc_enum_fmt_vid, 520 .vidioc_g_fmt_vid_out = vidioc_g_fmt_vid_out, 521 .vidioc_try_fmt_vid_out = vidioc_try_fmt_vid_out, 522 .vidioc_s_fmt_vid_out = vidioc_s_fmt_vid_out, 523 .vidioc_enum_fmt_vid_out_mplane = vidioc_enum_fmt_vid_mplane, 524 .vidioc_g_fmt_vid_out_mplane = vidioc_g_fmt_vid_out_mplane, 525 .vidioc_try_fmt_vid_out_mplane = vidioc_try_fmt_vid_out_mplane, 526 .vidioc_s_fmt_vid_out_mplane = vidioc_s_fmt_vid_out_mplane, 527 528 .vidioc_g_selection = vidioc_g_selection, 529 .vidioc_s_selection = vidioc_s_selection, 530 .vidioc_cropcap = vidioc_cropcap, 531 532 .vidioc_g_fmt_vbi_cap = vidioc_g_fmt_vbi_cap, 533 .vidioc_try_fmt_vbi_cap = vidioc_g_fmt_vbi_cap, 534 .vidioc_s_fmt_vbi_cap = vidioc_s_fmt_vbi_cap, 535 536 .vidioc_g_fmt_sliced_vbi_cap = vidioc_g_fmt_sliced_vbi_cap, 537 .vidioc_try_fmt_sliced_vbi_cap = vidioc_try_fmt_sliced_vbi_cap, 538 .vidioc_s_fmt_sliced_vbi_cap = vidioc_s_fmt_sliced_vbi_cap, 539 .vidioc_g_sliced_vbi_cap = vidioc_g_sliced_vbi_cap, 540 541 .vidioc_g_fmt_vbi_out = vidioc_g_fmt_vbi_out, 542 .vidioc_try_fmt_vbi_out = vidioc_g_fmt_vbi_out, 543 .vidioc_s_fmt_vbi_out = vidioc_s_fmt_vbi_out, 544 545 .vidioc_g_fmt_sliced_vbi_out = vidioc_g_fmt_sliced_vbi_out, 546 .vidioc_try_fmt_sliced_vbi_out = vidioc_try_fmt_sliced_vbi_out, 547 .vidioc_s_fmt_sliced_vbi_out = vidioc_s_fmt_sliced_vbi_out, 548 549 .vidioc_enum_fmt_sdr_cap = vidioc_enum_fmt_sdr_cap, 550 .vidioc_g_fmt_sdr_cap = vidioc_g_fmt_sdr_cap, 551 .vidioc_try_fmt_sdr_cap = vidioc_g_fmt_sdr_cap, 552 .vidioc_s_fmt_sdr_cap = vidioc_g_fmt_sdr_cap, 553 554 .vidioc_overlay = vidioc_overlay, 555 .vidioc_enum_framesizes = vidioc_enum_framesizes, 556 .vidioc_enum_frameintervals = vidioc_enum_frameintervals, 557 .vidioc_g_parm = vidioc_g_parm, 558 .vidioc_s_parm = vidioc_s_parm, 559 560 .vidioc_enum_fmt_vid_overlay = vidioc_enum_fmt_vid_overlay, 561 .vidioc_g_fmt_vid_overlay = vidioc_g_fmt_vid_overlay, 562 .vidioc_try_fmt_vid_overlay = vidioc_try_fmt_vid_overlay, 563 .vidioc_s_fmt_vid_overlay = vidioc_s_fmt_vid_overlay, 564 .vidioc_g_fmt_vid_out_overlay = vidioc_g_fmt_vid_out_overlay, 565 .vidioc_try_fmt_vid_out_overlay = vidioc_try_fmt_vid_out_overlay, 566 .vidioc_s_fmt_vid_out_overlay = vidioc_s_fmt_vid_out_overlay, 567 .vidioc_g_fbuf = vidioc_g_fbuf, 568 .vidioc_s_fbuf = vidioc_s_fbuf, 569 570 .vidioc_reqbufs = vb2_ioctl_reqbufs, 571 .vidioc_create_bufs = vb2_ioctl_create_bufs, 572 .vidioc_prepare_buf = vb2_ioctl_prepare_buf, 573 .vidioc_querybuf = vb2_ioctl_querybuf, 574 .vidioc_qbuf = vb2_ioctl_qbuf, 575 .vidioc_dqbuf = vb2_ioctl_dqbuf, 576 .vidioc_expbuf = vb2_ioctl_expbuf, 577 .vidioc_streamon = vb2_ioctl_streamon, 578 .vidioc_streamoff = vb2_ioctl_streamoff, 579 580 .vidioc_enum_input = vidioc_enum_input, 581 .vidioc_g_input = vidioc_g_input, 582 .vidioc_s_input = vidioc_s_input, 583 .vidioc_s_audio = vidioc_s_audio, 584 .vidioc_g_audio = vidioc_g_audio, 585 .vidioc_enumaudio = vidioc_enumaudio, 586 .vidioc_s_frequency = vidioc_s_frequency, 587 .vidioc_g_frequency = vidioc_g_frequency, 588 .vidioc_s_tuner = vidioc_s_tuner, 589 .vidioc_g_tuner = vidioc_g_tuner, 590 .vidioc_s_modulator = vidioc_s_modulator, 591 .vidioc_g_modulator = vidioc_g_modulator, 592 .vidioc_s_hw_freq_seek = vidioc_s_hw_freq_seek, 593 .vidioc_enum_freq_bands = vidioc_enum_freq_bands, 594 595 .vidioc_enum_output = vidioc_enum_output, 596 .vidioc_g_output = vidioc_g_output, 597 .vidioc_s_output = vidioc_s_output, 598 .vidioc_s_audout = vidioc_s_audout, 599 .vidioc_g_audout = vidioc_g_audout, 600 .vidioc_enumaudout = vidioc_enumaudout, 601 602 .vidioc_querystd = vidioc_querystd, 603 .vidioc_g_std = vidioc_g_std, 604 .vidioc_s_std = vidioc_s_std, 605 .vidioc_s_dv_timings = vidioc_s_dv_timings, 606 .vidioc_g_dv_timings = vidioc_g_dv_timings, 607 .vidioc_query_dv_timings = vidioc_query_dv_timings, 608 .vidioc_enum_dv_timings = vidioc_enum_dv_timings, 609 .vidioc_dv_timings_cap = vidioc_dv_timings_cap, 610 .vidioc_g_edid = vidioc_g_edid, 611 .vidioc_s_edid = vidioc_s_edid, 612 613 .vidioc_log_status = v4l2_ctrl_log_status, 614 .vidioc_subscribe_event = vidioc_subscribe_event, 615 .vidioc_unsubscribe_event = v4l2_event_unsubscribe, 616}; 617 618/* ----------------------------------------------------------------- 619 Initialization and module stuff 620 ------------------------------------------------------------------*/ 621 622static void vivid_dev_release(struct v4l2_device *v4l2_dev) 623{ 624 struct vivid_dev *dev = container_of(v4l2_dev, struct vivid_dev, v4l2_dev); 625 626 vivid_free_controls(dev); 627 v4l2_device_unregister(&dev->v4l2_dev); 628 vfree(dev->scaled_line); 629 vfree(dev->blended_line); 630 vfree(dev->edid); 631 vfree(dev->bitmap_cap); 632 vfree(dev->bitmap_out); 633 tpg_free(&dev->tpg); 634 kfree(dev->query_dv_timings_qmenu); 635 kfree(dev); 636} 637 638static int vivid_create_instance(struct platform_device *pdev, int inst) 639{ 640 static const struct v4l2_dv_timings def_dv_timings = 641 V4L2_DV_BT_CEA_1280X720P60; 642 unsigned in_type_counter[4] = { 0, 0, 0, 0 }; 643 unsigned out_type_counter[4] = { 0, 0, 0, 0 }; 644 int ccs_cap = ccs_cap_mode[inst]; 645 int ccs_out = ccs_out_mode[inst]; 646 bool has_tuner; 647 bool has_modulator; 648 struct vivid_dev *dev; 649 struct video_device *vfd; 650 struct vb2_queue *q; 651 unsigned node_type = node_types[inst]; 652 v4l2_std_id tvnorms_cap = 0, tvnorms_out = 0; 653 int ret; 654 int i; 655 656 /* allocate main vivid state structure */ 657 dev = kzalloc(sizeof(*dev), GFP_KERNEL); 658 if (!dev) 659 return -ENOMEM; 660 661 dev->inst = inst; 662 663 /* register v4l2_device */ 664 snprintf(dev->v4l2_dev.name, sizeof(dev->v4l2_dev.name), 665 "%s-%03d", VIVID_MODULE_NAME, inst); 666 ret = v4l2_device_register(&pdev->dev, &dev->v4l2_dev); 667 if (ret) { 668 kfree(dev); 669 return ret; 670 } 671 dev->v4l2_dev.release = vivid_dev_release; 672 673 /* start detecting feature set */ 674 675 /* do we use single- or multi-planar? */ 676 dev->multiplanar = multiplanar[inst] > 1; 677 v4l2_info(&dev->v4l2_dev, "using %splanar format API\n", 678 dev->multiplanar ? "multi" : "single "); 679 680 /* how many inputs do we have and of what type? */ 681 dev->num_inputs = num_inputs[inst]; 682 if (dev->num_inputs < 1) 683 dev->num_inputs = 1; 684 if (dev->num_inputs >= MAX_INPUTS) 685 dev->num_inputs = MAX_INPUTS; 686 for (i = 0; i < dev->num_inputs; i++) { 687 dev->input_type[i] = (input_types[inst] >> (i * 2)) & 0x3; 688 dev->input_name_counter[i] = in_type_counter[dev->input_type[i]]++; 689 } 690 dev->has_audio_inputs = in_type_counter[TV] && in_type_counter[SVID]; 691 692 /* how many outputs do we have and of what type? */ 693 dev->num_outputs = num_outputs[inst]; 694 if (dev->num_outputs < 1) 695 dev->num_outputs = 1; 696 if (dev->num_outputs >= MAX_OUTPUTS) 697 dev->num_outputs = MAX_OUTPUTS; 698 for (i = 0; i < dev->num_outputs; i++) { 699 dev->output_type[i] = ((output_types[inst] >> i) & 1) ? HDMI : SVID; 700 dev->output_name_counter[i] = out_type_counter[dev->output_type[i]]++; 701 } 702 dev->has_audio_outputs = out_type_counter[SVID]; 703 704 /* do we create a video capture device? */ 705 dev->has_vid_cap = node_type & 0x0001; 706 707 /* do we create a vbi capture device? */ 708 if (in_type_counter[TV] || in_type_counter[SVID]) { 709 dev->has_raw_vbi_cap = node_type & 0x0004; 710 dev->has_sliced_vbi_cap = node_type & 0x0008; 711 dev->has_vbi_cap = dev->has_raw_vbi_cap | dev->has_sliced_vbi_cap; 712 } 713 714 /* do we create a video output device? */ 715 dev->has_vid_out = node_type & 0x0100; 716 717 /* do we create a vbi output device? */ 718 if (out_type_counter[SVID]) { 719 dev->has_raw_vbi_out = node_type & 0x0400; 720 dev->has_sliced_vbi_out = node_type & 0x0800; 721 dev->has_vbi_out = dev->has_raw_vbi_out | dev->has_sliced_vbi_out; 722 } 723 724 /* do we create a radio receiver device? */ 725 dev->has_radio_rx = node_type & 0x0010; 726 727 /* do we create a radio transmitter device? */ 728 dev->has_radio_tx = node_type & 0x1000; 729 730 /* do we create a software defined radio capture device? */ 731 dev->has_sdr_cap = node_type & 0x0020; 732 733 /* do we have a tuner? */ 734 has_tuner = ((dev->has_vid_cap || dev->has_vbi_cap) && in_type_counter[TV]) || 735 dev->has_radio_rx || dev->has_sdr_cap; 736 737 /* do we have a modulator? */ 738 has_modulator = dev->has_radio_tx; 739 740 if (dev->has_vid_cap) 741 /* do we have a framebuffer for overlay testing? */ 742 dev->has_fb = node_type & 0x10000; 743 744 /* can we do crop/compose/scaling while capturing? */ 745 if (no_error_inj && ccs_cap == -1) 746 ccs_cap = 7; 747 748 /* if ccs_cap == -1, then the use can select it using controls */ 749 if (ccs_cap != -1) { 750 dev->has_crop_cap = ccs_cap & 1; 751 dev->has_compose_cap = ccs_cap & 2; 752 dev->has_scaler_cap = ccs_cap & 4; 753 v4l2_info(&dev->v4l2_dev, "Capture Crop: %c Compose: %c Scaler: %c\n", 754 dev->has_crop_cap ? 'Y' : 'N', 755 dev->has_compose_cap ? 'Y' : 'N', 756 dev->has_scaler_cap ? 'Y' : 'N'); 757 } 758 759 /* can we do crop/compose/scaling with video output? */ 760 if (no_error_inj && ccs_out == -1) 761 ccs_out = 7; 762 763 /* if ccs_out == -1, then the use can select it using controls */ 764 if (ccs_out != -1) { 765 dev->has_crop_out = ccs_out & 1; 766 dev->has_compose_out = ccs_out & 2; 767 dev->has_scaler_out = ccs_out & 4; 768 v4l2_info(&dev->v4l2_dev, "Output Crop: %c Compose: %c Scaler: %c\n", 769 dev->has_crop_out ? 'Y' : 'N', 770 dev->has_compose_out ? 'Y' : 'N', 771 dev->has_scaler_out ? 'Y' : 'N'); 772 } 773 774 /* end detecting feature set */ 775 776 if (dev->has_vid_cap) { 777 /* set up the capabilities of the video capture device */ 778 dev->vid_cap_caps = dev->multiplanar ? 779 V4L2_CAP_VIDEO_CAPTURE_MPLANE : 780 V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_VIDEO_OVERLAY; 781 dev->vid_cap_caps |= V4L2_CAP_STREAMING | V4L2_CAP_READWRITE; 782 if (dev->has_audio_inputs) 783 dev->vid_cap_caps |= V4L2_CAP_AUDIO; 784 if (in_type_counter[TV]) 785 dev->vid_cap_caps |= V4L2_CAP_TUNER; 786 } 787 if (dev->has_vid_out) { 788 /* set up the capabilities of the video output device */ 789 dev->vid_out_caps = dev->multiplanar ? 790 V4L2_CAP_VIDEO_OUTPUT_MPLANE : 791 V4L2_CAP_VIDEO_OUTPUT; 792 if (dev->has_fb) 793 dev->vid_out_caps |= V4L2_CAP_VIDEO_OUTPUT_OVERLAY; 794 dev->vid_out_caps |= V4L2_CAP_STREAMING | V4L2_CAP_READWRITE; 795 if (dev->has_audio_outputs) 796 dev->vid_out_caps |= V4L2_CAP_AUDIO; 797 } 798 if (dev->has_vbi_cap) { 799 /* set up the capabilities of the vbi capture device */ 800 dev->vbi_cap_caps = (dev->has_raw_vbi_cap ? V4L2_CAP_VBI_CAPTURE : 0) | 801 (dev->has_sliced_vbi_cap ? V4L2_CAP_SLICED_VBI_CAPTURE : 0); 802 dev->vbi_cap_caps |= V4L2_CAP_STREAMING | V4L2_CAP_READWRITE; 803 if (dev->has_audio_inputs) 804 dev->vbi_cap_caps |= V4L2_CAP_AUDIO; 805 if (in_type_counter[TV]) 806 dev->vbi_cap_caps |= V4L2_CAP_TUNER; 807 } 808 if (dev->has_vbi_out) { 809 /* set up the capabilities of the vbi output device */ 810 dev->vbi_out_caps = (dev->has_raw_vbi_out ? V4L2_CAP_VBI_OUTPUT : 0) | 811 (dev->has_sliced_vbi_out ? V4L2_CAP_SLICED_VBI_OUTPUT : 0); 812 dev->vbi_out_caps |= V4L2_CAP_STREAMING | V4L2_CAP_READWRITE; 813 if (dev->has_audio_outputs) 814 dev->vbi_out_caps |= V4L2_CAP_AUDIO; 815 } 816 if (dev->has_sdr_cap) { 817 /* set up the capabilities of the sdr capture device */ 818 dev->sdr_cap_caps = V4L2_CAP_SDR_CAPTURE | V4L2_CAP_TUNER; 819 dev->sdr_cap_caps |= V4L2_CAP_STREAMING | V4L2_CAP_READWRITE; 820 } 821 /* set up the capabilities of the radio receiver device */ 822 if (dev->has_radio_rx) 823 dev->radio_rx_caps = V4L2_CAP_RADIO | V4L2_CAP_RDS_CAPTURE | 824 V4L2_CAP_HW_FREQ_SEEK | V4L2_CAP_TUNER | 825 V4L2_CAP_READWRITE; 826 /* set up the capabilities of the radio transmitter device */ 827 if (dev->has_radio_tx) 828 dev->radio_tx_caps = V4L2_CAP_RDS_OUTPUT | V4L2_CAP_MODULATOR | 829 V4L2_CAP_READWRITE; 830 831 /* initialize the test pattern generator */ 832 tpg_init(&dev->tpg, 640, 360); 833 if (tpg_alloc(&dev->tpg, MAX_ZOOM * MAX_WIDTH)) 834 goto free_dev; 835 dev->scaled_line = vzalloc(MAX_ZOOM * MAX_WIDTH); 836 if (!dev->scaled_line) 837 goto free_dev; 838 dev->blended_line = vzalloc(MAX_ZOOM * MAX_WIDTH); 839 if (!dev->blended_line) 840 goto free_dev; 841 842 /* load the edid */ 843 dev->edid = vmalloc(256 * 128); 844 if (!dev->edid) 845 goto free_dev; 846 847 /* create a string array containing the names of all the preset timings */ 848 while (v4l2_dv_timings_presets[dev->query_dv_timings_size].bt.width) 849 dev->query_dv_timings_size++; 850 dev->query_dv_timings_qmenu = kmalloc(dev->query_dv_timings_size * 851 (sizeof(void *) + 32), GFP_KERNEL); 852 if (dev->query_dv_timings_qmenu == NULL) 853 goto free_dev; 854 for (i = 0; i < dev->query_dv_timings_size; i++) { 855 const struct v4l2_bt_timings *bt = &v4l2_dv_timings_presets[i].bt; 856 char *p = (char *)&dev->query_dv_timings_qmenu[dev->query_dv_timings_size]; 857 u32 htot, vtot; 858 859 p += i * 32; 860 dev->query_dv_timings_qmenu[i] = p; 861 862 htot = V4L2_DV_BT_FRAME_WIDTH(bt); 863 vtot = V4L2_DV_BT_FRAME_HEIGHT(bt); 864 snprintf(p, 32, "%ux%u%s%u", 865 bt->width, bt->height, bt->interlaced ? "i" : "p", 866 (u32)bt->pixelclock / (htot * vtot)); 867 } 868 869 /* disable invalid ioctls based on the feature set */ 870 if (!dev->has_audio_inputs) { 871 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_S_AUDIO); 872 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_G_AUDIO); 873 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_ENUMAUDIO); 874 v4l2_disable_ioctl(&dev->vbi_cap_dev, VIDIOC_S_AUDIO); 875 v4l2_disable_ioctl(&dev->vbi_cap_dev, VIDIOC_G_AUDIO); 876 v4l2_disable_ioctl(&dev->vbi_cap_dev, VIDIOC_ENUMAUDIO); 877 } 878 if (!dev->has_audio_outputs) { 879 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_S_AUDOUT); 880 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_G_AUDOUT); 881 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_ENUMAUDOUT); 882 v4l2_disable_ioctl(&dev->vbi_out_dev, VIDIOC_S_AUDOUT); 883 v4l2_disable_ioctl(&dev->vbi_out_dev, VIDIOC_G_AUDOUT); 884 v4l2_disable_ioctl(&dev->vbi_out_dev, VIDIOC_ENUMAUDOUT); 885 } 886 if (!in_type_counter[TV] && !in_type_counter[SVID]) { 887 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_S_STD); 888 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_G_STD); 889 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_ENUMSTD); 890 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_QUERYSTD); 891 } 892 if (!out_type_counter[SVID]) { 893 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_S_STD); 894 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_G_STD); 895 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_ENUMSTD); 896 } 897 if (!has_tuner && !has_modulator) { 898 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_S_FREQUENCY); 899 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_G_FREQUENCY); 900 v4l2_disable_ioctl(&dev->vbi_cap_dev, VIDIOC_S_FREQUENCY); 901 v4l2_disable_ioctl(&dev->vbi_cap_dev, VIDIOC_G_FREQUENCY); 902 } 903 if (!has_tuner) { 904 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_S_TUNER); 905 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_G_TUNER); 906 v4l2_disable_ioctl(&dev->vbi_cap_dev, VIDIOC_S_TUNER); 907 v4l2_disable_ioctl(&dev->vbi_cap_dev, VIDIOC_G_TUNER); 908 } 909 if (in_type_counter[HDMI] == 0) { 910 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_S_EDID); 911 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_G_EDID); 912 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_DV_TIMINGS_CAP); 913 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_G_DV_TIMINGS); 914 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_S_DV_TIMINGS); 915 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_ENUM_DV_TIMINGS); 916 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_QUERY_DV_TIMINGS); 917 } 918 if (out_type_counter[HDMI] == 0) { 919 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_G_EDID); 920 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_DV_TIMINGS_CAP); 921 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_G_DV_TIMINGS); 922 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_S_DV_TIMINGS); 923 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_ENUM_DV_TIMINGS); 924 } 925 if (!dev->has_fb) { 926 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_G_FBUF); 927 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_S_FBUF); 928 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_OVERLAY); 929 } 930 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_S_HW_FREQ_SEEK); 931 v4l2_disable_ioctl(&dev->vbi_cap_dev, VIDIOC_S_HW_FREQ_SEEK); 932 v4l2_disable_ioctl(&dev->sdr_cap_dev, VIDIOC_S_HW_FREQ_SEEK); 933 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_S_FREQUENCY); 934 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_G_FREQUENCY); 935 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_ENUM_FRAMESIZES); 936 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_ENUM_FRAMEINTERVALS); 937 v4l2_disable_ioctl(&dev->vbi_out_dev, VIDIOC_S_FREQUENCY); 938 v4l2_disable_ioctl(&dev->vbi_out_dev, VIDIOC_G_FREQUENCY); 939 940 /* configure internal data */ 941 dev->fmt_cap = &vivid_formats[0]; 942 dev->fmt_out = &vivid_formats[0]; 943 if (!dev->multiplanar) 944 vivid_formats[0].data_offset[0] = 0; 945 dev->webcam_size_idx = 1; 946 dev->webcam_ival_idx = 3; 947 tpg_s_fourcc(&dev->tpg, dev->fmt_cap->fourcc); 948 dev->std_cap = V4L2_STD_PAL; 949 dev->std_out = V4L2_STD_PAL; 950 if (dev->input_type[0] == TV || dev->input_type[0] == SVID) 951 tvnorms_cap = V4L2_STD_ALL; 952 if (dev->output_type[0] == SVID) 953 tvnorms_out = V4L2_STD_ALL; 954 dev->dv_timings_cap = def_dv_timings; 955 dev->dv_timings_out = def_dv_timings; 956 dev->tv_freq = 2804 /* 175.25 * 16 */; 957 dev->tv_audmode = V4L2_TUNER_MODE_STEREO; 958 dev->tv_field_cap = V4L2_FIELD_INTERLACED; 959 dev->tv_field_out = V4L2_FIELD_INTERLACED; 960 dev->radio_rx_freq = 95000 * 16; 961 dev->radio_rx_audmode = V4L2_TUNER_MODE_STEREO; 962 if (dev->has_radio_tx) { 963 dev->radio_tx_freq = 95500 * 16; 964 dev->radio_rds_loop = false; 965 } 966 dev->radio_tx_subchans = V4L2_TUNER_SUB_STEREO | V4L2_TUNER_SUB_RDS; 967 dev->sdr_adc_freq = 300000; 968 dev->sdr_fm_freq = 50000000; 969 dev->edid_max_blocks = dev->edid_blocks = 2; 970 memcpy(dev->edid, vivid_hdmi_edid, sizeof(vivid_hdmi_edid)); 971 ktime_get_ts(&dev->radio_rds_init_ts); 972 973 /* create all controls */ 974 ret = vivid_create_controls(dev, ccs_cap == -1, ccs_out == -1, no_error_inj, 975 in_type_counter[TV] || in_type_counter[SVID] || 976 out_type_counter[SVID], 977 in_type_counter[HDMI] || out_type_counter[HDMI]); 978 if (ret) 979 goto unreg_dev; 980 981 /* 982 * update the capture and output formats to do a proper initial 983 * configuration. 984 */ 985 vivid_update_format_cap(dev, false); 986 vivid_update_format_out(dev); 987 988 v4l2_ctrl_handler_setup(&dev->ctrl_hdl_vid_cap); 989 v4l2_ctrl_handler_setup(&dev->ctrl_hdl_vid_out); 990 v4l2_ctrl_handler_setup(&dev->ctrl_hdl_vbi_cap); 991 v4l2_ctrl_handler_setup(&dev->ctrl_hdl_vbi_out); 992 v4l2_ctrl_handler_setup(&dev->ctrl_hdl_radio_rx); 993 v4l2_ctrl_handler_setup(&dev->ctrl_hdl_radio_tx); 994 v4l2_ctrl_handler_setup(&dev->ctrl_hdl_sdr_cap); 995 996 /* initialize overlay */ 997 dev->fb_cap.fmt.width = dev->src_rect.width; 998 dev->fb_cap.fmt.height = dev->src_rect.height; 999 dev->fb_cap.fmt.pixelformat = dev->fmt_cap->fourcc; 1000 dev->fb_cap.fmt.bytesperline = dev->src_rect.width * tpg_g_twopixelsize(&dev->tpg, 0) / 2; 1001 dev->fb_cap.fmt.sizeimage = dev->src_rect.height * dev->fb_cap.fmt.bytesperline; 1002 1003 /* initialize locks */ 1004 spin_lock_init(&dev->slock); 1005 mutex_init(&dev->mutex); 1006 1007 /* init dma queues */ 1008 INIT_LIST_HEAD(&dev->vid_cap_active); 1009 INIT_LIST_HEAD(&dev->vid_out_active); 1010 INIT_LIST_HEAD(&dev->vbi_cap_active); 1011 INIT_LIST_HEAD(&dev->vbi_out_active); 1012 INIT_LIST_HEAD(&dev->sdr_cap_active); 1013 1014 /* start creating the vb2 queues */ 1015 if (dev->has_vid_cap) { 1016 /* initialize vid_cap queue */ 1017 q = &dev->vb_vid_cap_q; 1018 q->type = dev->multiplanar ? V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE : 1019 V4L2_BUF_TYPE_VIDEO_CAPTURE; 1020 q->io_modes = VB2_MMAP | VB2_USERPTR | VB2_DMABUF | VB2_READ; 1021 q->drv_priv = dev; 1022 q->buf_struct_size = sizeof(struct vivid_buffer); 1023 q->ops = &vivid_vid_cap_qops; 1024 q->mem_ops = &vb2_vmalloc_memops; 1025 q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC; 1026 q->min_buffers_needed = 2; 1027 q->lock = &dev->mutex; 1028 1029 ret = vb2_queue_init(q); 1030 if (ret) 1031 goto unreg_dev; 1032 } 1033 1034 if (dev->has_vid_out) { 1035 /* initialize vid_out queue */ 1036 q = &dev->vb_vid_out_q; 1037 q->type = dev->multiplanar ? V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE : 1038 V4L2_BUF_TYPE_VIDEO_OUTPUT; 1039 q->io_modes = VB2_MMAP | VB2_USERPTR | VB2_DMABUF | VB2_WRITE; 1040 q->drv_priv = dev; 1041 q->buf_struct_size = sizeof(struct vivid_buffer); 1042 q->ops = &vivid_vid_out_qops; 1043 q->mem_ops = &vb2_vmalloc_memops; 1044 q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC; 1045 q->min_buffers_needed = 2; 1046 q->lock = &dev->mutex; 1047 1048 ret = vb2_queue_init(q); 1049 if (ret) 1050 goto unreg_dev; 1051 } 1052 1053 if (dev->has_vbi_cap) { 1054 /* initialize vbi_cap queue */ 1055 q = &dev->vb_vbi_cap_q; 1056 q->type = dev->has_raw_vbi_cap ? V4L2_BUF_TYPE_VBI_CAPTURE : 1057 V4L2_BUF_TYPE_SLICED_VBI_CAPTURE; 1058 q->io_modes = VB2_MMAP | VB2_USERPTR | VB2_DMABUF | VB2_READ; 1059 q->drv_priv = dev; 1060 q->buf_struct_size = sizeof(struct vivid_buffer); 1061 q->ops = &vivid_vbi_cap_qops; 1062 q->mem_ops = &vb2_vmalloc_memops; 1063 q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC; 1064 q->min_buffers_needed = 2; 1065 q->lock = &dev->mutex; 1066 1067 ret = vb2_queue_init(q); 1068 if (ret) 1069 goto unreg_dev; 1070 } 1071 1072 if (dev->has_vbi_out) { 1073 /* initialize vbi_out queue */ 1074 q = &dev->vb_vbi_out_q; 1075 q->type = dev->has_raw_vbi_out ? V4L2_BUF_TYPE_VBI_OUTPUT : 1076 V4L2_BUF_TYPE_SLICED_VBI_OUTPUT; 1077 q->io_modes = VB2_MMAP | VB2_USERPTR | VB2_DMABUF | VB2_WRITE; 1078 q->drv_priv = dev; 1079 q->buf_struct_size = sizeof(struct vivid_buffer); 1080 q->ops = &vivid_vbi_out_qops; 1081 q->mem_ops = &vb2_vmalloc_memops; 1082 q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC; 1083 q->min_buffers_needed = 2; 1084 q->lock = &dev->mutex; 1085 1086 ret = vb2_queue_init(q); 1087 if (ret) 1088 goto unreg_dev; 1089 } 1090 1091 if (dev->has_sdr_cap) { 1092 /* initialize sdr_cap queue */ 1093 q = &dev->vb_sdr_cap_q; 1094 q->type = V4L2_BUF_TYPE_SDR_CAPTURE; 1095 q->io_modes = VB2_MMAP | VB2_USERPTR | VB2_DMABUF | VB2_READ; 1096 q->drv_priv = dev; 1097 q->buf_struct_size = sizeof(struct vivid_buffer); 1098 q->ops = &vivid_sdr_cap_qops; 1099 q->mem_ops = &vb2_vmalloc_memops; 1100 q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC; 1101 q->min_buffers_needed = 8; 1102 q->lock = &dev->mutex; 1103 1104 ret = vb2_queue_init(q); 1105 if (ret) 1106 goto unreg_dev; 1107 } 1108 1109 if (dev->has_fb) { 1110 /* Create framebuffer for testing capture/output overlay */ 1111 ret = vivid_fb_init(dev); 1112 if (ret) 1113 goto unreg_dev; 1114 v4l2_info(&dev->v4l2_dev, "Framebuffer device registered as fb%d\n", 1115 dev->fb_info.node); 1116 } 1117 1118 /* finally start creating the device nodes */ 1119 if (dev->has_vid_cap) { 1120 vfd = &dev->vid_cap_dev; 1121 strlcpy(vfd->name, "vivid-vid-cap", sizeof(vfd->name)); 1122 vfd->fops = &vivid_fops; 1123 vfd->ioctl_ops = &vivid_ioctl_ops; 1124 vfd->release = video_device_release_empty; 1125 vfd->v4l2_dev = &dev->v4l2_dev; 1126 vfd->queue = &dev->vb_vid_cap_q; 1127 vfd->tvnorms = tvnorms_cap; 1128 1129 /* 1130 * Provide a mutex to v4l2 core. It will be used to protect 1131 * all fops and v4l2 ioctls. 1132 */ 1133 vfd->lock = &dev->mutex; 1134 video_set_drvdata(vfd, dev); 1135 1136 ret = video_register_device(vfd, VFL_TYPE_GRABBER, vid_cap_nr[inst]); 1137 if (ret < 0) 1138 goto unreg_dev; 1139 v4l2_info(&dev->v4l2_dev, "V4L2 capture device registered as %s\n", 1140 video_device_node_name(vfd)); 1141 } 1142 1143 if (dev->has_vid_out) { 1144 vfd = &dev->vid_out_dev; 1145 strlcpy(vfd->name, "vivid-vid-out", sizeof(vfd->name)); 1146 vfd->vfl_dir = VFL_DIR_TX; 1147 vfd->fops = &vivid_fops; 1148 vfd->ioctl_ops = &vivid_ioctl_ops; 1149 vfd->release = video_device_release_empty; 1150 vfd->v4l2_dev = &dev->v4l2_dev; 1151 vfd->queue = &dev->vb_vid_out_q; 1152 vfd->tvnorms = tvnorms_out; 1153 1154 /* 1155 * Provide a mutex to v4l2 core. It will be used to protect 1156 * all fops and v4l2 ioctls. 1157 */ 1158 vfd->lock = &dev->mutex; 1159 video_set_drvdata(vfd, dev); 1160 1161 ret = video_register_device(vfd, VFL_TYPE_GRABBER, vid_out_nr[inst]); 1162 if (ret < 0) 1163 goto unreg_dev; 1164 v4l2_info(&dev->v4l2_dev, "V4L2 output device registered as %s\n", 1165 video_device_node_name(vfd)); 1166 } 1167 1168 if (dev->has_vbi_cap) { 1169 vfd = &dev->vbi_cap_dev; 1170 strlcpy(vfd->name, "vivid-vbi-cap", sizeof(vfd->name)); 1171 vfd->fops = &vivid_fops; 1172 vfd->ioctl_ops = &vivid_ioctl_ops; 1173 vfd->release = video_device_release_empty; 1174 vfd->v4l2_dev = &dev->v4l2_dev; 1175 vfd->queue = &dev->vb_vbi_cap_q; 1176 vfd->lock = &dev->mutex; 1177 vfd->tvnorms = tvnorms_cap; 1178 video_set_drvdata(vfd, dev); 1179 1180 ret = video_register_device(vfd, VFL_TYPE_VBI, vbi_cap_nr[inst]); 1181 if (ret < 0) 1182 goto unreg_dev; 1183 v4l2_info(&dev->v4l2_dev, "V4L2 capture device registered as %s, supports %s VBI\n", 1184 video_device_node_name(vfd), 1185 (dev->has_raw_vbi_cap && dev->has_sliced_vbi_cap) ? 1186 "raw and sliced" : 1187 (dev->has_raw_vbi_cap ? "raw" : "sliced")); 1188 } 1189 1190 if (dev->has_vbi_out) { 1191 vfd = &dev->vbi_out_dev; 1192 strlcpy(vfd->name, "vivid-vbi-out", sizeof(vfd->name)); 1193 vfd->vfl_dir = VFL_DIR_TX; 1194 vfd->fops = &vivid_fops; 1195 vfd->ioctl_ops = &vivid_ioctl_ops; 1196 vfd->release = video_device_release_empty; 1197 vfd->v4l2_dev = &dev->v4l2_dev; 1198 vfd->queue = &dev->vb_vbi_out_q; 1199 vfd->lock = &dev->mutex; 1200 vfd->tvnorms = tvnorms_out; 1201 video_set_drvdata(vfd, dev); 1202 1203 ret = video_register_device(vfd, VFL_TYPE_VBI, vbi_out_nr[inst]); 1204 if (ret < 0) 1205 goto unreg_dev; 1206 v4l2_info(&dev->v4l2_dev, "V4L2 output device registered as %s, supports %s VBI\n", 1207 video_device_node_name(vfd), 1208 (dev->has_raw_vbi_out && dev->has_sliced_vbi_out) ? 1209 "raw and sliced" : 1210 (dev->has_raw_vbi_out ? "raw" : "sliced")); 1211 } 1212 1213 if (dev->has_sdr_cap) { 1214 vfd = &dev->sdr_cap_dev; 1215 strlcpy(vfd->name, "vivid-sdr-cap", sizeof(vfd->name)); 1216 vfd->fops = &vivid_fops; 1217 vfd->ioctl_ops = &vivid_ioctl_ops; 1218 vfd->release = video_device_release_empty; 1219 vfd->v4l2_dev = &dev->v4l2_dev; 1220 vfd->queue = &dev->vb_sdr_cap_q; 1221 vfd->lock = &dev->mutex; 1222 video_set_drvdata(vfd, dev); 1223 1224 ret = video_register_device(vfd, VFL_TYPE_SDR, sdr_cap_nr[inst]); 1225 if (ret < 0) 1226 goto unreg_dev; 1227 v4l2_info(&dev->v4l2_dev, "V4L2 capture device registered as %s\n", 1228 video_device_node_name(vfd)); 1229 } 1230 1231 if (dev->has_radio_rx) { 1232 vfd = &dev->radio_rx_dev; 1233 strlcpy(vfd->name, "vivid-rad-rx", sizeof(vfd->name)); 1234 vfd->fops = &vivid_radio_fops; 1235 vfd->ioctl_ops = &vivid_ioctl_ops; 1236 vfd->release = video_device_release_empty; 1237 vfd->v4l2_dev = &dev->v4l2_dev; 1238 vfd->lock = &dev->mutex; 1239 video_set_drvdata(vfd, dev); 1240 1241 ret = video_register_device(vfd, VFL_TYPE_RADIO, radio_rx_nr[inst]); 1242 if (ret < 0) 1243 goto unreg_dev; 1244 v4l2_info(&dev->v4l2_dev, "V4L2 receiver device registered as %s\n", 1245 video_device_node_name(vfd)); 1246 } 1247 1248 if (dev->has_radio_tx) { 1249 vfd = &dev->radio_tx_dev; 1250 strlcpy(vfd->name, "vivid-rad-tx", sizeof(vfd->name)); 1251 vfd->vfl_dir = VFL_DIR_TX; 1252 vfd->fops = &vivid_radio_fops; 1253 vfd->ioctl_ops = &vivid_ioctl_ops; 1254 vfd->release = video_device_release_empty; 1255 vfd->v4l2_dev = &dev->v4l2_dev; 1256 vfd->lock = &dev->mutex; 1257 video_set_drvdata(vfd, dev); 1258 1259 ret = video_register_device(vfd, VFL_TYPE_RADIO, radio_tx_nr[inst]); 1260 if (ret < 0) 1261 goto unreg_dev; 1262 v4l2_info(&dev->v4l2_dev, "V4L2 transmitter device registered as %s\n", 1263 video_device_node_name(vfd)); 1264 } 1265 1266 /* Now that everything is fine, let's add it to device list */ 1267 vivid_devs[inst] = dev; 1268 1269 return 0; 1270 1271unreg_dev: 1272 video_unregister_device(&dev->radio_tx_dev); 1273 video_unregister_device(&dev->radio_rx_dev); 1274 video_unregister_device(&dev->sdr_cap_dev); 1275 video_unregister_device(&dev->vbi_out_dev); 1276 video_unregister_device(&dev->vbi_cap_dev); 1277 video_unregister_device(&dev->vid_out_dev); 1278 video_unregister_device(&dev->vid_cap_dev); 1279free_dev: 1280 v4l2_device_put(&dev->v4l2_dev); 1281 return ret; 1282} 1283 1284/* This routine allocates from 1 to n_devs virtual drivers. 1285 1286 The real maximum number of virtual drivers will depend on how many drivers 1287 will succeed. This is limited to the maximum number of devices that 1288 videodev supports, which is equal to VIDEO_NUM_DEVICES. 1289 */ 1290static int vivid_probe(struct platform_device *pdev) 1291{ 1292 const struct font_desc *font = find_font("VGA8x16"); 1293 int ret = 0, i; 1294 1295 if (font == NULL) { 1296 pr_err("vivid: could not find font\n"); 1297 return -ENODEV; 1298 } 1299 1300 tpg_set_font(font->data); 1301 1302 n_devs = clamp_t(unsigned, n_devs, 1, VIVID_MAX_DEVS); 1303 1304 for (i = 0; i < n_devs; i++) { 1305 ret = vivid_create_instance(pdev, i); 1306 if (ret) { 1307 /* If some instantiations succeeded, keep driver */ 1308 if (i) 1309 ret = 0; 1310 break; 1311 } 1312 } 1313 1314 if (ret < 0) { 1315 pr_err("vivid: error %d while loading driver\n", ret); 1316 return ret; 1317 } 1318 1319 /* n_devs will reflect the actual number of allocated devices */ 1320 n_devs = i; 1321 1322 return ret; 1323} 1324 1325static int vivid_remove(struct platform_device *pdev) 1326{ 1327 struct vivid_dev *dev; 1328 unsigned i; 1329 1330 for (i = 0; vivid_devs[i]; i++) { 1331 dev = vivid_devs[i]; 1332 1333 if (dev->has_vid_cap) { 1334 v4l2_info(&dev->v4l2_dev, "unregistering %s\n", 1335 video_device_node_name(&dev->vid_cap_dev)); 1336 video_unregister_device(&dev->vid_cap_dev); 1337 } 1338 if (dev->has_vid_out) { 1339 v4l2_info(&dev->v4l2_dev, "unregistering %s\n", 1340 video_device_node_name(&dev->vid_out_dev)); 1341 video_unregister_device(&dev->vid_out_dev); 1342 } 1343 if (dev->has_vbi_cap) { 1344 v4l2_info(&dev->v4l2_dev, "unregistering %s\n", 1345 video_device_node_name(&dev->vbi_cap_dev)); 1346 video_unregister_device(&dev->vbi_cap_dev); 1347 } 1348 if (dev->has_vbi_out) { 1349 v4l2_info(&dev->v4l2_dev, "unregistering %s\n", 1350 video_device_node_name(&dev->vbi_out_dev)); 1351 video_unregister_device(&dev->vbi_out_dev); 1352 } 1353 if (dev->has_sdr_cap) { 1354 v4l2_info(&dev->v4l2_dev, "unregistering %s\n", 1355 video_device_node_name(&dev->sdr_cap_dev)); 1356 video_unregister_device(&dev->sdr_cap_dev); 1357 } 1358 if (dev->has_radio_rx) { 1359 v4l2_info(&dev->v4l2_dev, "unregistering %s\n", 1360 video_device_node_name(&dev->radio_rx_dev)); 1361 video_unregister_device(&dev->radio_rx_dev); 1362 } 1363 if (dev->has_radio_tx) { 1364 v4l2_info(&dev->v4l2_dev, "unregistering %s\n", 1365 video_device_node_name(&dev->radio_tx_dev)); 1366 video_unregister_device(&dev->radio_tx_dev); 1367 } 1368 if (dev->has_fb) { 1369 v4l2_info(&dev->v4l2_dev, "unregistering fb%d\n", 1370 dev->fb_info.node); 1371 unregister_framebuffer(&dev->fb_info); 1372 vivid_fb_release_buffers(dev); 1373 } 1374 v4l2_device_put(&dev->v4l2_dev); 1375 vivid_devs[i] = NULL; 1376 } 1377 return 0; 1378} 1379 1380static void vivid_pdev_release(struct device *dev) 1381{ 1382} 1383 1384static struct platform_device vivid_pdev = { 1385 .name = "vivid", 1386 .dev.release = vivid_pdev_release, 1387}; 1388 1389static struct platform_driver vivid_pdrv = { 1390 .probe = vivid_probe, 1391 .remove = vivid_remove, 1392 .driver = { 1393 .name = "vivid", 1394 }, 1395}; 1396 1397static int __init vivid_init(void) 1398{ 1399 int ret; 1400 1401 ret = platform_device_register(&vivid_pdev); 1402 if (ret) 1403 return ret; 1404 1405 ret = platform_driver_register(&vivid_pdrv); 1406 if (ret) 1407 platform_device_unregister(&vivid_pdev); 1408 1409 return ret; 1410} 1411 1412static void __exit vivid_exit(void) 1413{ 1414 platform_driver_unregister(&vivid_pdrv); 1415 platform_device_unregister(&vivid_pdev); 1416} 1417 1418module_init(vivid_init); 1419module_exit(vivid_exit); 1420