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 #include "vivid-meta-cap.h" 41 #include "vivid-meta-out.h" 42 #include "vivid-touch-cap.h" 43 44 #define VIVID_MODULE_NAME "vivid" 45 46 /* The maximum number of vivid devices */ 47 #define VIVID_MAX_DEVS CONFIG_VIDEO_VIVID_MAX_DEVS 48 49 MODULE_DESCRIPTION("Virtual Video Test Driver"); 50 MODULE_AUTHOR("Hans Verkuil"); 51 MODULE_LICENSE("GPL"); 52 53 static unsigned n_devs = 1; 54 module_param(n_devs, uint, 0444); 55 MODULE_PARM_DESC(n_devs, " number of driver instances to create"); 56 57 static int vid_cap_nr[VIVID_MAX_DEVS] = { [0 ... (VIVID_MAX_DEVS - 1)] = -1 }; 58 module_param_array(vid_cap_nr, int, NULL, 0444); 59 MODULE_PARM_DESC(vid_cap_nr, " videoX start number, -1 is autodetect"); 60 61 static int vid_out_nr[VIVID_MAX_DEVS] = { [0 ... (VIVID_MAX_DEVS - 1)] = -1 }; 62 module_param_array(vid_out_nr, int, NULL, 0444); 63 MODULE_PARM_DESC(vid_out_nr, " videoX start number, -1 is autodetect"); 64 65 static int vbi_cap_nr[VIVID_MAX_DEVS] = { [0 ... (VIVID_MAX_DEVS - 1)] = -1 }; 66 module_param_array(vbi_cap_nr, int, NULL, 0444); 67 MODULE_PARM_DESC(vbi_cap_nr, " vbiX start number, -1 is autodetect"); 68 69 static int vbi_out_nr[VIVID_MAX_DEVS] = { [0 ... (VIVID_MAX_DEVS - 1)] = -1 }; 70 module_param_array(vbi_out_nr, int, NULL, 0444); 71 MODULE_PARM_DESC(vbi_out_nr, " vbiX start number, -1 is autodetect"); 72 73 static int sdr_cap_nr[VIVID_MAX_DEVS] = { [0 ... (VIVID_MAX_DEVS - 1)] = -1 }; 74 module_param_array(sdr_cap_nr, int, NULL, 0444); 75 MODULE_PARM_DESC(sdr_cap_nr, " swradioX start number, -1 is autodetect"); 76 77 static int radio_rx_nr[VIVID_MAX_DEVS] = { [0 ... (VIVID_MAX_DEVS - 1)] = -1 }; 78 module_param_array(radio_rx_nr, int, NULL, 0444); 79 MODULE_PARM_DESC(radio_rx_nr, " radioX start number, -1 is autodetect"); 80 81 static int radio_tx_nr[VIVID_MAX_DEVS] = { [0 ... (VIVID_MAX_DEVS - 1)] = -1 }; 82 module_param_array(radio_tx_nr, int, NULL, 0444); 83 MODULE_PARM_DESC(radio_tx_nr, " radioX start number, -1 is autodetect"); 84 85 static int meta_cap_nr[VIVID_MAX_DEVS] = { [0 ... (VIVID_MAX_DEVS - 1)] = -1 }; 86 module_param_array(meta_cap_nr, int, NULL, 0444); 87 MODULE_PARM_DESC(meta_cap_nr, " videoX start number, -1 is autodetect"); 88 89 static int meta_out_nr[VIVID_MAX_DEVS] = { [0 ... (VIVID_MAX_DEVS - 1)] = -1 }; 90 module_param_array(meta_out_nr, int, NULL, 0444); 91 MODULE_PARM_DESC(meta_out_nr, " videoX start number, -1 is autodetect"); 92 93 static int touch_cap_nr[VIVID_MAX_DEVS] = { [0 ... (VIVID_MAX_DEVS - 1)] = -1 }; 94 module_param_array(touch_cap_nr, int, NULL, 0444); 95 MODULE_PARM_DESC(touch_cap_nr, " v4l-touchX start number, -1 is autodetect"); 96 97 static int ccs_cap_mode[VIVID_MAX_DEVS] = { [0 ... (VIVID_MAX_DEVS - 1)] = -1 }; 98 module_param_array(ccs_cap_mode, int, NULL, 0444); 99 MODULE_PARM_DESC(ccs_cap_mode, " capture crop/compose/scale mode:\n" 100 "\t\t bit 0=crop, 1=compose, 2=scale,\n" 101 "\t\t -1=user-controlled (default)"); 102 103 static int ccs_out_mode[VIVID_MAX_DEVS] = { [0 ... (VIVID_MAX_DEVS - 1)] = -1 }; 104 module_param_array(ccs_out_mode, int, NULL, 0444); 105 MODULE_PARM_DESC(ccs_out_mode, " output crop/compose/scale mode:\n" 106 "\t\t bit 0=crop, 1=compose, 2=scale,\n" 107 "\t\t -1=user-controlled (default)"); 108 109 static unsigned multiplanar[VIVID_MAX_DEVS] = { [0 ... (VIVID_MAX_DEVS - 1)] = 1 }; 110 module_param_array(multiplanar, uint, NULL, 0444); 111 MODULE_PARM_DESC(multiplanar, " 1 (default) creates a single planar device, 2 creates a multiplanar device."); 112 113 /* 114 * Default: video + vbi-cap (raw and sliced) + radio rx + radio tx + sdr + 115 * vbi-out + vid-out + meta-cap 116 */ 117 static unsigned int node_types[VIVID_MAX_DEVS] = { 118 [0 ... (VIVID_MAX_DEVS - 1)] = 0xe1d3d 119 }; 120 module_param_array(node_types, uint, NULL, 0444); 121 MODULE_PARM_DESC(node_types, " node types, default is 0xe1d3d. Bitmask with the following meaning:\n" 122 "\t\t bit 0: Video Capture node\n" 123 "\t\t bit 2-3: VBI Capture node: 0 = none, 1 = raw vbi, 2 = sliced vbi, 3 = both\n" 124 "\t\t bit 4: Radio Receiver node\n" 125 "\t\t bit 5: Software Defined Radio Receiver node\n" 126 "\t\t bit 8: Video Output node\n" 127 "\t\t bit 10-11: VBI Output node: 0 = none, 1 = raw vbi, 2 = sliced vbi, 3 = both\n" 128 "\t\t bit 12: Radio Transmitter node\n" 129 "\t\t bit 16: Framebuffer for testing overlays\n" 130 "\t\t bit 17: Metadata Capture node\n" 131 "\t\t bit 18: Metadata Output node\n" 132 "\t\t bit 19: Touch Capture node\n"); 133 134 /* Default: 4 inputs */ 135 static unsigned num_inputs[VIVID_MAX_DEVS] = { [0 ... (VIVID_MAX_DEVS - 1)] = 4 }; 136 module_param_array(num_inputs, uint, NULL, 0444); 137 MODULE_PARM_DESC(num_inputs, " number of inputs, default is 4"); 138 139 /* Default: input 0 = WEBCAM, 1 = TV, 2 = SVID, 3 = HDMI */ 140 static unsigned input_types[VIVID_MAX_DEVS] = { [0 ... (VIVID_MAX_DEVS - 1)] = 0xe4 }; 141 module_param_array(input_types, uint, NULL, 0444); 142 MODULE_PARM_DESC(input_types, " input types, default is 0xe4. Two bits per input,\n" 143 "\t\t bits 0-1 == input 0, bits 31-30 == input 15.\n" 144 "\t\t Type 0 == webcam, 1 == TV, 2 == S-Video, 3 == HDMI"); 145 146 /* Default: 2 outputs */ 147 static unsigned num_outputs[VIVID_MAX_DEVS] = { [0 ... (VIVID_MAX_DEVS - 1)] = 2 }; 148 module_param_array(num_outputs, uint, NULL, 0444); 149 MODULE_PARM_DESC(num_outputs, " number of outputs, default is 2"); 150 151 /* Default: output 0 = SVID, 1 = HDMI */ 152 static unsigned output_types[VIVID_MAX_DEVS] = { [0 ... (VIVID_MAX_DEVS - 1)] = 2 }; 153 module_param_array(output_types, uint, NULL, 0444); 154 MODULE_PARM_DESC(output_types, " output types, default is 0x02. One bit per output,\n" 155 "\t\t bit 0 == output 0, bit 15 == output 15.\n" 156 "\t\t Type 0 == S-Video, 1 == HDMI"); 157 158 unsigned vivid_debug; 159 module_param(vivid_debug, uint, 0644); 160 MODULE_PARM_DESC(vivid_debug, " activates debug info"); 161 162 static bool no_error_inj; 163 module_param(no_error_inj, bool, 0444); 164 MODULE_PARM_DESC(no_error_inj, " if set disable the error injecting controls"); 165 166 static unsigned int allocators[VIVID_MAX_DEVS] = { [0 ... (VIVID_MAX_DEVS - 1)] = 0 }; 167 module_param_array(allocators, uint, NULL, 0444); 168 MODULE_PARM_DESC(allocators, " memory allocator selection, default is 0.\n" 169 "\t\t 0 == vmalloc\n" 170 "\t\t 1 == dma-contig"); 171 172 static struct vivid_dev *vivid_devs[VIVID_MAX_DEVS]; 173 174 const struct v4l2_rect vivid_min_rect = { 175 0, 0, MIN_WIDTH, MIN_HEIGHT 176 }; 177 178 const struct v4l2_rect vivid_max_rect = { 179 0, 0, MAX_WIDTH * MAX_ZOOM, MAX_HEIGHT * MAX_ZOOM 180 }; 181 182 static const u8 vivid_hdmi_edid[256] = { 183 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 184 0x31, 0xd8, 0x34, 0x12, 0x00, 0x00, 0x00, 0x00, 185 0x22, 0x1a, 0x01, 0x03, 0x80, 0x60, 0x36, 0x78, 186 0x0f, 0xee, 0x91, 0xa3, 0x54, 0x4c, 0x99, 0x26, 187 0x0f, 0x50, 0x54, 0x2f, 0xcf, 0x00, 0x31, 0x59, 188 0x45, 0x59, 0x81, 0x80, 0x81, 0x40, 0x90, 0x40, 189 0x95, 0x00, 0xa9, 0x40, 0xb3, 0x00, 0x08, 0xe8, 190 0x00, 0x30, 0xf2, 0x70, 0x5a, 0x80, 0xb0, 0x58, 191 0x8a, 0x00, 0xc0, 0x1c, 0x32, 0x00, 0x00, 0x1e, 192 0x00, 0x00, 0x00, 0xfd, 0x00, 0x18, 0x55, 0x18, 193 0x87, 0x3c, 0x00, 0x0a, 0x20, 0x20, 0x20, 0x20, 194 0x20, 0x20, 0x00, 0x00, 0x00, 0xfc, 0x00, 0x76, 195 0x69, 0x76, 0x69, 0x64, 0x0a, 0x20, 0x20, 0x20, 196 0x20, 0x20, 0x20, 0x20, 0x00, 0x00, 0x00, 0x10, 197 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 198 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x7b, 199 200 0x02, 0x03, 0x3f, 0xf0, 0x51, 0x61, 0x60, 0x5f, 201 0x5e, 0x5d, 0x10, 0x1f, 0x04, 0x13, 0x22, 0x21, 202 0x20, 0x05, 0x14, 0x02, 0x11, 0x01, 0x23, 0x09, 203 0x07, 0x07, 0x83, 0x01, 0x00, 0x00, 0x6d, 0x03, 204 0x0c, 0x00, 0x10, 0x00, 0x00, 0x3c, 0x21, 0x00, 205 0x60, 0x01, 0x02, 0x03, 0x67, 0xd8, 0x5d, 0xc4, 206 0x01, 0x78, 0x00, 0x00, 0xe2, 0x00, 0xea, 0xe3, 207 0x05, 0x00, 0x00, 0xe3, 0x06, 0x01, 0x00, 0x4d, 208 0xd0, 0x00, 0xa0, 0xf0, 0x70, 0x3e, 0x80, 0x30, 209 0x20, 0x35, 0x00, 0xc0, 0x1c, 0x32, 0x00, 0x00, 210 0x1e, 0x1a, 0x36, 0x80, 0xa0, 0x70, 0x38, 0x1f, 211 0x40, 0x30, 0x20, 0x35, 0x00, 0xc0, 0x1c, 0x32, 212 0x00, 0x00, 0x1a, 0x1a, 0x1d, 0x00, 0x80, 0x51, 213 0xd0, 0x1c, 0x20, 0x40, 0x80, 0x35, 0x00, 0xc0, 214 0x1c, 0x32, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 215 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x63, 216 }; 217 218 static int vidioc_querycap(struct file *file, void *priv, 219 struct v4l2_capability *cap) 220 { 221 struct vivid_dev *dev = video_drvdata(file); 222 223 strscpy(cap->driver, "vivid", sizeof(cap->driver)); 224 strscpy(cap->card, "vivid", sizeof(cap->card)); 225 snprintf(cap->bus_info, sizeof(cap->bus_info), 226 "platform:%s", dev->v4l2_dev.name); 227 228 cap->capabilities = dev->vid_cap_caps | dev->vid_out_caps | 229 dev->vbi_cap_caps | dev->vbi_out_caps | 230 dev->radio_rx_caps | dev->radio_tx_caps | 231 dev->sdr_cap_caps | dev->meta_cap_caps | 232 dev->meta_out_caps | dev->touch_cap_caps | 233 V4L2_CAP_DEVICE_CAPS; 234 return 0; 235 } 236 237 static int vidioc_s_hw_freq_seek(struct file *file, void *fh, const struct v4l2_hw_freq_seek *a) 238 { 239 struct video_device *vdev = video_devdata(file); 240 241 if (vdev->vfl_type == VFL_TYPE_RADIO) 242 return vivid_radio_rx_s_hw_freq_seek(file, fh, a); 243 return -ENOTTY; 244 } 245 246 static int vidioc_enum_freq_bands(struct file *file, void *fh, struct v4l2_frequency_band *band) 247 { 248 struct video_device *vdev = video_devdata(file); 249 250 if (vdev->vfl_type == VFL_TYPE_RADIO) 251 return vivid_radio_rx_enum_freq_bands(file, fh, band); 252 if (vdev->vfl_type == VFL_TYPE_SDR) 253 return vivid_sdr_enum_freq_bands(file, fh, band); 254 return -ENOTTY; 255 } 256 257 static int vidioc_g_tuner(struct file *file, void *fh, struct v4l2_tuner *vt) 258 { 259 struct video_device *vdev = video_devdata(file); 260 261 if (vdev->vfl_type == VFL_TYPE_RADIO) 262 return vivid_radio_rx_g_tuner(file, fh, vt); 263 if (vdev->vfl_type == VFL_TYPE_SDR) 264 return vivid_sdr_g_tuner(file, fh, vt); 265 return vivid_video_g_tuner(file, fh, vt); 266 } 267 268 static int vidioc_s_tuner(struct file *file, void *fh, const struct v4l2_tuner *vt) 269 { 270 struct video_device *vdev = video_devdata(file); 271 272 if (vdev->vfl_type == VFL_TYPE_RADIO) 273 return vivid_radio_rx_s_tuner(file, fh, vt); 274 if (vdev->vfl_type == VFL_TYPE_SDR) 275 return vivid_sdr_s_tuner(file, fh, vt); 276 return vivid_video_s_tuner(file, fh, vt); 277 } 278 279 static int vidioc_g_frequency(struct file *file, void *fh, struct v4l2_frequency *vf) 280 { 281 struct vivid_dev *dev = video_drvdata(file); 282 struct video_device *vdev = video_devdata(file); 283 284 if (vdev->vfl_type == VFL_TYPE_RADIO) 285 return vivid_radio_g_frequency(file, 286 vdev->vfl_dir == VFL_DIR_RX ? 287 &dev->radio_rx_freq : &dev->radio_tx_freq, vf); 288 if (vdev->vfl_type == VFL_TYPE_SDR) 289 return vivid_sdr_g_frequency(file, fh, vf); 290 return vivid_video_g_frequency(file, fh, vf); 291 } 292 293 static int vidioc_s_frequency(struct file *file, void *fh, const struct v4l2_frequency *vf) 294 { 295 struct vivid_dev *dev = video_drvdata(file); 296 struct video_device *vdev = video_devdata(file); 297 298 if (vdev->vfl_type == VFL_TYPE_RADIO) 299 return vivid_radio_s_frequency(file, 300 vdev->vfl_dir == VFL_DIR_RX ? 301 &dev->radio_rx_freq : &dev->radio_tx_freq, vf); 302 if (vdev->vfl_type == VFL_TYPE_SDR) 303 return vivid_sdr_s_frequency(file, fh, vf); 304 return vivid_video_s_frequency(file, fh, vf); 305 } 306 307 static int vidioc_overlay(struct file *file, void *fh, unsigned i) 308 { 309 struct video_device *vdev = video_devdata(file); 310 311 if (vdev->vfl_dir == VFL_DIR_RX) 312 return vivid_vid_cap_overlay(file, fh, i); 313 return vivid_vid_out_overlay(file, fh, i); 314 } 315 316 static int vidioc_g_fbuf(struct file *file, void *fh, struct v4l2_framebuffer *a) 317 { 318 struct video_device *vdev = video_devdata(file); 319 320 if (vdev->vfl_dir == VFL_DIR_RX) 321 return vivid_vid_cap_g_fbuf(file, fh, a); 322 return vivid_vid_out_g_fbuf(file, fh, a); 323 } 324 325 static int vidioc_s_fbuf(struct file *file, void *fh, const struct v4l2_framebuffer *a) 326 { 327 struct video_device *vdev = video_devdata(file); 328 329 if (vdev->vfl_dir == VFL_DIR_RX) 330 return vivid_vid_cap_s_fbuf(file, fh, a); 331 return vivid_vid_out_s_fbuf(file, fh, a); 332 } 333 334 static int vidioc_s_std(struct file *file, void *fh, v4l2_std_id id) 335 { 336 struct video_device *vdev = video_devdata(file); 337 338 if (vdev->vfl_dir == VFL_DIR_RX) 339 return vivid_vid_cap_s_std(file, fh, id); 340 return vivid_vid_out_s_std(file, fh, id); 341 } 342 343 static int vidioc_s_dv_timings(struct file *file, void *fh, struct v4l2_dv_timings *timings) 344 { 345 struct video_device *vdev = video_devdata(file); 346 347 if (vdev->vfl_dir == VFL_DIR_RX) 348 return vivid_vid_cap_s_dv_timings(file, fh, timings); 349 return vivid_vid_out_s_dv_timings(file, fh, timings); 350 } 351 352 static int vidioc_g_pixelaspect(struct file *file, void *fh, 353 int type, struct v4l2_fract *f) 354 { 355 struct video_device *vdev = video_devdata(file); 356 357 if (vdev->vfl_dir == VFL_DIR_RX) 358 return vivid_vid_cap_g_pixelaspect(file, fh, type, f); 359 return vivid_vid_out_g_pixelaspect(file, fh, type, f); 360 } 361 362 static int vidioc_g_selection(struct file *file, void *fh, 363 struct v4l2_selection *sel) 364 { 365 struct video_device *vdev = video_devdata(file); 366 367 if (vdev->vfl_dir == VFL_DIR_RX) 368 return vivid_vid_cap_g_selection(file, fh, sel); 369 return vivid_vid_out_g_selection(file, fh, sel); 370 } 371 372 static int vidioc_s_selection(struct file *file, void *fh, 373 struct v4l2_selection *sel) 374 { 375 struct video_device *vdev = video_devdata(file); 376 377 if (vdev->vfl_dir == VFL_DIR_RX) 378 return vivid_vid_cap_s_selection(file, fh, sel); 379 return vivid_vid_out_s_selection(file, fh, sel); 380 } 381 382 static int vidioc_g_parm(struct file *file, void *fh, 383 struct v4l2_streamparm *parm) 384 { 385 struct video_device *vdev = video_devdata(file); 386 387 if (vdev->vfl_type == VFL_TYPE_TOUCH) 388 return vivid_g_parm_tch(file, fh, parm); 389 if (vdev->vfl_dir == VFL_DIR_RX) 390 return vivid_vid_cap_g_parm(file, fh, parm); 391 return vivid_vid_out_g_parm(file, fh, parm); 392 } 393 394 static int vidioc_s_parm(struct file *file, void *fh, 395 struct v4l2_streamparm *parm) 396 { 397 struct video_device *vdev = video_devdata(file); 398 399 if (vdev->vfl_dir == VFL_DIR_RX) 400 return vivid_vid_cap_s_parm(file, fh, parm); 401 return -ENOTTY; 402 } 403 404 static int vidioc_log_status(struct file *file, void *fh) 405 { 406 struct vivid_dev *dev = video_drvdata(file); 407 struct video_device *vdev = video_devdata(file); 408 409 v4l2_ctrl_log_status(file, fh); 410 if (vdev->vfl_dir == VFL_DIR_RX && vdev->vfl_type == VFL_TYPE_VIDEO) 411 tpg_log_status(&dev->tpg); 412 return 0; 413 } 414 415 static ssize_t vivid_radio_read(struct file *file, char __user *buf, 416 size_t size, loff_t *offset) 417 { 418 struct video_device *vdev = video_devdata(file); 419 420 if (vdev->vfl_dir == VFL_DIR_TX) 421 return -EINVAL; 422 return vivid_radio_rx_read(file, buf, size, offset); 423 } 424 425 static ssize_t vivid_radio_write(struct file *file, const char __user *buf, 426 size_t size, loff_t *offset) 427 { 428 struct video_device *vdev = video_devdata(file); 429 430 if (vdev->vfl_dir == VFL_DIR_RX) 431 return -EINVAL; 432 return vivid_radio_tx_write(file, buf, size, offset); 433 } 434 435 static __poll_t vivid_radio_poll(struct file *file, struct poll_table_struct *wait) 436 { 437 struct video_device *vdev = video_devdata(file); 438 439 if (vdev->vfl_dir == VFL_DIR_RX) 440 return vivid_radio_rx_poll(file, wait); 441 return vivid_radio_tx_poll(file, wait); 442 } 443 444 static int vivid_enum_input(struct file *file, void *priv, 445 struct v4l2_input *inp) 446 { 447 struct video_device *vdev = video_devdata(file); 448 449 if (vdev->vfl_type == VFL_TYPE_TOUCH) 450 return vivid_enum_input_tch(file, priv, inp); 451 return vidioc_enum_input(file, priv, inp); 452 } 453 454 static int vivid_g_input(struct file *file, void *priv, unsigned int *i) 455 { 456 struct video_device *vdev = video_devdata(file); 457 458 if (vdev->vfl_type == VFL_TYPE_TOUCH) 459 return vivid_g_input_tch(file, priv, i); 460 return vidioc_g_input(file, priv, i); 461 } 462 463 static int vivid_s_input(struct file *file, void *priv, unsigned int i) 464 { 465 struct video_device *vdev = video_devdata(file); 466 467 if (vdev->vfl_type == VFL_TYPE_TOUCH) 468 return vivid_s_input_tch(file, priv, i); 469 return vidioc_s_input(file, priv, i); 470 } 471 472 static int vivid_enum_fmt_cap(struct file *file, void *priv, 473 struct v4l2_fmtdesc *f) 474 { 475 struct video_device *vdev = video_devdata(file); 476 477 if (vdev->vfl_type == VFL_TYPE_TOUCH) 478 return vivid_enum_fmt_tch(file, priv, f); 479 return vivid_enum_fmt_vid(file, priv, f); 480 } 481 482 static int vivid_g_fmt_cap(struct file *file, void *priv, 483 struct v4l2_format *f) 484 { 485 struct video_device *vdev = video_devdata(file); 486 487 if (vdev->vfl_type == VFL_TYPE_TOUCH) 488 return vivid_g_fmt_tch(file, priv, f); 489 return vidioc_g_fmt_vid_cap(file, priv, f); 490 } 491 492 static int vivid_try_fmt_cap(struct file *file, void *priv, 493 struct v4l2_format *f) 494 { 495 struct video_device *vdev = video_devdata(file); 496 497 if (vdev->vfl_type == VFL_TYPE_TOUCH) 498 return vivid_g_fmt_tch(file, priv, f); 499 return vidioc_try_fmt_vid_cap(file, priv, f); 500 } 501 502 static int vivid_s_fmt_cap(struct file *file, void *priv, 503 struct v4l2_format *f) 504 { 505 struct video_device *vdev = video_devdata(file); 506 507 if (vdev->vfl_type == VFL_TYPE_TOUCH) 508 return vivid_g_fmt_tch(file, priv, f); 509 return vidioc_s_fmt_vid_cap(file, priv, f); 510 } 511 512 static int vivid_g_fmt_cap_mplane(struct file *file, void *priv, 513 struct v4l2_format *f) 514 { 515 struct video_device *vdev = video_devdata(file); 516 517 if (vdev->vfl_type == VFL_TYPE_TOUCH) 518 return vivid_g_fmt_tch_mplane(file, priv, f); 519 return vidioc_g_fmt_vid_cap_mplane(file, priv, f); 520 } 521 522 static int vivid_try_fmt_cap_mplane(struct file *file, void *priv, 523 struct v4l2_format *f) 524 { 525 struct video_device *vdev = video_devdata(file); 526 527 if (vdev->vfl_type == VFL_TYPE_TOUCH) 528 return vivid_g_fmt_tch_mplane(file, priv, f); 529 return vidioc_try_fmt_vid_cap_mplane(file, priv, f); 530 } 531 532 static int vivid_s_fmt_cap_mplane(struct file *file, void *priv, 533 struct v4l2_format *f) 534 { 535 struct video_device *vdev = video_devdata(file); 536 537 if (vdev->vfl_type == VFL_TYPE_TOUCH) 538 return vivid_g_fmt_tch_mplane(file, priv, f); 539 return vidioc_s_fmt_vid_cap_mplane(file, priv, f); 540 } 541 542 static bool vivid_is_in_use(struct video_device *vdev) 543 { 544 unsigned long flags; 545 bool res; 546 547 spin_lock_irqsave(&vdev->fh_lock, flags); 548 res = !list_empty(&vdev->fh_list); 549 spin_unlock_irqrestore(&vdev->fh_lock, flags); 550 return res; 551 } 552 553 static bool vivid_is_last_user(struct vivid_dev *dev) 554 { 555 unsigned uses = vivid_is_in_use(&dev->vid_cap_dev) + 556 vivid_is_in_use(&dev->vid_out_dev) + 557 vivid_is_in_use(&dev->vbi_cap_dev) + 558 vivid_is_in_use(&dev->vbi_out_dev) + 559 vivid_is_in_use(&dev->sdr_cap_dev) + 560 vivid_is_in_use(&dev->radio_rx_dev) + 561 vivid_is_in_use(&dev->radio_tx_dev) + 562 vivid_is_in_use(&dev->meta_cap_dev) + 563 vivid_is_in_use(&dev->meta_out_dev) + 564 vivid_is_in_use(&dev->touch_cap_dev); 565 566 return uses == 1; 567 } 568 569 static int vivid_fop_release(struct file *file) 570 { 571 struct vivid_dev *dev = video_drvdata(file); 572 struct video_device *vdev = video_devdata(file); 573 574 mutex_lock(&dev->mutex); 575 if (!no_error_inj && v4l2_fh_is_singular_file(file) && 576 !video_is_registered(vdev) && vivid_is_last_user(dev)) { 577 /* 578 * I am the last user of this driver, and a disconnect 579 * was forced (since this video_device is unregistered), 580 * so re-register all video_device's again. 581 */ 582 v4l2_info(&dev->v4l2_dev, "reconnect\n"); 583 set_bit(V4L2_FL_REGISTERED, &dev->vid_cap_dev.flags); 584 set_bit(V4L2_FL_REGISTERED, &dev->vid_out_dev.flags); 585 set_bit(V4L2_FL_REGISTERED, &dev->vbi_cap_dev.flags); 586 set_bit(V4L2_FL_REGISTERED, &dev->vbi_out_dev.flags); 587 set_bit(V4L2_FL_REGISTERED, &dev->sdr_cap_dev.flags); 588 set_bit(V4L2_FL_REGISTERED, &dev->radio_rx_dev.flags); 589 set_bit(V4L2_FL_REGISTERED, &dev->radio_tx_dev.flags); 590 set_bit(V4L2_FL_REGISTERED, &dev->meta_cap_dev.flags); 591 set_bit(V4L2_FL_REGISTERED, &dev->meta_out_dev.flags); 592 set_bit(V4L2_FL_REGISTERED, &dev->touch_cap_dev.flags); 593 } 594 mutex_unlock(&dev->mutex); 595 if (file->private_data == dev->overlay_cap_owner) 596 dev->overlay_cap_owner = NULL; 597 if (file->private_data == dev->radio_rx_rds_owner) { 598 dev->radio_rx_rds_last_block = 0; 599 dev->radio_rx_rds_owner = NULL; 600 } 601 if (file->private_data == dev->radio_tx_rds_owner) { 602 dev->radio_tx_rds_last_block = 0; 603 dev->radio_tx_rds_owner = NULL; 604 } 605 if (vdev->queue) 606 return vb2_fop_release(file); 607 return v4l2_fh_release(file); 608 } 609 610 static const struct v4l2_file_operations vivid_fops = { 611 .owner = THIS_MODULE, 612 .open = v4l2_fh_open, 613 .release = vivid_fop_release, 614 .read = vb2_fop_read, 615 .write = vb2_fop_write, 616 .poll = vb2_fop_poll, 617 .unlocked_ioctl = video_ioctl2, 618 .mmap = vb2_fop_mmap, 619 }; 620 621 static const struct v4l2_file_operations vivid_radio_fops = { 622 .owner = THIS_MODULE, 623 .open = v4l2_fh_open, 624 .release = vivid_fop_release, 625 .read = vivid_radio_read, 626 .write = vivid_radio_write, 627 .poll = vivid_radio_poll, 628 .unlocked_ioctl = video_ioctl2, 629 }; 630 631 static const struct v4l2_ioctl_ops vivid_ioctl_ops = { 632 .vidioc_querycap = vidioc_querycap, 633 634 .vidioc_enum_fmt_vid_cap = vivid_enum_fmt_cap, 635 .vidioc_g_fmt_vid_cap = vivid_g_fmt_cap, 636 .vidioc_try_fmt_vid_cap = vivid_try_fmt_cap, 637 .vidioc_s_fmt_vid_cap = vivid_s_fmt_cap, 638 .vidioc_g_fmt_vid_cap_mplane = vivid_g_fmt_cap_mplane, 639 .vidioc_try_fmt_vid_cap_mplane = vivid_try_fmt_cap_mplane, 640 .vidioc_s_fmt_vid_cap_mplane = vivid_s_fmt_cap_mplane, 641 642 .vidioc_enum_fmt_vid_out = vivid_enum_fmt_vid, 643 .vidioc_g_fmt_vid_out = vidioc_g_fmt_vid_out, 644 .vidioc_try_fmt_vid_out = vidioc_try_fmt_vid_out, 645 .vidioc_s_fmt_vid_out = vidioc_s_fmt_vid_out, 646 .vidioc_g_fmt_vid_out_mplane = vidioc_g_fmt_vid_out_mplane, 647 .vidioc_try_fmt_vid_out_mplane = vidioc_try_fmt_vid_out_mplane, 648 .vidioc_s_fmt_vid_out_mplane = vidioc_s_fmt_vid_out_mplane, 649 650 .vidioc_g_selection = vidioc_g_selection, 651 .vidioc_s_selection = vidioc_s_selection, 652 .vidioc_g_pixelaspect = vidioc_g_pixelaspect, 653 654 .vidioc_g_fmt_vbi_cap = vidioc_g_fmt_vbi_cap, 655 .vidioc_try_fmt_vbi_cap = vidioc_g_fmt_vbi_cap, 656 .vidioc_s_fmt_vbi_cap = vidioc_s_fmt_vbi_cap, 657 658 .vidioc_g_fmt_sliced_vbi_cap = vidioc_g_fmt_sliced_vbi_cap, 659 .vidioc_try_fmt_sliced_vbi_cap = vidioc_try_fmt_sliced_vbi_cap, 660 .vidioc_s_fmt_sliced_vbi_cap = vidioc_s_fmt_sliced_vbi_cap, 661 .vidioc_g_sliced_vbi_cap = vidioc_g_sliced_vbi_cap, 662 663 .vidioc_g_fmt_vbi_out = vidioc_g_fmt_vbi_out, 664 .vidioc_try_fmt_vbi_out = vidioc_g_fmt_vbi_out, 665 .vidioc_s_fmt_vbi_out = vidioc_s_fmt_vbi_out, 666 667 .vidioc_g_fmt_sliced_vbi_out = vidioc_g_fmt_sliced_vbi_out, 668 .vidioc_try_fmt_sliced_vbi_out = vidioc_try_fmt_sliced_vbi_out, 669 .vidioc_s_fmt_sliced_vbi_out = vidioc_s_fmt_sliced_vbi_out, 670 671 .vidioc_enum_fmt_sdr_cap = vidioc_enum_fmt_sdr_cap, 672 .vidioc_g_fmt_sdr_cap = vidioc_g_fmt_sdr_cap, 673 .vidioc_try_fmt_sdr_cap = vidioc_try_fmt_sdr_cap, 674 .vidioc_s_fmt_sdr_cap = vidioc_s_fmt_sdr_cap, 675 676 .vidioc_overlay = vidioc_overlay, 677 .vidioc_enum_framesizes = vidioc_enum_framesizes, 678 .vidioc_enum_frameintervals = vidioc_enum_frameintervals, 679 .vidioc_g_parm = vidioc_g_parm, 680 .vidioc_s_parm = vidioc_s_parm, 681 682 .vidioc_enum_fmt_vid_overlay = vidioc_enum_fmt_vid_overlay, 683 .vidioc_g_fmt_vid_overlay = vidioc_g_fmt_vid_overlay, 684 .vidioc_try_fmt_vid_overlay = vidioc_try_fmt_vid_overlay, 685 .vidioc_s_fmt_vid_overlay = vidioc_s_fmt_vid_overlay, 686 .vidioc_g_fmt_vid_out_overlay = vidioc_g_fmt_vid_out_overlay, 687 .vidioc_try_fmt_vid_out_overlay = vidioc_try_fmt_vid_out_overlay, 688 .vidioc_s_fmt_vid_out_overlay = vidioc_s_fmt_vid_out_overlay, 689 .vidioc_g_fbuf = vidioc_g_fbuf, 690 .vidioc_s_fbuf = vidioc_s_fbuf, 691 692 .vidioc_reqbufs = vb2_ioctl_reqbufs, 693 .vidioc_create_bufs = vb2_ioctl_create_bufs, 694 .vidioc_prepare_buf = vb2_ioctl_prepare_buf, 695 .vidioc_querybuf = vb2_ioctl_querybuf, 696 .vidioc_qbuf = vb2_ioctl_qbuf, 697 .vidioc_dqbuf = vb2_ioctl_dqbuf, 698 .vidioc_expbuf = vb2_ioctl_expbuf, 699 .vidioc_streamon = vb2_ioctl_streamon, 700 .vidioc_streamoff = vb2_ioctl_streamoff, 701 702 .vidioc_enum_input = vivid_enum_input, 703 .vidioc_g_input = vivid_g_input, 704 .vidioc_s_input = vivid_s_input, 705 .vidioc_s_audio = vidioc_s_audio, 706 .vidioc_g_audio = vidioc_g_audio, 707 .vidioc_enumaudio = vidioc_enumaudio, 708 .vidioc_s_frequency = vidioc_s_frequency, 709 .vidioc_g_frequency = vidioc_g_frequency, 710 .vidioc_s_tuner = vidioc_s_tuner, 711 .vidioc_g_tuner = vidioc_g_tuner, 712 .vidioc_s_modulator = vidioc_s_modulator, 713 .vidioc_g_modulator = vidioc_g_modulator, 714 .vidioc_s_hw_freq_seek = vidioc_s_hw_freq_seek, 715 .vidioc_enum_freq_bands = vidioc_enum_freq_bands, 716 717 .vidioc_enum_output = vidioc_enum_output, 718 .vidioc_g_output = vidioc_g_output, 719 .vidioc_s_output = vidioc_s_output, 720 .vidioc_s_audout = vidioc_s_audout, 721 .vidioc_g_audout = vidioc_g_audout, 722 .vidioc_enumaudout = vidioc_enumaudout, 723 724 .vidioc_querystd = vidioc_querystd, 725 .vidioc_g_std = vidioc_g_std, 726 .vidioc_s_std = vidioc_s_std, 727 .vidioc_s_dv_timings = vidioc_s_dv_timings, 728 .vidioc_g_dv_timings = vidioc_g_dv_timings, 729 .vidioc_query_dv_timings = vidioc_query_dv_timings, 730 .vidioc_enum_dv_timings = vidioc_enum_dv_timings, 731 .vidioc_dv_timings_cap = vidioc_dv_timings_cap, 732 .vidioc_g_edid = vidioc_g_edid, 733 .vidioc_s_edid = vidioc_s_edid, 734 735 .vidioc_log_status = vidioc_log_status, 736 .vidioc_subscribe_event = vidioc_subscribe_event, 737 .vidioc_unsubscribe_event = v4l2_event_unsubscribe, 738 739 .vidioc_enum_fmt_meta_cap = vidioc_enum_fmt_meta_cap, 740 .vidioc_g_fmt_meta_cap = vidioc_g_fmt_meta_cap, 741 .vidioc_s_fmt_meta_cap = vidioc_g_fmt_meta_cap, 742 .vidioc_try_fmt_meta_cap = vidioc_g_fmt_meta_cap, 743 744 .vidioc_enum_fmt_meta_out = vidioc_enum_fmt_meta_out, 745 .vidioc_g_fmt_meta_out = vidioc_g_fmt_meta_out, 746 .vidioc_s_fmt_meta_out = vidioc_g_fmt_meta_out, 747 .vidioc_try_fmt_meta_out = vidioc_g_fmt_meta_out, 748 }; 749 750 /* ----------------------------------------------------------------- 751 Initialization and module stuff 752 ------------------------------------------------------------------*/ 753 754 static void vivid_dev_release(struct v4l2_device *v4l2_dev) 755 { 756 struct vivid_dev *dev = container_of(v4l2_dev, struct vivid_dev, v4l2_dev); 757 758 vivid_free_controls(dev); 759 v4l2_device_unregister(&dev->v4l2_dev); 760 #ifdef CONFIG_MEDIA_CONTROLLER 761 media_device_cleanup(&dev->mdev); 762 #endif 763 vfree(dev->scaled_line); 764 vfree(dev->blended_line); 765 vfree(dev->edid); 766 vfree(dev->bitmap_cap); 767 vfree(dev->bitmap_out); 768 tpg_free(&dev->tpg); 769 kfree(dev->query_dv_timings_qmenu); 770 kfree(dev->query_dv_timings_qmenu_strings); 771 kfree(dev); 772 } 773 774 #ifdef CONFIG_MEDIA_CONTROLLER 775 static int vivid_req_validate(struct media_request *req) 776 { 777 struct vivid_dev *dev = container_of(req->mdev, struct vivid_dev, mdev); 778 779 if (dev->req_validate_error) { 780 dev->req_validate_error = false; 781 return -EINVAL; 782 } 783 return vb2_request_validate(req); 784 } 785 786 static const struct media_device_ops vivid_media_ops = { 787 .req_validate = vivid_req_validate, 788 .req_queue = vb2_request_queue, 789 }; 790 #endif 791 792 static int vivid_create_queue(struct vivid_dev *dev, 793 struct vb2_queue *q, 794 u32 buf_type, 795 unsigned int min_buffers_needed, 796 const struct vb2_ops *ops) 797 { 798 if (buf_type == V4L2_BUF_TYPE_VIDEO_CAPTURE && dev->multiplanar) 799 buf_type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE; 800 else if (buf_type == V4L2_BUF_TYPE_VIDEO_OUTPUT && dev->multiplanar) 801 buf_type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE; 802 else if (buf_type == V4L2_BUF_TYPE_VBI_CAPTURE && !dev->has_raw_vbi_cap) 803 buf_type = V4L2_BUF_TYPE_SLICED_VBI_CAPTURE; 804 else if (buf_type == V4L2_BUF_TYPE_VBI_OUTPUT && !dev->has_raw_vbi_out) 805 buf_type = V4L2_BUF_TYPE_SLICED_VBI_OUTPUT; 806 807 q->type = buf_type; 808 q->io_modes = VB2_MMAP | VB2_DMABUF; 809 q->io_modes |= V4L2_TYPE_IS_OUTPUT(buf_type) ? VB2_WRITE : VB2_READ; 810 if (allocators[dev->inst] != 1) 811 q->io_modes |= VB2_USERPTR; 812 q->drv_priv = dev; 813 q->buf_struct_size = sizeof(struct vivid_buffer); 814 q->ops = ops; 815 q->mem_ops = allocators[dev->inst] == 1 ? &vb2_dma_contig_memops : 816 &vb2_vmalloc_memops; 817 q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC; 818 q->min_buffers_needed = min_buffers_needed; 819 q->lock = &dev->mutex; 820 q->dev = dev->v4l2_dev.dev; 821 q->supports_requests = true; 822 823 return vb2_queue_init(q); 824 } 825 826 static int vivid_create_instance(struct platform_device *pdev, int inst) 827 { 828 static const struct v4l2_dv_timings def_dv_timings = 829 V4L2_DV_BT_CEA_1280X720P60; 830 unsigned in_type_counter[4] = { 0, 0, 0, 0 }; 831 unsigned out_type_counter[4] = { 0, 0, 0, 0 }; 832 int ccs_cap = ccs_cap_mode[inst]; 833 int ccs_out = ccs_out_mode[inst]; 834 bool has_tuner; 835 bool has_modulator; 836 struct vivid_dev *dev; 837 struct video_device *vfd; 838 unsigned node_type = node_types[inst]; 839 v4l2_std_id tvnorms_cap = 0, tvnorms_out = 0; 840 int ret; 841 int i; 842 #ifdef CONFIG_VIDEO_VIVID_CEC 843 unsigned int cec_tx_bus_cnt = 0; 844 #endif 845 846 /* allocate main vivid state structure */ 847 dev = kzalloc(sizeof(*dev), GFP_KERNEL); 848 if (!dev) 849 return -ENOMEM; 850 851 dev->inst = inst; 852 853 #ifdef CONFIG_MEDIA_CONTROLLER 854 dev->v4l2_dev.mdev = &dev->mdev; 855 856 /* Initialize media device */ 857 strscpy(dev->mdev.model, VIVID_MODULE_NAME, sizeof(dev->mdev.model)); 858 snprintf(dev->mdev.bus_info, sizeof(dev->mdev.bus_info), 859 "platform:%s-%03d", VIVID_MODULE_NAME, inst); 860 dev->mdev.dev = &pdev->dev; 861 media_device_init(&dev->mdev); 862 dev->mdev.ops = &vivid_media_ops; 863 #endif 864 865 /* register v4l2_device */ 866 snprintf(dev->v4l2_dev.name, sizeof(dev->v4l2_dev.name), 867 "%s-%03d", VIVID_MODULE_NAME, inst); 868 ret = v4l2_device_register(&pdev->dev, &dev->v4l2_dev); 869 if (ret) { 870 kfree(dev); 871 return ret; 872 } 873 dev->v4l2_dev.release = vivid_dev_release; 874 875 /* start detecting feature set */ 876 877 /* do we use single- or multi-planar? */ 878 dev->multiplanar = multiplanar[inst] > 1; 879 v4l2_info(&dev->v4l2_dev, "using %splanar format API\n", 880 dev->multiplanar ? "multi" : "single "); 881 882 /* how many inputs do we have and of what type? */ 883 dev->num_inputs = num_inputs[inst]; 884 if (dev->num_inputs < 1) 885 dev->num_inputs = 1; 886 if (dev->num_inputs >= MAX_INPUTS) 887 dev->num_inputs = MAX_INPUTS; 888 for (i = 0; i < dev->num_inputs; i++) { 889 dev->input_type[i] = (input_types[inst] >> (i * 2)) & 0x3; 890 dev->input_name_counter[i] = in_type_counter[dev->input_type[i]]++; 891 } 892 dev->has_audio_inputs = in_type_counter[TV] && in_type_counter[SVID]; 893 if (in_type_counter[HDMI] == 16) { 894 /* The CEC physical address only allows for max 15 inputs */ 895 in_type_counter[HDMI]--; 896 dev->num_inputs--; 897 } 898 dev->num_hdmi_inputs = in_type_counter[HDMI]; 899 900 /* how many outputs do we have and of what type? */ 901 dev->num_outputs = num_outputs[inst]; 902 if (dev->num_outputs < 1) 903 dev->num_outputs = 1; 904 if (dev->num_outputs >= MAX_OUTPUTS) 905 dev->num_outputs = MAX_OUTPUTS; 906 for (i = 0; i < dev->num_outputs; i++) { 907 dev->output_type[i] = ((output_types[inst] >> i) & 1) ? HDMI : SVID; 908 dev->output_name_counter[i] = out_type_counter[dev->output_type[i]]++; 909 dev->display_present[i] = true; 910 } 911 dev->has_audio_outputs = out_type_counter[SVID]; 912 if (out_type_counter[HDMI] == 16) { 913 /* 914 * The CEC physical address only allows for max 15 inputs, 915 * so outputs are also limited to 15 to allow for easy 916 * CEC output to input mapping. 917 */ 918 out_type_counter[HDMI]--; 919 dev->num_outputs--; 920 } 921 dev->num_hdmi_outputs = out_type_counter[HDMI]; 922 923 /* do we create a video capture device? */ 924 dev->has_vid_cap = node_type & 0x0001; 925 926 /* do we create a vbi capture device? */ 927 if (in_type_counter[TV] || in_type_counter[SVID]) { 928 dev->has_raw_vbi_cap = node_type & 0x0004; 929 dev->has_sliced_vbi_cap = node_type & 0x0008; 930 dev->has_vbi_cap = dev->has_raw_vbi_cap | dev->has_sliced_vbi_cap; 931 } 932 933 /* do we create a meta capture device */ 934 dev->has_meta_cap = node_type & 0x20000; 935 936 /* sanity checks */ 937 if ((in_type_counter[WEBCAM] || in_type_counter[HDMI]) && 938 !dev->has_vid_cap && !dev->has_meta_cap) { 939 v4l2_warn(&dev->v4l2_dev, 940 "Webcam or HDMI input without video or metadata nodes\n"); 941 kfree(dev); 942 return -EINVAL; 943 } 944 if ((in_type_counter[TV] || in_type_counter[SVID]) && 945 !dev->has_vid_cap && !dev->has_vbi_cap && !dev->has_meta_cap) { 946 v4l2_warn(&dev->v4l2_dev, 947 "TV or S-Video input without video, VBI or metadata nodes\n"); 948 kfree(dev); 949 return -EINVAL; 950 } 951 952 /* do we create a video output device? */ 953 dev->has_vid_out = node_type & 0x0100; 954 955 /* do we create a vbi output device? */ 956 if (out_type_counter[SVID]) { 957 dev->has_raw_vbi_out = node_type & 0x0400; 958 dev->has_sliced_vbi_out = node_type & 0x0800; 959 dev->has_vbi_out = dev->has_raw_vbi_out | dev->has_sliced_vbi_out; 960 } 961 962 /* do we create a metadata output device */ 963 dev->has_meta_out = node_type & 0x40000; 964 965 /* sanity checks */ 966 if (out_type_counter[SVID] && 967 !dev->has_vid_out && !dev->has_vbi_out && !dev->has_meta_out) { 968 v4l2_warn(&dev->v4l2_dev, 969 "S-Video output without video, VBI or metadata nodes\n"); 970 kfree(dev); 971 return -EINVAL; 972 } 973 if (out_type_counter[HDMI] && !dev->has_vid_out && !dev->has_meta_out) { 974 v4l2_warn(&dev->v4l2_dev, 975 "HDMI output without video or metadata nodes\n"); 976 kfree(dev); 977 return -EINVAL; 978 } 979 980 /* do we create a radio receiver device? */ 981 dev->has_radio_rx = node_type & 0x0010; 982 983 /* do we create a radio transmitter device? */ 984 dev->has_radio_tx = node_type & 0x1000; 985 986 /* do we create a software defined radio capture device? */ 987 dev->has_sdr_cap = node_type & 0x0020; 988 989 /* do we have a TV tuner? */ 990 dev->has_tv_tuner = in_type_counter[TV]; 991 992 /* do we have a tuner? */ 993 has_tuner = ((dev->has_vid_cap || dev->has_vbi_cap) && in_type_counter[TV]) || 994 dev->has_radio_rx || dev->has_sdr_cap; 995 996 /* do we have a modulator? */ 997 has_modulator = dev->has_radio_tx; 998 999 if (dev->has_vid_cap) 1000 /* do we have a framebuffer for overlay testing? */ 1001 dev->has_fb = node_type & 0x10000; 1002 1003 /* can we do crop/compose/scaling while capturing? */ 1004 if (no_error_inj && ccs_cap == -1) 1005 ccs_cap = 7; 1006 1007 /* if ccs_cap == -1, then the user can select it using controls */ 1008 if (ccs_cap != -1) { 1009 dev->has_crop_cap = ccs_cap & 1; 1010 dev->has_compose_cap = ccs_cap & 2; 1011 dev->has_scaler_cap = ccs_cap & 4; 1012 v4l2_info(&dev->v4l2_dev, "Capture Crop: %c Compose: %c Scaler: %c\n", 1013 dev->has_crop_cap ? 'Y' : 'N', 1014 dev->has_compose_cap ? 'Y' : 'N', 1015 dev->has_scaler_cap ? 'Y' : 'N'); 1016 } 1017 1018 /* can we do crop/compose/scaling with video output? */ 1019 if (no_error_inj && ccs_out == -1) 1020 ccs_out = 7; 1021 1022 /* if ccs_out == -1, then the user can select it using controls */ 1023 if (ccs_out != -1) { 1024 dev->has_crop_out = ccs_out & 1; 1025 dev->has_compose_out = ccs_out & 2; 1026 dev->has_scaler_out = ccs_out & 4; 1027 v4l2_info(&dev->v4l2_dev, "Output Crop: %c Compose: %c Scaler: %c\n", 1028 dev->has_crop_out ? 'Y' : 'N', 1029 dev->has_compose_out ? 'Y' : 'N', 1030 dev->has_scaler_out ? 'Y' : 'N'); 1031 } 1032 1033 /* do we create a touch capture device */ 1034 dev->has_touch_cap = node_type & 0x80000; 1035 1036 /* end detecting feature set */ 1037 1038 if (dev->has_vid_cap) { 1039 /* set up the capabilities of the video capture device */ 1040 dev->vid_cap_caps = dev->multiplanar ? 1041 V4L2_CAP_VIDEO_CAPTURE_MPLANE : 1042 V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_VIDEO_OVERLAY; 1043 dev->vid_cap_caps |= V4L2_CAP_STREAMING | V4L2_CAP_READWRITE; 1044 if (dev->has_audio_inputs) 1045 dev->vid_cap_caps |= V4L2_CAP_AUDIO; 1046 if (dev->has_tv_tuner) 1047 dev->vid_cap_caps |= V4L2_CAP_TUNER; 1048 } 1049 if (dev->has_vid_out) { 1050 /* set up the capabilities of the video output device */ 1051 dev->vid_out_caps = dev->multiplanar ? 1052 V4L2_CAP_VIDEO_OUTPUT_MPLANE : 1053 V4L2_CAP_VIDEO_OUTPUT; 1054 if (dev->has_fb) 1055 dev->vid_out_caps |= V4L2_CAP_VIDEO_OUTPUT_OVERLAY; 1056 dev->vid_out_caps |= V4L2_CAP_STREAMING | V4L2_CAP_READWRITE; 1057 if (dev->has_audio_outputs) 1058 dev->vid_out_caps |= V4L2_CAP_AUDIO; 1059 } 1060 if (dev->has_vbi_cap) { 1061 /* set up the capabilities of the vbi capture device */ 1062 dev->vbi_cap_caps = (dev->has_raw_vbi_cap ? V4L2_CAP_VBI_CAPTURE : 0) | 1063 (dev->has_sliced_vbi_cap ? V4L2_CAP_SLICED_VBI_CAPTURE : 0); 1064 dev->vbi_cap_caps |= V4L2_CAP_STREAMING | V4L2_CAP_READWRITE; 1065 if (dev->has_audio_inputs) 1066 dev->vbi_cap_caps |= V4L2_CAP_AUDIO; 1067 if (dev->has_tv_tuner) 1068 dev->vbi_cap_caps |= V4L2_CAP_TUNER; 1069 } 1070 if (dev->has_vbi_out) { 1071 /* set up the capabilities of the vbi output device */ 1072 dev->vbi_out_caps = (dev->has_raw_vbi_out ? V4L2_CAP_VBI_OUTPUT : 0) | 1073 (dev->has_sliced_vbi_out ? V4L2_CAP_SLICED_VBI_OUTPUT : 0); 1074 dev->vbi_out_caps |= V4L2_CAP_STREAMING | V4L2_CAP_READWRITE; 1075 if (dev->has_audio_outputs) 1076 dev->vbi_out_caps |= V4L2_CAP_AUDIO; 1077 } 1078 if (dev->has_sdr_cap) { 1079 /* set up the capabilities of the sdr capture device */ 1080 dev->sdr_cap_caps = V4L2_CAP_SDR_CAPTURE | V4L2_CAP_TUNER; 1081 dev->sdr_cap_caps |= V4L2_CAP_STREAMING | V4L2_CAP_READWRITE; 1082 } 1083 /* set up the capabilities of the radio receiver device */ 1084 if (dev->has_radio_rx) 1085 dev->radio_rx_caps = V4L2_CAP_RADIO | V4L2_CAP_RDS_CAPTURE | 1086 V4L2_CAP_HW_FREQ_SEEK | V4L2_CAP_TUNER | 1087 V4L2_CAP_READWRITE; 1088 /* set up the capabilities of the radio transmitter device */ 1089 if (dev->has_radio_tx) 1090 dev->radio_tx_caps = V4L2_CAP_RDS_OUTPUT | V4L2_CAP_MODULATOR | 1091 V4L2_CAP_READWRITE; 1092 1093 /* set up the capabilities of meta capture device */ 1094 if (dev->has_meta_cap) { 1095 dev->meta_cap_caps = V4L2_CAP_META_CAPTURE | 1096 V4L2_CAP_STREAMING | V4L2_CAP_READWRITE; 1097 if (dev->has_audio_inputs) 1098 dev->meta_cap_caps |= V4L2_CAP_AUDIO; 1099 if (dev->has_tv_tuner) 1100 dev->meta_cap_caps |= V4L2_CAP_TUNER; 1101 } 1102 /* set up the capabilities of meta output device */ 1103 if (dev->has_meta_out) { 1104 dev->meta_out_caps = V4L2_CAP_META_OUTPUT | 1105 V4L2_CAP_STREAMING | V4L2_CAP_READWRITE; 1106 if (dev->has_audio_outputs) 1107 dev->meta_out_caps |= V4L2_CAP_AUDIO; 1108 } 1109 /* set up the capabilities of the touch capture device */ 1110 if (dev->has_touch_cap) { 1111 dev->touch_cap_caps = V4L2_CAP_TOUCH | V4L2_CAP_STREAMING | 1112 V4L2_CAP_READWRITE; 1113 dev->touch_cap_caps |= dev->multiplanar ? 1114 V4L2_CAP_VIDEO_CAPTURE_MPLANE : V4L2_CAP_VIDEO_CAPTURE; 1115 } 1116 1117 ret = -ENOMEM; 1118 /* initialize the test pattern generator */ 1119 tpg_init(&dev->tpg, 640, 360); 1120 if (tpg_alloc(&dev->tpg, MAX_ZOOM * MAX_WIDTH)) 1121 goto free_dev; 1122 dev->scaled_line = vzalloc(array_size(MAX_WIDTH, MAX_ZOOM)); 1123 if (!dev->scaled_line) 1124 goto free_dev; 1125 dev->blended_line = vzalloc(array_size(MAX_WIDTH, MAX_ZOOM)); 1126 if (!dev->blended_line) 1127 goto free_dev; 1128 1129 /* load the edid */ 1130 dev->edid = vmalloc(256 * 128); 1131 if (!dev->edid) 1132 goto free_dev; 1133 1134 while (v4l2_dv_timings_presets[dev->query_dv_timings_size].bt.width) 1135 dev->query_dv_timings_size++; 1136 1137 /* 1138 * Create a char pointer array that points to the names of all the 1139 * preset timings 1140 */ 1141 dev->query_dv_timings_qmenu = kmalloc_array(dev->query_dv_timings_size, 1142 sizeof(char *), GFP_KERNEL); 1143 /* 1144 * Create a string array containing the names of all the preset 1145 * timings. Each name is max 31 chars long (+ terminating 0). 1146 */ 1147 dev->query_dv_timings_qmenu_strings = 1148 kmalloc_array(dev->query_dv_timings_size, 32, GFP_KERNEL); 1149 1150 if (!dev->query_dv_timings_qmenu || 1151 !dev->query_dv_timings_qmenu_strings) 1152 goto free_dev; 1153 1154 for (i = 0; i < dev->query_dv_timings_size; i++) { 1155 const struct v4l2_bt_timings *bt = &v4l2_dv_timings_presets[i].bt; 1156 char *p = dev->query_dv_timings_qmenu_strings + i * 32; 1157 u32 htot, vtot; 1158 1159 dev->query_dv_timings_qmenu[i] = p; 1160 1161 htot = V4L2_DV_BT_FRAME_WIDTH(bt); 1162 vtot = V4L2_DV_BT_FRAME_HEIGHT(bt); 1163 snprintf(p, 32, "%ux%u%s%u", 1164 bt->width, bt->height, bt->interlaced ? "i" : "p", 1165 (u32)bt->pixelclock / (htot * vtot)); 1166 } 1167 1168 /* disable invalid ioctls based on the feature set */ 1169 if (!dev->has_audio_inputs) { 1170 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_S_AUDIO); 1171 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_G_AUDIO); 1172 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_ENUMAUDIO); 1173 v4l2_disable_ioctl(&dev->vbi_cap_dev, VIDIOC_S_AUDIO); 1174 v4l2_disable_ioctl(&dev->vbi_cap_dev, VIDIOC_G_AUDIO); 1175 v4l2_disable_ioctl(&dev->vbi_cap_dev, VIDIOC_ENUMAUDIO); 1176 v4l2_disable_ioctl(&dev->meta_cap_dev, VIDIOC_S_AUDIO); 1177 v4l2_disable_ioctl(&dev->meta_cap_dev, VIDIOC_G_AUDIO); 1178 v4l2_disable_ioctl(&dev->meta_cap_dev, VIDIOC_ENUMAUDIO); 1179 } 1180 if (!dev->has_audio_outputs) { 1181 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_S_AUDOUT); 1182 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_G_AUDOUT); 1183 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_ENUMAUDOUT); 1184 v4l2_disable_ioctl(&dev->vbi_out_dev, VIDIOC_S_AUDOUT); 1185 v4l2_disable_ioctl(&dev->vbi_out_dev, VIDIOC_G_AUDOUT); 1186 v4l2_disable_ioctl(&dev->vbi_out_dev, VIDIOC_ENUMAUDOUT); 1187 v4l2_disable_ioctl(&dev->meta_out_dev, VIDIOC_S_AUDOUT); 1188 v4l2_disable_ioctl(&dev->meta_out_dev, VIDIOC_G_AUDOUT); 1189 v4l2_disable_ioctl(&dev->meta_out_dev, VIDIOC_ENUMAUDOUT); 1190 } 1191 if (!in_type_counter[TV] && !in_type_counter[SVID]) { 1192 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_S_STD); 1193 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_G_STD); 1194 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_ENUMSTD); 1195 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_QUERYSTD); 1196 } 1197 if (!out_type_counter[SVID]) { 1198 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_S_STD); 1199 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_G_STD); 1200 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_ENUMSTD); 1201 } 1202 if (!has_tuner && !has_modulator) { 1203 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_S_FREQUENCY); 1204 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_G_FREQUENCY); 1205 v4l2_disable_ioctl(&dev->vbi_cap_dev, VIDIOC_S_FREQUENCY); 1206 v4l2_disable_ioctl(&dev->vbi_cap_dev, VIDIOC_G_FREQUENCY); 1207 v4l2_disable_ioctl(&dev->meta_cap_dev, VIDIOC_S_FREQUENCY); 1208 v4l2_disable_ioctl(&dev->meta_cap_dev, VIDIOC_G_FREQUENCY); 1209 } 1210 if (!has_tuner) { 1211 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_S_TUNER); 1212 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_G_TUNER); 1213 v4l2_disable_ioctl(&dev->vbi_cap_dev, VIDIOC_S_TUNER); 1214 v4l2_disable_ioctl(&dev->vbi_cap_dev, VIDIOC_G_TUNER); 1215 v4l2_disable_ioctl(&dev->meta_cap_dev, VIDIOC_S_TUNER); 1216 v4l2_disable_ioctl(&dev->meta_cap_dev, VIDIOC_G_TUNER); 1217 } 1218 if (in_type_counter[HDMI] == 0) { 1219 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_S_EDID); 1220 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_G_EDID); 1221 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_DV_TIMINGS_CAP); 1222 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_G_DV_TIMINGS); 1223 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_S_DV_TIMINGS); 1224 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_ENUM_DV_TIMINGS); 1225 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_QUERY_DV_TIMINGS); 1226 } 1227 if (out_type_counter[HDMI] == 0) { 1228 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_G_EDID); 1229 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_DV_TIMINGS_CAP); 1230 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_G_DV_TIMINGS); 1231 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_S_DV_TIMINGS); 1232 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_ENUM_DV_TIMINGS); 1233 } 1234 if (!dev->has_fb) { 1235 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_G_FBUF); 1236 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_S_FBUF); 1237 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_OVERLAY); 1238 } 1239 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_S_HW_FREQ_SEEK); 1240 v4l2_disable_ioctl(&dev->vbi_cap_dev, VIDIOC_S_HW_FREQ_SEEK); 1241 v4l2_disable_ioctl(&dev->sdr_cap_dev, VIDIOC_S_HW_FREQ_SEEK); 1242 v4l2_disable_ioctl(&dev->meta_cap_dev, VIDIOC_S_HW_FREQ_SEEK); 1243 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_S_FREQUENCY); 1244 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_G_FREQUENCY); 1245 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_ENUM_FRAMESIZES); 1246 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_ENUM_FRAMEINTERVALS); 1247 v4l2_disable_ioctl(&dev->vbi_out_dev, VIDIOC_S_FREQUENCY); 1248 v4l2_disable_ioctl(&dev->vbi_out_dev, VIDIOC_G_FREQUENCY); 1249 v4l2_disable_ioctl(&dev->meta_out_dev, VIDIOC_S_FREQUENCY); 1250 v4l2_disable_ioctl(&dev->meta_out_dev, VIDIOC_G_FREQUENCY); 1251 v4l2_disable_ioctl(&dev->touch_cap_dev, VIDIOC_S_PARM); 1252 v4l2_disable_ioctl(&dev->touch_cap_dev, VIDIOC_ENUM_FRAMESIZES); 1253 v4l2_disable_ioctl(&dev->touch_cap_dev, VIDIOC_ENUM_FRAMEINTERVALS); 1254 1255 /* configure internal data */ 1256 dev->fmt_cap = &vivid_formats[0]; 1257 dev->fmt_out = &vivid_formats[0]; 1258 if (!dev->multiplanar) 1259 vivid_formats[0].data_offset[0] = 0; 1260 dev->webcam_size_idx = 1; 1261 dev->webcam_ival_idx = 3; 1262 tpg_s_fourcc(&dev->tpg, dev->fmt_cap->fourcc); 1263 dev->std_out = V4L2_STD_PAL; 1264 if (dev->input_type[0] == TV || dev->input_type[0] == SVID) 1265 tvnorms_cap = V4L2_STD_ALL; 1266 if (dev->output_type[0] == SVID) 1267 tvnorms_out = V4L2_STD_ALL; 1268 for (i = 0; i < MAX_INPUTS; i++) { 1269 dev->dv_timings_cap[i] = def_dv_timings; 1270 dev->std_cap[i] = V4L2_STD_PAL; 1271 } 1272 dev->dv_timings_out = def_dv_timings; 1273 dev->tv_freq = 2804 /* 175.25 * 16 */; 1274 dev->tv_audmode = V4L2_TUNER_MODE_STEREO; 1275 dev->tv_field_cap = V4L2_FIELD_INTERLACED; 1276 dev->tv_field_out = V4L2_FIELD_INTERLACED; 1277 dev->radio_rx_freq = 95000 * 16; 1278 dev->radio_rx_audmode = V4L2_TUNER_MODE_STEREO; 1279 if (dev->has_radio_tx) { 1280 dev->radio_tx_freq = 95500 * 16; 1281 dev->radio_rds_loop = false; 1282 } 1283 dev->radio_tx_subchans = V4L2_TUNER_SUB_STEREO | V4L2_TUNER_SUB_RDS; 1284 dev->sdr_adc_freq = 300000; 1285 dev->sdr_fm_freq = 50000000; 1286 dev->sdr_pixelformat = V4L2_SDR_FMT_CU8; 1287 dev->sdr_buffersize = SDR_CAP_SAMPLES_PER_BUF * 2; 1288 1289 dev->edid_max_blocks = dev->edid_blocks = 2; 1290 memcpy(dev->edid, vivid_hdmi_edid, sizeof(vivid_hdmi_edid)); 1291 dev->radio_rds_init_time = ktime_get(); 1292 1293 /* create all controls */ 1294 ret = vivid_create_controls(dev, ccs_cap == -1, ccs_out == -1, no_error_inj, 1295 in_type_counter[TV] || in_type_counter[SVID] || 1296 out_type_counter[SVID], 1297 in_type_counter[HDMI] || out_type_counter[HDMI]); 1298 if (ret) 1299 goto unreg_dev; 1300 1301 /* enable/disable interface specific controls */ 1302 if (dev->num_outputs && dev->output_type[0] != HDMI) 1303 v4l2_ctrl_activate(dev->ctrl_display_present, false); 1304 if (dev->num_inputs && dev->input_type[0] != HDMI) { 1305 v4l2_ctrl_activate(dev->ctrl_dv_timings_signal_mode, false); 1306 v4l2_ctrl_activate(dev->ctrl_dv_timings, false); 1307 } else if (dev->num_inputs && dev->input_type[0] == HDMI) { 1308 v4l2_ctrl_activate(dev->ctrl_std_signal_mode, false); 1309 v4l2_ctrl_activate(dev->ctrl_standard, false); 1310 } 1311 1312 /* 1313 * update the capture and output formats to do a proper initial 1314 * configuration. 1315 */ 1316 vivid_update_format_cap(dev, false); 1317 vivid_update_format_out(dev); 1318 1319 /* initialize overlay */ 1320 dev->fb_cap.fmt.width = dev->src_rect.width; 1321 dev->fb_cap.fmt.height = dev->src_rect.height; 1322 dev->fb_cap.fmt.pixelformat = dev->fmt_cap->fourcc; 1323 dev->fb_cap.fmt.bytesperline = dev->src_rect.width * tpg_g_twopixelsize(&dev->tpg, 0) / 2; 1324 dev->fb_cap.fmt.sizeimage = dev->src_rect.height * dev->fb_cap.fmt.bytesperline; 1325 1326 /* update touch configuration */ 1327 dev->timeperframe_tch_cap.numerator = 1; 1328 dev->timeperframe_tch_cap.denominator = 10; 1329 vivid_set_touch(dev, 0); 1330 1331 /* initialize locks */ 1332 spin_lock_init(&dev->slock); 1333 mutex_init(&dev->mutex); 1334 1335 /* init dma queues */ 1336 INIT_LIST_HEAD(&dev->vid_cap_active); 1337 INIT_LIST_HEAD(&dev->vid_out_active); 1338 INIT_LIST_HEAD(&dev->vbi_cap_active); 1339 INIT_LIST_HEAD(&dev->vbi_out_active); 1340 INIT_LIST_HEAD(&dev->sdr_cap_active); 1341 INIT_LIST_HEAD(&dev->meta_cap_active); 1342 INIT_LIST_HEAD(&dev->meta_out_active); 1343 INIT_LIST_HEAD(&dev->touch_cap_active); 1344 1345 INIT_LIST_HEAD(&dev->cec_work_list); 1346 spin_lock_init(&dev->cec_slock); 1347 /* 1348 * Same as create_singlethread_workqueue, but now I can use the 1349 * string formatting of alloc_ordered_workqueue. 1350 */ 1351 dev->cec_workqueue = 1352 alloc_ordered_workqueue("vivid-%03d-cec", WQ_MEM_RECLAIM, inst); 1353 if (!dev->cec_workqueue) { 1354 ret = -ENOMEM; 1355 goto unreg_dev; 1356 } 1357 1358 if (allocators[inst] == 1) 1359 dma_coerce_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32)); 1360 1361 /* start creating the vb2 queues */ 1362 if (dev->has_vid_cap) { 1363 /* initialize vid_cap queue */ 1364 ret = vivid_create_queue(dev, &dev->vb_vid_cap_q, 1365 V4L2_BUF_TYPE_VIDEO_CAPTURE, 2, 1366 &vivid_vid_cap_qops); 1367 if (ret) 1368 goto unreg_dev; 1369 } 1370 1371 if (dev->has_vid_out) { 1372 /* initialize vid_out queue */ 1373 ret = vivid_create_queue(dev, &dev->vb_vid_out_q, 1374 V4L2_BUF_TYPE_VIDEO_OUTPUT, 2, 1375 &vivid_vid_out_qops); 1376 if (ret) 1377 goto unreg_dev; 1378 } 1379 1380 if (dev->has_vbi_cap) { 1381 /* initialize vbi_cap queue */ 1382 ret = vivid_create_queue(dev, &dev->vb_vbi_cap_q, 1383 V4L2_BUF_TYPE_VBI_CAPTURE, 2, 1384 &vivid_vbi_cap_qops); 1385 if (ret) 1386 goto unreg_dev; 1387 } 1388 1389 if (dev->has_vbi_out) { 1390 /* initialize vbi_out queue */ 1391 ret = vivid_create_queue(dev, &dev->vb_vbi_out_q, 1392 V4L2_BUF_TYPE_VBI_OUTPUT, 2, 1393 &vivid_vbi_out_qops); 1394 if (ret) 1395 goto unreg_dev; 1396 } 1397 1398 if (dev->has_sdr_cap) { 1399 /* initialize sdr_cap queue */ 1400 ret = vivid_create_queue(dev, &dev->vb_sdr_cap_q, 1401 V4L2_BUF_TYPE_SDR_CAPTURE, 8, 1402 &vivid_sdr_cap_qops); 1403 if (ret) 1404 goto unreg_dev; 1405 } 1406 1407 if (dev->has_meta_cap) { 1408 /* initialize meta_cap queue */ 1409 ret = vivid_create_queue(dev, &dev->vb_meta_cap_q, 1410 V4L2_BUF_TYPE_META_CAPTURE, 2, 1411 &vivid_meta_cap_qops); 1412 if (ret) 1413 goto unreg_dev; 1414 } 1415 1416 if (dev->has_meta_out) { 1417 /* initialize meta_out queue */ 1418 ret = vivid_create_queue(dev, &dev->vb_meta_out_q, 1419 V4L2_BUF_TYPE_META_OUTPUT, 1, 1420 &vivid_meta_out_qops); 1421 if (ret) 1422 goto unreg_dev; 1423 } 1424 1425 if (dev->has_touch_cap) { 1426 /* initialize touch_cap queue */ 1427 ret = vivid_create_queue(dev, &dev->vb_touch_cap_q, 1428 V4L2_BUF_TYPE_VIDEO_CAPTURE, 1, 1429 &vivid_touch_cap_qops); 1430 if (ret) 1431 goto unreg_dev; 1432 } 1433 1434 if (dev->has_fb) { 1435 /* Create framebuffer for testing capture/output overlay */ 1436 ret = vivid_fb_init(dev); 1437 if (ret) 1438 goto unreg_dev; 1439 v4l2_info(&dev->v4l2_dev, "Framebuffer device registered as fb%d\n", 1440 dev->fb_info.node); 1441 } 1442 1443 #ifdef CONFIG_VIDEO_VIVID_CEC 1444 if (dev->has_vid_cap && in_type_counter[HDMI]) { 1445 struct cec_adapter *adap; 1446 1447 adap = vivid_cec_alloc_adap(dev, 0, false); 1448 ret = PTR_ERR_OR_ZERO(adap); 1449 if (ret < 0) 1450 goto unreg_dev; 1451 dev->cec_rx_adap = adap; 1452 } 1453 1454 if (dev->has_vid_out) { 1455 for (i = 0; i < dev->num_outputs; i++) { 1456 struct cec_adapter *adap; 1457 1458 if (dev->output_type[i] != HDMI) 1459 continue; 1460 1461 dev->cec_output2bus_map[i] = cec_tx_bus_cnt; 1462 adap = vivid_cec_alloc_adap(dev, cec_tx_bus_cnt, true); 1463 ret = PTR_ERR_OR_ZERO(adap); 1464 if (ret < 0) { 1465 for (i = 0; i < dev->num_outputs; i++) 1466 cec_delete_adapter(dev->cec_tx_adap[i]); 1467 goto unreg_dev; 1468 } 1469 1470 dev->cec_tx_adap[cec_tx_bus_cnt] = adap; 1471 cec_tx_bus_cnt++; 1472 } 1473 } 1474 #endif 1475 1476 v4l2_ctrl_handler_setup(&dev->ctrl_hdl_vid_cap); 1477 v4l2_ctrl_handler_setup(&dev->ctrl_hdl_vid_out); 1478 v4l2_ctrl_handler_setup(&dev->ctrl_hdl_vbi_cap); 1479 v4l2_ctrl_handler_setup(&dev->ctrl_hdl_vbi_out); 1480 v4l2_ctrl_handler_setup(&dev->ctrl_hdl_radio_rx); 1481 v4l2_ctrl_handler_setup(&dev->ctrl_hdl_radio_tx); 1482 v4l2_ctrl_handler_setup(&dev->ctrl_hdl_sdr_cap); 1483 v4l2_ctrl_handler_setup(&dev->ctrl_hdl_meta_cap); 1484 v4l2_ctrl_handler_setup(&dev->ctrl_hdl_meta_out); 1485 v4l2_ctrl_handler_setup(&dev->ctrl_hdl_touch_cap); 1486 1487 /* finally start creating the device nodes */ 1488 if (dev->has_vid_cap) { 1489 vfd = &dev->vid_cap_dev; 1490 snprintf(vfd->name, sizeof(vfd->name), 1491 "vivid-%03d-vid-cap", inst); 1492 vfd->fops = &vivid_fops; 1493 vfd->ioctl_ops = &vivid_ioctl_ops; 1494 vfd->device_caps = dev->vid_cap_caps; 1495 vfd->release = video_device_release_empty; 1496 vfd->v4l2_dev = &dev->v4l2_dev; 1497 vfd->queue = &dev->vb_vid_cap_q; 1498 vfd->tvnorms = tvnorms_cap; 1499 1500 /* 1501 * Provide a mutex to v4l2 core. It will be used to protect 1502 * all fops and v4l2 ioctls. 1503 */ 1504 vfd->lock = &dev->mutex; 1505 video_set_drvdata(vfd, dev); 1506 1507 #ifdef CONFIG_MEDIA_CONTROLLER 1508 dev->vid_cap_pad.flags = MEDIA_PAD_FL_SINK; 1509 ret = media_entity_pads_init(&vfd->entity, 1, &dev->vid_cap_pad); 1510 if (ret) 1511 goto unreg_dev; 1512 #endif 1513 1514 #ifdef CONFIG_VIDEO_VIVID_CEC 1515 if (in_type_counter[HDMI]) { 1516 ret = cec_register_adapter(dev->cec_rx_adap, &pdev->dev); 1517 if (ret < 0) { 1518 cec_delete_adapter(dev->cec_rx_adap); 1519 dev->cec_rx_adap = NULL; 1520 goto unreg_dev; 1521 } 1522 cec_s_phys_addr(dev->cec_rx_adap, 0, false); 1523 v4l2_info(&dev->v4l2_dev, "CEC adapter %s registered for HDMI input 0\n", 1524 dev_name(&dev->cec_rx_adap->devnode.dev)); 1525 } 1526 #endif 1527 1528 ret = video_register_device(vfd, VFL_TYPE_VIDEO, vid_cap_nr[inst]); 1529 if (ret < 0) 1530 goto unreg_dev; 1531 v4l2_info(&dev->v4l2_dev, "V4L2 capture device registered as %s\n", 1532 video_device_node_name(vfd)); 1533 } 1534 1535 if (dev->has_vid_out) { 1536 vfd = &dev->vid_out_dev; 1537 snprintf(vfd->name, sizeof(vfd->name), 1538 "vivid-%03d-vid-out", inst); 1539 vfd->vfl_dir = VFL_DIR_TX; 1540 vfd->fops = &vivid_fops; 1541 vfd->ioctl_ops = &vivid_ioctl_ops; 1542 vfd->device_caps = dev->vid_out_caps; 1543 vfd->release = video_device_release_empty; 1544 vfd->v4l2_dev = &dev->v4l2_dev; 1545 vfd->queue = &dev->vb_vid_out_q; 1546 vfd->tvnorms = tvnorms_out; 1547 1548 /* 1549 * Provide a mutex to v4l2 core. It will be used to protect 1550 * all fops and v4l2 ioctls. 1551 */ 1552 vfd->lock = &dev->mutex; 1553 video_set_drvdata(vfd, dev); 1554 1555 #ifdef CONFIG_MEDIA_CONTROLLER 1556 dev->vid_out_pad.flags = MEDIA_PAD_FL_SOURCE; 1557 ret = media_entity_pads_init(&vfd->entity, 1, &dev->vid_out_pad); 1558 if (ret) 1559 goto unreg_dev; 1560 #endif 1561 1562 #ifdef CONFIG_VIDEO_VIVID_CEC 1563 for (i = 0; i < cec_tx_bus_cnt; i++) { 1564 ret = cec_register_adapter(dev->cec_tx_adap[i], &pdev->dev); 1565 if (ret < 0) { 1566 for (; i < cec_tx_bus_cnt; i++) { 1567 cec_delete_adapter(dev->cec_tx_adap[i]); 1568 dev->cec_tx_adap[i] = NULL; 1569 } 1570 goto unreg_dev; 1571 } 1572 v4l2_info(&dev->v4l2_dev, "CEC adapter %s registered for HDMI output %d\n", 1573 dev_name(&dev->cec_tx_adap[i]->devnode.dev), i); 1574 if (i < out_type_counter[HDMI]) 1575 cec_s_phys_addr(dev->cec_tx_adap[i], (i + 1) << 12, false); 1576 else 1577 cec_s_phys_addr(dev->cec_tx_adap[i], 0x1000, false); 1578 } 1579 #endif 1580 1581 ret = video_register_device(vfd, VFL_TYPE_VIDEO, vid_out_nr[inst]); 1582 if (ret < 0) 1583 goto unreg_dev; 1584 v4l2_info(&dev->v4l2_dev, "V4L2 output device registered as %s\n", 1585 video_device_node_name(vfd)); 1586 } 1587 1588 if (dev->has_vbi_cap) { 1589 vfd = &dev->vbi_cap_dev; 1590 snprintf(vfd->name, sizeof(vfd->name), 1591 "vivid-%03d-vbi-cap", inst); 1592 vfd->fops = &vivid_fops; 1593 vfd->ioctl_ops = &vivid_ioctl_ops; 1594 vfd->device_caps = dev->vbi_cap_caps; 1595 vfd->release = video_device_release_empty; 1596 vfd->v4l2_dev = &dev->v4l2_dev; 1597 vfd->queue = &dev->vb_vbi_cap_q; 1598 vfd->lock = &dev->mutex; 1599 vfd->tvnorms = tvnorms_cap; 1600 video_set_drvdata(vfd, dev); 1601 1602 #ifdef CONFIG_MEDIA_CONTROLLER 1603 dev->vbi_cap_pad.flags = MEDIA_PAD_FL_SINK; 1604 ret = media_entity_pads_init(&vfd->entity, 1, &dev->vbi_cap_pad); 1605 if (ret) 1606 goto unreg_dev; 1607 #endif 1608 1609 ret = video_register_device(vfd, VFL_TYPE_VBI, vbi_cap_nr[inst]); 1610 if (ret < 0) 1611 goto unreg_dev; 1612 v4l2_info(&dev->v4l2_dev, "V4L2 capture device registered as %s, supports %s VBI\n", 1613 video_device_node_name(vfd), 1614 (dev->has_raw_vbi_cap && dev->has_sliced_vbi_cap) ? 1615 "raw and sliced" : 1616 (dev->has_raw_vbi_cap ? "raw" : "sliced")); 1617 } 1618 1619 if (dev->has_vbi_out) { 1620 vfd = &dev->vbi_out_dev; 1621 snprintf(vfd->name, sizeof(vfd->name), 1622 "vivid-%03d-vbi-out", inst); 1623 vfd->vfl_dir = VFL_DIR_TX; 1624 vfd->fops = &vivid_fops; 1625 vfd->ioctl_ops = &vivid_ioctl_ops; 1626 vfd->device_caps = dev->vbi_out_caps; 1627 vfd->release = video_device_release_empty; 1628 vfd->v4l2_dev = &dev->v4l2_dev; 1629 vfd->queue = &dev->vb_vbi_out_q; 1630 vfd->lock = &dev->mutex; 1631 vfd->tvnorms = tvnorms_out; 1632 video_set_drvdata(vfd, dev); 1633 1634 #ifdef CONFIG_MEDIA_CONTROLLER 1635 dev->vbi_out_pad.flags = MEDIA_PAD_FL_SOURCE; 1636 ret = media_entity_pads_init(&vfd->entity, 1, &dev->vbi_out_pad); 1637 if (ret) 1638 goto unreg_dev; 1639 #endif 1640 1641 ret = video_register_device(vfd, VFL_TYPE_VBI, vbi_out_nr[inst]); 1642 if (ret < 0) 1643 goto unreg_dev; 1644 v4l2_info(&dev->v4l2_dev, "V4L2 output device registered as %s, supports %s VBI\n", 1645 video_device_node_name(vfd), 1646 (dev->has_raw_vbi_out && dev->has_sliced_vbi_out) ? 1647 "raw and sliced" : 1648 (dev->has_raw_vbi_out ? "raw" : "sliced")); 1649 } 1650 1651 if (dev->has_sdr_cap) { 1652 vfd = &dev->sdr_cap_dev; 1653 snprintf(vfd->name, sizeof(vfd->name), 1654 "vivid-%03d-sdr-cap", inst); 1655 vfd->fops = &vivid_fops; 1656 vfd->ioctl_ops = &vivid_ioctl_ops; 1657 vfd->device_caps = dev->sdr_cap_caps; 1658 vfd->release = video_device_release_empty; 1659 vfd->v4l2_dev = &dev->v4l2_dev; 1660 vfd->queue = &dev->vb_sdr_cap_q; 1661 vfd->lock = &dev->mutex; 1662 video_set_drvdata(vfd, dev); 1663 1664 #ifdef CONFIG_MEDIA_CONTROLLER 1665 dev->sdr_cap_pad.flags = MEDIA_PAD_FL_SINK; 1666 ret = media_entity_pads_init(&vfd->entity, 1, &dev->sdr_cap_pad); 1667 if (ret) 1668 goto unreg_dev; 1669 #endif 1670 1671 ret = video_register_device(vfd, VFL_TYPE_SDR, sdr_cap_nr[inst]); 1672 if (ret < 0) 1673 goto unreg_dev; 1674 v4l2_info(&dev->v4l2_dev, "V4L2 capture device registered as %s\n", 1675 video_device_node_name(vfd)); 1676 } 1677 1678 if (dev->has_radio_rx) { 1679 vfd = &dev->radio_rx_dev; 1680 snprintf(vfd->name, sizeof(vfd->name), 1681 "vivid-%03d-rad-rx", inst); 1682 vfd->fops = &vivid_radio_fops; 1683 vfd->ioctl_ops = &vivid_ioctl_ops; 1684 vfd->device_caps = dev->radio_rx_caps; 1685 vfd->release = video_device_release_empty; 1686 vfd->v4l2_dev = &dev->v4l2_dev; 1687 vfd->lock = &dev->mutex; 1688 video_set_drvdata(vfd, dev); 1689 1690 ret = video_register_device(vfd, VFL_TYPE_RADIO, radio_rx_nr[inst]); 1691 if (ret < 0) 1692 goto unreg_dev; 1693 v4l2_info(&dev->v4l2_dev, "V4L2 receiver device registered as %s\n", 1694 video_device_node_name(vfd)); 1695 } 1696 1697 if (dev->has_radio_tx) { 1698 vfd = &dev->radio_tx_dev; 1699 snprintf(vfd->name, sizeof(vfd->name), 1700 "vivid-%03d-rad-tx", inst); 1701 vfd->vfl_dir = VFL_DIR_TX; 1702 vfd->fops = &vivid_radio_fops; 1703 vfd->ioctl_ops = &vivid_ioctl_ops; 1704 vfd->device_caps = dev->radio_tx_caps; 1705 vfd->release = video_device_release_empty; 1706 vfd->v4l2_dev = &dev->v4l2_dev; 1707 vfd->lock = &dev->mutex; 1708 video_set_drvdata(vfd, dev); 1709 1710 ret = video_register_device(vfd, VFL_TYPE_RADIO, radio_tx_nr[inst]); 1711 if (ret < 0) 1712 goto unreg_dev; 1713 v4l2_info(&dev->v4l2_dev, "V4L2 transmitter device registered as %s\n", 1714 video_device_node_name(vfd)); 1715 } 1716 1717 if (dev->has_meta_cap) { 1718 vfd = &dev->meta_cap_dev; 1719 snprintf(vfd->name, sizeof(vfd->name), 1720 "vivid-%03d-meta-cap", inst); 1721 vfd->fops = &vivid_fops; 1722 vfd->ioctl_ops = &vivid_ioctl_ops; 1723 vfd->device_caps = dev->meta_cap_caps; 1724 vfd->release = video_device_release_empty; 1725 vfd->v4l2_dev = &dev->v4l2_dev; 1726 vfd->queue = &dev->vb_meta_cap_q; 1727 vfd->lock = &dev->mutex; 1728 vfd->tvnorms = tvnorms_cap; 1729 video_set_drvdata(vfd, dev); 1730 #ifdef CONFIG_MEDIA_CONTROLLER 1731 dev->meta_cap_pad.flags = MEDIA_PAD_FL_SINK; 1732 ret = media_entity_pads_init(&vfd->entity, 1, 1733 &dev->meta_cap_pad); 1734 if (ret) 1735 goto unreg_dev; 1736 #endif 1737 ret = video_register_device(vfd, VFL_TYPE_VIDEO, 1738 meta_cap_nr[inst]); 1739 if (ret < 0) 1740 goto unreg_dev; 1741 v4l2_info(&dev->v4l2_dev, 1742 "V4L2 metadata capture device registered as %s\n", 1743 video_device_node_name(vfd)); 1744 } 1745 1746 if (dev->has_meta_out) { 1747 vfd = &dev->meta_out_dev; 1748 snprintf(vfd->name, sizeof(vfd->name), 1749 "vivid-%03d-meta-out", inst); 1750 vfd->vfl_dir = VFL_DIR_TX; 1751 vfd->fops = &vivid_fops; 1752 vfd->ioctl_ops = &vivid_ioctl_ops; 1753 vfd->device_caps = dev->meta_out_caps; 1754 vfd->release = video_device_release_empty; 1755 vfd->v4l2_dev = &dev->v4l2_dev; 1756 vfd->queue = &dev->vb_meta_out_q; 1757 vfd->lock = &dev->mutex; 1758 vfd->tvnorms = tvnorms_out; 1759 video_set_drvdata(vfd, dev); 1760 #ifdef CONFIG_MEDIA_CONTROLLER 1761 dev->meta_out_pad.flags = MEDIA_PAD_FL_SOURCE; 1762 ret = media_entity_pads_init(&vfd->entity, 1, 1763 &dev->meta_out_pad); 1764 if (ret) 1765 goto unreg_dev; 1766 #endif 1767 ret = video_register_device(vfd, VFL_TYPE_VIDEO, 1768 meta_out_nr[inst]); 1769 if (ret < 0) 1770 goto unreg_dev; 1771 v4l2_info(&dev->v4l2_dev, 1772 "V4L2 metadata output device registered as %s\n", 1773 video_device_node_name(vfd)); 1774 } 1775 1776 if (dev->has_touch_cap) { 1777 vfd = &dev->touch_cap_dev; 1778 snprintf(vfd->name, sizeof(vfd->name), 1779 "vivid-%03d-touch-cap", inst); 1780 vfd->fops = &vivid_fops; 1781 vfd->ioctl_ops = &vivid_ioctl_ops; 1782 vfd->device_caps = dev->touch_cap_caps; 1783 vfd->release = video_device_release_empty; 1784 vfd->v4l2_dev = &dev->v4l2_dev; 1785 vfd->queue = &dev->vb_touch_cap_q; 1786 vfd->tvnorms = tvnorms_cap; 1787 vfd->lock = &dev->mutex; 1788 video_set_drvdata(vfd, dev); 1789 #ifdef CONFIG_MEDIA_CONTROLLER 1790 dev->touch_cap_pad.flags = MEDIA_PAD_FL_SINK; 1791 ret = media_entity_pads_init(&vfd->entity, 1, 1792 &dev->touch_cap_pad); 1793 if (ret) 1794 goto unreg_dev; 1795 #endif 1796 ret = video_register_device(vfd, VFL_TYPE_TOUCH, 1797 touch_cap_nr[inst]); 1798 if (ret < 0) 1799 goto unreg_dev; 1800 v4l2_info(&dev->v4l2_dev, 1801 "V4L2 touch capture device registered as %s\n", 1802 video_device_node_name(vfd)); 1803 } 1804 1805 #ifdef CONFIG_MEDIA_CONTROLLER 1806 /* Register the media device */ 1807 ret = media_device_register(&dev->mdev); 1808 if (ret) { 1809 dev_err(dev->mdev.dev, 1810 "media device register failed (err=%d)\n", ret); 1811 goto unreg_dev; 1812 } 1813 #endif 1814 1815 /* Now that everything is fine, let's add it to device list */ 1816 vivid_devs[inst] = dev; 1817 1818 return 0; 1819 1820 unreg_dev: 1821 video_unregister_device(&dev->touch_cap_dev); 1822 video_unregister_device(&dev->meta_out_dev); 1823 video_unregister_device(&dev->meta_cap_dev); 1824 video_unregister_device(&dev->radio_tx_dev); 1825 video_unregister_device(&dev->radio_rx_dev); 1826 video_unregister_device(&dev->sdr_cap_dev); 1827 video_unregister_device(&dev->vbi_out_dev); 1828 video_unregister_device(&dev->vbi_cap_dev); 1829 video_unregister_device(&dev->vid_out_dev); 1830 video_unregister_device(&dev->vid_cap_dev); 1831 cec_unregister_adapter(dev->cec_rx_adap); 1832 for (i = 0; i < MAX_OUTPUTS; i++) 1833 cec_unregister_adapter(dev->cec_tx_adap[i]); 1834 if (dev->cec_workqueue) { 1835 vivid_cec_bus_free_work(dev); 1836 destroy_workqueue(dev->cec_workqueue); 1837 } 1838 free_dev: 1839 v4l2_device_put(&dev->v4l2_dev); 1840 return ret; 1841 } 1842 1843 /* This routine allocates from 1 to n_devs virtual drivers. 1844 1845 The real maximum number of virtual drivers will depend on how many drivers 1846 will succeed. This is limited to the maximum number of devices that 1847 videodev supports, which is equal to VIDEO_NUM_DEVICES. 1848 */ 1849 static int vivid_probe(struct platform_device *pdev) 1850 { 1851 const struct font_desc *font = find_font("VGA8x16"); 1852 int ret = 0, i; 1853 1854 if (font == NULL) { 1855 pr_err("vivid: could not find font\n"); 1856 return -ENODEV; 1857 } 1858 1859 tpg_set_font(font->data); 1860 1861 n_devs = clamp_t(unsigned, n_devs, 1, VIVID_MAX_DEVS); 1862 1863 for (i = 0; i < n_devs; i++) { 1864 ret = vivid_create_instance(pdev, i); 1865 if (ret) { 1866 /* If some instantiations succeeded, keep driver */ 1867 if (i) 1868 ret = 0; 1869 break; 1870 } 1871 } 1872 1873 if (ret < 0) { 1874 pr_err("vivid: error %d while loading driver\n", ret); 1875 return ret; 1876 } 1877 1878 /* n_devs will reflect the actual number of allocated devices */ 1879 n_devs = i; 1880 1881 return ret; 1882 } 1883 1884 static int vivid_remove(struct platform_device *pdev) 1885 { 1886 struct vivid_dev *dev; 1887 unsigned int i, j; 1888 1889 for (i = 0; i < n_devs; i++) { 1890 dev = vivid_devs[i]; 1891 if (!dev) 1892 continue; 1893 1894 #ifdef CONFIG_MEDIA_CONTROLLER 1895 media_device_unregister(&dev->mdev); 1896 #endif 1897 1898 if (dev->has_vid_cap) { 1899 v4l2_info(&dev->v4l2_dev, "unregistering %s\n", 1900 video_device_node_name(&dev->vid_cap_dev)); 1901 video_unregister_device(&dev->vid_cap_dev); 1902 } 1903 if (dev->has_vid_out) { 1904 v4l2_info(&dev->v4l2_dev, "unregistering %s\n", 1905 video_device_node_name(&dev->vid_out_dev)); 1906 video_unregister_device(&dev->vid_out_dev); 1907 } 1908 if (dev->has_vbi_cap) { 1909 v4l2_info(&dev->v4l2_dev, "unregistering %s\n", 1910 video_device_node_name(&dev->vbi_cap_dev)); 1911 video_unregister_device(&dev->vbi_cap_dev); 1912 } 1913 if (dev->has_vbi_out) { 1914 v4l2_info(&dev->v4l2_dev, "unregistering %s\n", 1915 video_device_node_name(&dev->vbi_out_dev)); 1916 video_unregister_device(&dev->vbi_out_dev); 1917 } 1918 if (dev->has_sdr_cap) { 1919 v4l2_info(&dev->v4l2_dev, "unregistering %s\n", 1920 video_device_node_name(&dev->sdr_cap_dev)); 1921 video_unregister_device(&dev->sdr_cap_dev); 1922 } 1923 if (dev->has_radio_rx) { 1924 v4l2_info(&dev->v4l2_dev, "unregistering %s\n", 1925 video_device_node_name(&dev->radio_rx_dev)); 1926 video_unregister_device(&dev->radio_rx_dev); 1927 } 1928 if (dev->has_radio_tx) { 1929 v4l2_info(&dev->v4l2_dev, "unregistering %s\n", 1930 video_device_node_name(&dev->radio_tx_dev)); 1931 video_unregister_device(&dev->radio_tx_dev); 1932 } 1933 if (dev->has_fb) { 1934 v4l2_info(&dev->v4l2_dev, "unregistering fb%d\n", 1935 dev->fb_info.node); 1936 unregister_framebuffer(&dev->fb_info); 1937 vivid_fb_release_buffers(dev); 1938 } 1939 if (dev->has_meta_cap) { 1940 v4l2_info(&dev->v4l2_dev, "unregistering %s\n", 1941 video_device_node_name(&dev->meta_cap_dev)); 1942 video_unregister_device(&dev->meta_cap_dev); 1943 } 1944 if (dev->has_meta_out) { 1945 v4l2_info(&dev->v4l2_dev, "unregistering %s\n", 1946 video_device_node_name(&dev->meta_out_dev)); 1947 video_unregister_device(&dev->meta_out_dev); 1948 } 1949 if (dev->has_touch_cap) { 1950 v4l2_info(&dev->v4l2_dev, "unregistering %s\n", 1951 video_device_node_name(&dev->touch_cap_dev)); 1952 video_unregister_device(&dev->touch_cap_dev); 1953 } 1954 cec_unregister_adapter(dev->cec_rx_adap); 1955 for (j = 0; j < MAX_OUTPUTS; j++) 1956 cec_unregister_adapter(dev->cec_tx_adap[j]); 1957 if (dev->cec_workqueue) { 1958 vivid_cec_bus_free_work(dev); 1959 destroy_workqueue(dev->cec_workqueue); 1960 } 1961 v4l2_device_put(&dev->v4l2_dev); 1962 vivid_devs[i] = NULL; 1963 } 1964 return 0; 1965 } 1966 1967 static void vivid_pdev_release(struct device *dev) 1968 { 1969 } 1970 1971 static struct platform_device vivid_pdev = { 1972 .name = "vivid", 1973 .dev.release = vivid_pdev_release, 1974 }; 1975 1976 static struct platform_driver vivid_pdrv = { 1977 .probe = vivid_probe, 1978 .remove = vivid_remove, 1979 .driver = { 1980 .name = "vivid", 1981 }, 1982 }; 1983 1984 static int __init vivid_init(void) 1985 { 1986 int ret; 1987 1988 ret = platform_device_register(&vivid_pdev); 1989 if (ret) 1990 return ret; 1991 1992 ret = platform_driver_register(&vivid_pdrv); 1993 if (ret) 1994 platform_device_unregister(&vivid_pdev); 1995 1996 return ret; 1997 } 1998 1999 static void __exit vivid_exit(void) 2000 { 2001 platform_driver_unregister(&vivid_pdrv); 2002 platform_device_unregister(&vivid_pdev); 2003 } 2004 2005 module_init(vivid_init); 2006 module_exit(vivid_exit); 2007