1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * cobalt V4L2 API 4 * 5 * Derived from ivtv-ioctl.c and cx18-fileops.c 6 * 7 * Copyright 2012-2015 Cisco Systems, Inc. and/or its affiliates. 8 * All rights reserved. 9 */ 10 11 #include <linux/dma-mapping.h> 12 #include <linux/delay.h> 13 #include <linux/math64.h> 14 #include <linux/pci.h> 15 #include <linux/v4l2-dv-timings.h> 16 17 #include <media/v4l2-ctrls.h> 18 #include <media/v4l2-event.h> 19 #include <media/v4l2-dv-timings.h> 20 #include <media/i2c/adv7604.h> 21 #include <media/i2c/adv7842.h> 22 23 #include "cobalt-alsa.h" 24 #include "cobalt-cpld.h" 25 #include "cobalt-driver.h" 26 #include "cobalt-v4l2.h" 27 #include "cobalt-irq.h" 28 #include "cobalt-omnitek.h" 29 30 static const struct v4l2_dv_timings cea1080p60 = V4L2_DV_BT_CEA_1920X1080P60; 31 32 /* vb2 DMA streaming ops */ 33 34 static int cobalt_queue_setup(struct vb2_queue *q, 35 unsigned int *num_buffers, unsigned int *num_planes, 36 unsigned int sizes[], struct device *alloc_devs[]) 37 { 38 struct cobalt_stream *s = q->drv_priv; 39 unsigned size = s->stride * s->height; 40 41 if (*num_buffers < 3) 42 *num_buffers = 3; 43 if (*num_buffers > NR_BUFS) 44 *num_buffers = NR_BUFS; 45 if (*num_planes) 46 return sizes[0] < size ? -EINVAL : 0; 47 *num_planes = 1; 48 sizes[0] = size; 49 return 0; 50 } 51 52 static int cobalt_buf_init(struct vb2_buffer *vb) 53 { 54 struct cobalt_stream *s = vb->vb2_queue->drv_priv; 55 struct cobalt *cobalt = s->cobalt; 56 const size_t max_pages_per_line = 57 (COBALT_MAX_WIDTH * COBALT_MAX_BPP) / PAGE_SIZE + 2; 58 const size_t bytes = 59 COBALT_MAX_HEIGHT * max_pages_per_line * 0x20; 60 const size_t audio_bytes = ((1920 * 4) / PAGE_SIZE + 1) * 0x20; 61 struct sg_dma_desc_info *desc = &s->dma_desc_info[vb->index]; 62 struct sg_table *sg_desc = vb2_dma_sg_plane_desc(vb, 0); 63 unsigned size; 64 int ret; 65 66 size = s->stride * s->height; 67 if (vb2_plane_size(vb, 0) < size) { 68 cobalt_info("data will not fit into plane (%lu < %u)\n", 69 vb2_plane_size(vb, 0), size); 70 return -EINVAL; 71 } 72 73 if (desc->virt == NULL) { 74 desc->dev = &cobalt->pci_dev->dev; 75 descriptor_list_allocate(desc, 76 s->is_audio ? audio_bytes : bytes); 77 if (desc->virt == NULL) 78 return -ENOMEM; 79 } 80 ret = descriptor_list_create(cobalt, sg_desc->sgl, 81 !s->is_output, sg_desc->nents, size, 82 s->width * s->bpp, s->stride, desc); 83 if (ret) 84 descriptor_list_free(desc); 85 return ret; 86 } 87 88 static void cobalt_buf_cleanup(struct vb2_buffer *vb) 89 { 90 struct cobalt_stream *s = vb->vb2_queue->drv_priv; 91 struct sg_dma_desc_info *desc = &s->dma_desc_info[vb->index]; 92 93 descriptor_list_free(desc); 94 } 95 96 static int cobalt_buf_prepare(struct vb2_buffer *vb) 97 { 98 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb); 99 struct cobalt_stream *s = vb->vb2_queue->drv_priv; 100 101 vb2_set_plane_payload(vb, 0, s->stride * s->height); 102 vbuf->field = V4L2_FIELD_NONE; 103 return 0; 104 } 105 106 static void chain_all_buffers(struct cobalt_stream *s) 107 { 108 struct sg_dma_desc_info *desc[NR_BUFS]; 109 struct cobalt_buffer *cb; 110 struct list_head *p; 111 int i = 0; 112 113 list_for_each(p, &s->bufs) { 114 cb = list_entry(p, struct cobalt_buffer, list); 115 desc[i] = &s->dma_desc_info[cb->vb.vb2_buf.index]; 116 if (i > 0) 117 descriptor_list_chain(desc[i-1], desc[i]); 118 i++; 119 } 120 } 121 122 static void cobalt_buf_queue(struct vb2_buffer *vb) 123 { 124 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb); 125 struct vb2_queue *q = vb->vb2_queue; 126 struct cobalt_stream *s = q->drv_priv; 127 struct cobalt_buffer *cb = to_cobalt_buffer(vbuf); 128 struct sg_dma_desc_info *desc = &s->dma_desc_info[vb->index]; 129 unsigned long flags; 130 131 /* Prepare new buffer */ 132 descriptor_list_loopback(desc); 133 descriptor_list_interrupt_disable(desc); 134 135 spin_lock_irqsave(&s->irqlock, flags); 136 list_add_tail(&cb->list, &s->bufs); 137 chain_all_buffers(s); 138 spin_unlock_irqrestore(&s->irqlock, flags); 139 } 140 141 static void cobalt_enable_output(struct cobalt_stream *s) 142 { 143 struct cobalt *cobalt = s->cobalt; 144 struct v4l2_bt_timings *bt = &s->timings.bt; 145 struct m00514_syncgen_flow_evcnt_regmap __iomem *vo = 146 COBALT_TX_BASE(cobalt); 147 unsigned fmt = s->pixfmt != V4L2_PIX_FMT_BGR32 ? 148 M00514_CONTROL_BITMAP_FORMAT_16_BPP_MSK : 0; 149 struct v4l2_subdev_format sd_fmt = { 150 .which = V4L2_SUBDEV_FORMAT_ACTIVE, 151 }; 152 u64 clk = bt->pixelclock; 153 154 if (bt->flags & V4L2_DV_FL_REDUCED_FPS) 155 clk = div_u64(clk * 1000ULL, 1001); 156 if (!cobalt_cpld_set_freq(cobalt, clk)) { 157 cobalt_err("pixelclock out of range\n"); 158 return; 159 } 160 161 sd_fmt.format.colorspace = s->colorspace; 162 sd_fmt.format.xfer_func = s->xfer_func; 163 sd_fmt.format.ycbcr_enc = s->ycbcr_enc; 164 sd_fmt.format.quantization = s->quantization; 165 sd_fmt.format.width = bt->width; 166 sd_fmt.format.height = bt->height; 167 168 /* Set up FDMA packer */ 169 switch (s->pixfmt) { 170 case V4L2_PIX_FMT_YUYV: 171 sd_fmt.format.code = MEDIA_BUS_FMT_UYVY8_1X16; 172 break; 173 case V4L2_PIX_FMT_BGR32: 174 sd_fmt.format.code = MEDIA_BUS_FMT_RGB888_1X24; 175 break; 176 } 177 v4l2_subdev_call(s->sd, pad, set_fmt, NULL, &sd_fmt); 178 179 iowrite32(0, &vo->control); 180 /* 1080p60 */ 181 iowrite32(bt->hsync, &vo->sync_generator_h_sync_length); 182 iowrite32(bt->hbackporch, &vo->sync_generator_h_backporch_length); 183 iowrite32(bt->width, &vo->sync_generator_h_active_length); 184 iowrite32(bt->hfrontporch, &vo->sync_generator_h_frontporch_length); 185 iowrite32(bt->vsync, &vo->sync_generator_v_sync_length); 186 iowrite32(bt->vbackporch, &vo->sync_generator_v_backporch_length); 187 iowrite32(bt->height, &vo->sync_generator_v_active_length); 188 iowrite32(bt->vfrontporch, &vo->sync_generator_v_frontporch_length); 189 iowrite32(0x9900c1, &vo->error_color); 190 191 iowrite32(M00514_CONTROL_BITMAP_SYNC_GENERATOR_LOAD_PARAM_MSK | fmt, 192 &vo->control); 193 iowrite32(M00514_CONTROL_BITMAP_EVCNT_CLEAR_MSK | fmt, &vo->control); 194 iowrite32(M00514_CONTROL_BITMAP_SYNC_GENERATOR_ENABLE_MSK | 195 M00514_CONTROL_BITMAP_FLOW_CTRL_OUTPUT_ENABLE_MSK | 196 fmt, &vo->control); 197 } 198 199 static void cobalt_enable_input(struct cobalt_stream *s) 200 { 201 struct cobalt *cobalt = s->cobalt; 202 int ch = (int)s->video_channel; 203 struct m00235_fdma_packer_regmap __iomem *packer; 204 struct v4l2_subdev_format sd_fmt_yuyv = { 205 .pad = s->pad_source, 206 .which = V4L2_SUBDEV_FORMAT_ACTIVE, 207 .format.code = MEDIA_BUS_FMT_YUYV8_1X16, 208 }; 209 struct v4l2_subdev_format sd_fmt_rgb = { 210 .pad = s->pad_source, 211 .which = V4L2_SUBDEV_FORMAT_ACTIVE, 212 .format.code = MEDIA_BUS_FMT_RGB888_1X24, 213 }; 214 215 cobalt_dbg(1, "video_channel %d (%s, %s)\n", 216 s->video_channel, 217 s->input == 0 ? "hdmi" : "generator", 218 "YUYV"); 219 220 packer = COBALT_CVI_PACKER(cobalt, ch); 221 222 /* Set up FDMA packer */ 223 switch (s->pixfmt) { 224 case V4L2_PIX_FMT_YUYV: 225 iowrite32(M00235_CONTROL_BITMAP_ENABLE_MSK | 226 (1 << M00235_CONTROL_BITMAP_PACK_FORMAT_OFST), 227 &packer->control); 228 v4l2_subdev_call(s->sd, pad, set_fmt, NULL, 229 &sd_fmt_yuyv); 230 break; 231 case V4L2_PIX_FMT_RGB24: 232 iowrite32(M00235_CONTROL_BITMAP_ENABLE_MSK | 233 (2 << M00235_CONTROL_BITMAP_PACK_FORMAT_OFST), 234 &packer->control); 235 v4l2_subdev_call(s->sd, pad, set_fmt, NULL, 236 &sd_fmt_rgb); 237 break; 238 case V4L2_PIX_FMT_BGR32: 239 iowrite32(M00235_CONTROL_BITMAP_ENABLE_MSK | 240 M00235_CONTROL_BITMAP_ENDIAN_FORMAT_MSK | 241 (3 << M00235_CONTROL_BITMAP_PACK_FORMAT_OFST), 242 &packer->control); 243 v4l2_subdev_call(s->sd, pad, set_fmt, NULL, 244 &sd_fmt_rgb); 245 break; 246 } 247 } 248 249 static void cobalt_dma_start_streaming(struct cobalt_stream *s) 250 { 251 struct cobalt *cobalt = s->cobalt; 252 int rx = s->video_channel; 253 struct m00460_evcnt_regmap __iomem *evcnt = 254 COBALT_CVI_EVCNT(cobalt, rx); 255 struct cobalt_buffer *cb; 256 unsigned long flags; 257 258 spin_lock_irqsave(&s->irqlock, flags); 259 if (!s->is_output) { 260 iowrite32(M00460_CONTROL_BITMAP_CLEAR_MSK, &evcnt->control); 261 iowrite32(M00460_CONTROL_BITMAP_ENABLE_MSK, &evcnt->control); 262 } else { 263 struct m00514_syncgen_flow_evcnt_regmap __iomem *vo = 264 COBALT_TX_BASE(cobalt); 265 u32 ctrl = ioread32(&vo->control); 266 267 ctrl &= ~(M00514_CONTROL_BITMAP_EVCNT_ENABLE_MSK | 268 M00514_CONTROL_BITMAP_EVCNT_CLEAR_MSK); 269 iowrite32(ctrl | M00514_CONTROL_BITMAP_EVCNT_CLEAR_MSK, 270 &vo->control); 271 iowrite32(ctrl | M00514_CONTROL_BITMAP_EVCNT_ENABLE_MSK, 272 &vo->control); 273 } 274 cb = list_first_entry(&s->bufs, struct cobalt_buffer, list); 275 omni_sg_dma_start(s, &s->dma_desc_info[cb->vb.vb2_buf.index]); 276 spin_unlock_irqrestore(&s->irqlock, flags); 277 } 278 279 static int cobalt_start_streaming(struct vb2_queue *q, unsigned int count) 280 { 281 struct cobalt_stream *s = q->drv_priv; 282 struct cobalt *cobalt = s->cobalt; 283 struct m00233_video_measure_regmap __iomem *vmr; 284 struct m00473_freewheel_regmap __iomem *fw; 285 struct m00479_clk_loss_detector_regmap __iomem *clkloss; 286 int rx = s->video_channel; 287 struct m00389_cvi_regmap __iomem *cvi = COBALT_CVI(cobalt, rx); 288 struct m00460_evcnt_regmap __iomem *evcnt = COBALT_CVI_EVCNT(cobalt, rx); 289 struct v4l2_bt_timings *bt = &s->timings.bt; 290 u64 tot_size; 291 u32 clk_freq; 292 293 if (s->is_audio) 294 goto done; 295 if (s->is_output) { 296 s->unstable_frame = false; 297 cobalt_enable_output(s); 298 goto done; 299 } 300 301 cobalt_enable_input(s); 302 303 fw = COBALT_CVI_FREEWHEEL(cobalt, rx); 304 vmr = COBALT_CVI_VMR(cobalt, rx); 305 clkloss = COBALT_CVI_CLK_LOSS(cobalt, rx); 306 307 iowrite32(M00460_CONTROL_BITMAP_CLEAR_MSK, &evcnt->control); 308 iowrite32(M00460_CONTROL_BITMAP_ENABLE_MSK, &evcnt->control); 309 iowrite32(bt->width, &cvi->frame_width); 310 iowrite32(bt->height, &cvi->frame_height); 311 tot_size = V4L2_DV_BT_FRAME_WIDTH(bt) * V4L2_DV_BT_FRAME_HEIGHT(bt); 312 iowrite32(div_u64((u64)V4L2_DV_BT_FRAME_WIDTH(bt) * COBALT_CLK * 4, 313 bt->pixelclock), &vmr->hsync_timeout_val); 314 iowrite32(M00233_CONTROL_BITMAP_ENABLE_MEASURE_MSK, &vmr->control); 315 clk_freq = ioread32(&fw->clk_freq); 316 iowrite32(clk_freq / 1000000, &clkloss->ref_clk_cnt_val); 317 /* The lower bound for the clock frequency is 0.5% lower as is 318 * allowed by the spec */ 319 iowrite32(div_u64(bt->pixelclock * 995, 1000000000), 320 &clkloss->test_clk_cnt_val); 321 /* will be enabled after the first frame has been received */ 322 iowrite32(bt->width * bt->height, &fw->active_length); 323 iowrite32(div_u64((u64)clk_freq * tot_size, bt->pixelclock), 324 &fw->total_length); 325 iowrite32(M00233_IRQ_TRIGGERS_BITMAP_VACTIVE_AREA_MSK | 326 M00233_IRQ_TRIGGERS_BITMAP_HACTIVE_AREA_MSK, 327 &vmr->irq_triggers); 328 iowrite32(0, &cvi->control); 329 iowrite32(M00233_CONTROL_BITMAP_ENABLE_MEASURE_MSK, &vmr->control); 330 331 iowrite32(0xff, &fw->output_color); 332 iowrite32(M00479_CTRL_BITMAP_ENABLE_MSK, &clkloss->ctrl); 333 iowrite32(M00473_CTRL_BITMAP_ENABLE_MSK | 334 M00473_CTRL_BITMAP_FORCE_FREEWHEEL_MODE_MSK, &fw->ctrl); 335 s->unstable_frame = true; 336 s->enable_freewheel = false; 337 s->enable_cvi = false; 338 s->skip_first_frames = 0; 339 340 done: 341 s->sequence = 0; 342 cobalt_dma_start_streaming(s); 343 return 0; 344 } 345 346 static void cobalt_dma_stop_streaming(struct cobalt_stream *s) 347 { 348 struct cobalt *cobalt = s->cobalt; 349 struct sg_dma_desc_info *desc; 350 struct cobalt_buffer *cb; 351 struct list_head *p; 352 unsigned long flags; 353 int timeout_msec = 100; 354 int rx = s->video_channel; 355 struct m00460_evcnt_regmap __iomem *evcnt = 356 COBALT_CVI_EVCNT(cobalt, rx); 357 358 if (!s->is_output) { 359 iowrite32(0, &evcnt->control); 360 } else if (!s->is_audio) { 361 struct m00514_syncgen_flow_evcnt_regmap __iomem *vo = 362 COBALT_TX_BASE(cobalt); 363 364 iowrite32(M00514_CONTROL_BITMAP_EVCNT_CLEAR_MSK, &vo->control); 365 iowrite32(0, &vo->control); 366 } 367 368 /* Try to stop the DMA engine gracefully */ 369 spin_lock_irqsave(&s->irqlock, flags); 370 list_for_each(p, &s->bufs) { 371 cb = list_entry(p, struct cobalt_buffer, list); 372 desc = &s->dma_desc_info[cb->vb.vb2_buf.index]; 373 /* Stop DMA after this descriptor chain */ 374 descriptor_list_end_of_chain(desc); 375 } 376 spin_unlock_irqrestore(&s->irqlock, flags); 377 378 /* Wait 100 millisecond for DMA to finish, abort on timeout. */ 379 if (!wait_event_timeout(s->q.done_wq, is_dma_done(s), 380 msecs_to_jiffies(timeout_msec))) { 381 omni_sg_dma_abort_channel(s); 382 pr_warn("aborted\n"); 383 } 384 cobalt_write_bar0(cobalt, DMA_INTERRUPT_STATUS_REG, 385 1 << s->dma_channel); 386 } 387 388 static void cobalt_stop_streaming(struct vb2_queue *q) 389 { 390 struct cobalt_stream *s = q->drv_priv; 391 struct cobalt *cobalt = s->cobalt; 392 int rx = s->video_channel; 393 struct m00233_video_measure_regmap __iomem *vmr; 394 struct m00473_freewheel_regmap __iomem *fw; 395 struct m00479_clk_loss_detector_regmap __iomem *clkloss; 396 struct cobalt_buffer *cb; 397 struct list_head *p, *safe; 398 unsigned long flags; 399 400 cobalt_dma_stop_streaming(s); 401 402 /* Return all buffers to user space */ 403 spin_lock_irqsave(&s->irqlock, flags); 404 list_for_each_safe(p, safe, &s->bufs) { 405 cb = list_entry(p, struct cobalt_buffer, list); 406 list_del(&cb->list); 407 vb2_buffer_done(&cb->vb.vb2_buf, VB2_BUF_STATE_ERROR); 408 } 409 spin_unlock_irqrestore(&s->irqlock, flags); 410 411 if (s->is_audio || s->is_output) 412 return; 413 414 fw = COBALT_CVI_FREEWHEEL(cobalt, rx); 415 vmr = COBALT_CVI_VMR(cobalt, rx); 416 clkloss = COBALT_CVI_CLK_LOSS(cobalt, rx); 417 iowrite32(0, &vmr->control); 418 iowrite32(M00233_CONTROL_BITMAP_ENABLE_MEASURE_MSK, &vmr->control); 419 iowrite32(0, &fw->ctrl); 420 iowrite32(0, &clkloss->ctrl); 421 } 422 423 static const struct vb2_ops cobalt_qops = { 424 .queue_setup = cobalt_queue_setup, 425 .buf_init = cobalt_buf_init, 426 .buf_cleanup = cobalt_buf_cleanup, 427 .buf_prepare = cobalt_buf_prepare, 428 .buf_queue = cobalt_buf_queue, 429 .start_streaming = cobalt_start_streaming, 430 .stop_streaming = cobalt_stop_streaming, 431 .wait_prepare = vb2_ops_wait_prepare, 432 .wait_finish = vb2_ops_wait_finish, 433 }; 434 435 /* V4L2 ioctls */ 436 437 #ifdef CONFIG_VIDEO_ADV_DEBUG 438 static int cobalt_cobaltc(struct cobalt *cobalt, unsigned int cmd, void *arg) 439 { 440 struct v4l2_dbg_register *regs = arg; 441 void __iomem *adrs = cobalt->bar1 + regs->reg; 442 443 cobalt_info("cobalt_cobaltc: adrs = %p\n", adrs); 444 445 if (!capable(CAP_SYS_ADMIN)) 446 return -EPERM; 447 448 regs->size = 4; 449 if (cmd == VIDIOC_DBG_S_REGISTER) 450 iowrite32(regs->val, adrs); 451 else 452 regs->val = ioread32(adrs); 453 return 0; 454 } 455 456 static int cobalt_g_register(struct file *file, void *priv_fh, 457 struct v4l2_dbg_register *reg) 458 { 459 struct cobalt_stream *s = video_drvdata(file); 460 struct cobalt *cobalt = s->cobalt; 461 462 return cobalt_cobaltc(cobalt, VIDIOC_DBG_G_REGISTER, reg); 463 } 464 465 static int cobalt_s_register(struct file *file, void *priv_fh, 466 const struct v4l2_dbg_register *reg) 467 { 468 struct cobalt_stream *s = video_drvdata(file); 469 struct cobalt *cobalt = s->cobalt; 470 471 return cobalt_cobaltc(cobalt, VIDIOC_DBG_S_REGISTER, 472 (struct v4l2_dbg_register *)reg); 473 } 474 #endif 475 476 static int cobalt_querycap(struct file *file, void *priv_fh, 477 struct v4l2_capability *vcap) 478 { 479 struct cobalt_stream *s = video_drvdata(file); 480 struct cobalt *cobalt = s->cobalt; 481 482 strscpy(vcap->driver, "cobalt", sizeof(vcap->driver)); 483 strscpy(vcap->card, "cobalt", sizeof(vcap->card)); 484 snprintf(vcap->bus_info, sizeof(vcap->bus_info), 485 "PCIe:%s", pci_name(cobalt->pci_dev)); 486 vcap->capabilities = V4L2_CAP_STREAMING | V4L2_CAP_READWRITE | 487 V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_DEVICE_CAPS; 488 if (cobalt->have_hsma_tx) 489 vcap->capabilities |= V4L2_CAP_VIDEO_OUTPUT; 490 return 0; 491 } 492 493 static void cobalt_video_input_status_show(struct cobalt_stream *s) 494 { 495 struct m00389_cvi_regmap __iomem *cvi; 496 struct m00233_video_measure_regmap __iomem *vmr; 497 struct m00473_freewheel_regmap __iomem *fw; 498 struct m00479_clk_loss_detector_regmap __iomem *clkloss; 499 struct m00235_fdma_packer_regmap __iomem *packer; 500 int rx = s->video_channel; 501 struct cobalt *cobalt = s->cobalt; 502 u32 cvi_ctrl, cvi_stat; 503 u32 vmr_ctrl, vmr_stat; 504 505 cvi = COBALT_CVI(cobalt, rx); 506 vmr = COBALT_CVI_VMR(cobalt, rx); 507 fw = COBALT_CVI_FREEWHEEL(cobalt, rx); 508 clkloss = COBALT_CVI_CLK_LOSS(cobalt, rx); 509 packer = COBALT_CVI_PACKER(cobalt, rx); 510 cvi_ctrl = ioread32(&cvi->control); 511 cvi_stat = ioread32(&cvi->status); 512 vmr_ctrl = ioread32(&vmr->control); 513 vmr_stat = ioread32(&vmr->status); 514 cobalt_info("rx%d: cvi resolution: %dx%d\n", rx, 515 ioread32(&cvi->frame_width), ioread32(&cvi->frame_height)); 516 cobalt_info("rx%d: cvi control: %s%s%s\n", rx, 517 (cvi_ctrl & M00389_CONTROL_BITMAP_ENABLE_MSK) ? 518 "enable " : "disable ", 519 (cvi_ctrl & M00389_CONTROL_BITMAP_HSYNC_POLARITY_LOW_MSK) ? 520 "HSync- " : "HSync+ ", 521 (cvi_ctrl & M00389_CONTROL_BITMAP_VSYNC_POLARITY_LOW_MSK) ? 522 "VSync- " : "VSync+ "); 523 cobalt_info("rx%d: cvi status: %s%s\n", rx, 524 (cvi_stat & M00389_STATUS_BITMAP_LOCK_MSK) ? 525 "lock " : "no-lock ", 526 (cvi_stat & M00389_STATUS_BITMAP_ERROR_MSK) ? 527 "error " : "no-error "); 528 529 cobalt_info("rx%d: Measurements: %s%s%s%s%s%s%s\n", rx, 530 (vmr_ctrl & M00233_CONTROL_BITMAP_HSYNC_POLARITY_LOW_MSK) ? 531 "HSync- " : "HSync+ ", 532 (vmr_ctrl & M00233_CONTROL_BITMAP_VSYNC_POLARITY_LOW_MSK) ? 533 "VSync- " : "VSync+ ", 534 (vmr_ctrl & M00233_CONTROL_BITMAP_ENABLE_MEASURE_MSK) ? 535 "enabled " : "disabled ", 536 (vmr_ctrl & M00233_CONTROL_BITMAP_ENABLE_INTERRUPT_MSK) ? 537 "irq-enabled " : "irq-disabled ", 538 (vmr_ctrl & M00233_CONTROL_BITMAP_UPDATE_ON_HSYNC_MSK) ? 539 "update-on-hsync " : "", 540 (vmr_stat & M00233_STATUS_BITMAP_HSYNC_TIMEOUT_MSK) ? 541 "hsync-timeout " : "", 542 (vmr_stat & M00233_STATUS_BITMAP_INIT_DONE_MSK) ? 543 "init-done" : ""); 544 cobalt_info("rx%d: irq_status: 0x%02x irq_triggers: 0x%02x\n", rx, 545 ioread32(&vmr->irq_status) & 0xff, 546 ioread32(&vmr->irq_triggers) & 0xff); 547 cobalt_info("rx%d: vsync: %d\n", rx, ioread32(&vmr->vsync_time)); 548 cobalt_info("rx%d: vbp: %d\n", rx, ioread32(&vmr->vback_porch)); 549 cobalt_info("rx%d: vact: %d\n", rx, ioread32(&vmr->vactive_area)); 550 cobalt_info("rx%d: vfb: %d\n", rx, ioread32(&vmr->vfront_porch)); 551 cobalt_info("rx%d: hsync: %d\n", rx, ioread32(&vmr->hsync_time)); 552 cobalt_info("rx%d: hbp: %d\n", rx, ioread32(&vmr->hback_porch)); 553 cobalt_info("rx%d: hact: %d\n", rx, ioread32(&vmr->hactive_area)); 554 cobalt_info("rx%d: hfb: %d\n", rx, ioread32(&vmr->hfront_porch)); 555 cobalt_info("rx%d: Freewheeling: %s%s%s\n", rx, 556 (ioread32(&fw->ctrl) & M00473_CTRL_BITMAP_ENABLE_MSK) ? 557 "enabled " : "disabled ", 558 (ioread32(&fw->ctrl) & M00473_CTRL_BITMAP_FORCE_FREEWHEEL_MODE_MSK) ? 559 "forced " : "", 560 (ioread32(&fw->status) & M00473_STATUS_BITMAP_FREEWHEEL_MODE_MSK) ? 561 "freewheeling " : "video-passthrough "); 562 iowrite32(0xff, &vmr->irq_status); 563 cobalt_info("rx%d: Clock Loss Detection: %s%s\n", rx, 564 (ioread32(&clkloss->ctrl) & M00479_CTRL_BITMAP_ENABLE_MSK) ? 565 "enabled " : "disabled ", 566 (ioread32(&clkloss->status) & M00479_STATUS_BITMAP_CLOCK_MISSING_MSK) ? 567 "clock-missing " : "found-clock "); 568 cobalt_info("rx%d: Packer: %x\n", rx, ioread32(&packer->control)); 569 } 570 571 static int cobalt_log_status(struct file *file, void *priv_fh) 572 { 573 struct cobalt_stream *s = video_drvdata(file); 574 struct cobalt *cobalt = s->cobalt; 575 struct m00514_syncgen_flow_evcnt_regmap __iomem *vo = 576 COBALT_TX_BASE(cobalt); 577 u8 stat; 578 579 cobalt_info("%s", cobalt->hdl_info); 580 cobalt_info("sysctrl: %08x, sysstat: %08x\n", 581 cobalt_g_sysctrl(cobalt), 582 cobalt_g_sysstat(cobalt)); 583 cobalt_info("dma channel: %d, video channel: %d\n", 584 s->dma_channel, s->video_channel); 585 cobalt_pcie_status_show(cobalt); 586 cobalt_cpld_status(cobalt); 587 cobalt_irq_log_status(cobalt); 588 v4l2_subdev_call(s->sd, core, log_status); 589 if (!s->is_output) { 590 cobalt_video_input_status_show(s); 591 return 0; 592 } 593 594 stat = ioread32(&vo->rd_status); 595 596 cobalt_info("tx: status: %s%s\n", 597 (stat & M00514_RD_STATUS_BITMAP_FLOW_CTRL_NO_DATA_ERROR_MSK) ? 598 "no_data " : "", 599 (stat & M00514_RD_STATUS_BITMAP_READY_BUFFER_FULL_MSK) ? 600 "ready_buffer_full " : ""); 601 cobalt_info("tx: evcnt: %d\n", ioread32(&vo->rd_evcnt_count)); 602 return 0; 603 } 604 605 static int cobalt_enum_dv_timings(struct file *file, void *priv_fh, 606 struct v4l2_enum_dv_timings *timings) 607 { 608 struct cobalt_stream *s = video_drvdata(file); 609 610 if (s->input == 1) { 611 if (timings->index) 612 return -EINVAL; 613 memset(timings->reserved, 0, sizeof(timings->reserved)); 614 timings->timings = cea1080p60; 615 return 0; 616 } 617 timings->pad = 0; 618 return v4l2_subdev_call(s->sd, 619 pad, enum_dv_timings, timings); 620 } 621 622 static int cobalt_s_dv_timings(struct file *file, void *priv_fh, 623 struct v4l2_dv_timings *timings) 624 { 625 struct cobalt_stream *s = video_drvdata(file); 626 int err; 627 628 if (s->input == 1) { 629 *timings = cea1080p60; 630 return 0; 631 } 632 633 if (v4l2_match_dv_timings(timings, &s->timings, 0, true)) 634 return 0; 635 636 if (vb2_is_busy(&s->q)) 637 return -EBUSY; 638 639 err = v4l2_subdev_call(s->sd, 640 video, s_dv_timings, timings); 641 if (!err) { 642 s->timings = *timings; 643 s->width = timings->bt.width; 644 s->height = timings->bt.height; 645 s->stride = timings->bt.width * s->bpp; 646 } 647 return err; 648 } 649 650 static int cobalt_g_dv_timings(struct file *file, void *priv_fh, 651 struct v4l2_dv_timings *timings) 652 { 653 struct cobalt_stream *s = video_drvdata(file); 654 655 if (s->input == 1) { 656 *timings = cea1080p60; 657 return 0; 658 } 659 return v4l2_subdev_call(s->sd, 660 video, g_dv_timings, timings); 661 } 662 663 static int cobalt_query_dv_timings(struct file *file, void *priv_fh, 664 struct v4l2_dv_timings *timings) 665 { 666 struct cobalt_stream *s = video_drvdata(file); 667 668 if (s->input == 1) { 669 *timings = cea1080p60; 670 return 0; 671 } 672 return v4l2_subdev_call(s->sd, 673 video, query_dv_timings, timings); 674 } 675 676 static int cobalt_dv_timings_cap(struct file *file, void *priv_fh, 677 struct v4l2_dv_timings_cap *cap) 678 { 679 struct cobalt_stream *s = video_drvdata(file); 680 681 cap->pad = 0; 682 return v4l2_subdev_call(s->sd, 683 pad, dv_timings_cap, cap); 684 } 685 686 static int cobalt_enum_fmt_vid_cap(struct file *file, void *priv_fh, 687 struct v4l2_fmtdesc *f) 688 { 689 switch (f->index) { 690 case 0: 691 strscpy(f->description, "YUV 4:2:2", sizeof(f->description)); 692 f->pixelformat = V4L2_PIX_FMT_YUYV; 693 break; 694 case 1: 695 strscpy(f->description, "RGB24", sizeof(f->description)); 696 f->pixelformat = V4L2_PIX_FMT_RGB24; 697 break; 698 case 2: 699 strscpy(f->description, "RGB32", sizeof(f->description)); 700 f->pixelformat = V4L2_PIX_FMT_BGR32; 701 break; 702 default: 703 return -EINVAL; 704 } 705 706 return 0; 707 } 708 709 static int cobalt_g_fmt_vid_cap(struct file *file, void *priv_fh, 710 struct v4l2_format *f) 711 { 712 struct cobalt_stream *s = video_drvdata(file); 713 struct v4l2_pix_format *pix = &f->fmt.pix; 714 struct v4l2_subdev_format sd_fmt; 715 716 pix->width = s->width; 717 pix->height = s->height; 718 pix->bytesperline = s->stride; 719 pix->field = V4L2_FIELD_NONE; 720 721 if (s->input == 1) { 722 pix->colorspace = V4L2_COLORSPACE_SRGB; 723 } else { 724 sd_fmt.pad = s->pad_source; 725 sd_fmt.which = V4L2_SUBDEV_FORMAT_ACTIVE; 726 v4l2_subdev_call(s->sd, pad, get_fmt, NULL, &sd_fmt); 727 v4l2_fill_pix_format(pix, &sd_fmt.format); 728 } 729 730 pix->pixelformat = s->pixfmt; 731 pix->sizeimage = pix->bytesperline * pix->height; 732 733 return 0; 734 } 735 736 static int cobalt_try_fmt_vid_cap(struct file *file, void *priv_fh, 737 struct v4l2_format *f) 738 { 739 struct cobalt_stream *s = video_drvdata(file); 740 struct v4l2_pix_format *pix = &f->fmt.pix; 741 struct v4l2_subdev_format sd_fmt; 742 743 /* Check for min (QCIF) and max (Full HD) size */ 744 if ((pix->width < 176) || (pix->height < 144)) { 745 pix->width = 176; 746 pix->height = 144; 747 } 748 749 if ((pix->width > 1920) || (pix->height > 1080)) { 750 pix->width = 1920; 751 pix->height = 1080; 752 } 753 754 /* Make width multiple of 4 */ 755 pix->width &= ~0x3; 756 757 /* Make height multiple of 2 */ 758 pix->height &= ~0x1; 759 760 if (s->input == 1) { 761 /* Generator => fixed format only */ 762 pix->width = 1920; 763 pix->height = 1080; 764 pix->colorspace = V4L2_COLORSPACE_SRGB; 765 } else { 766 sd_fmt.pad = s->pad_source; 767 sd_fmt.which = V4L2_SUBDEV_FORMAT_ACTIVE; 768 v4l2_subdev_call(s->sd, pad, get_fmt, NULL, &sd_fmt); 769 v4l2_fill_pix_format(pix, &sd_fmt.format); 770 } 771 772 switch (pix->pixelformat) { 773 case V4L2_PIX_FMT_YUYV: 774 default: 775 pix->bytesperline = max(pix->bytesperline & ~0x3, 776 pix->width * COBALT_BYTES_PER_PIXEL_YUYV); 777 pix->pixelformat = V4L2_PIX_FMT_YUYV; 778 break; 779 case V4L2_PIX_FMT_RGB24: 780 pix->bytesperline = max(pix->bytesperline & ~0x3, 781 pix->width * COBALT_BYTES_PER_PIXEL_RGB24); 782 break; 783 case V4L2_PIX_FMT_BGR32: 784 pix->bytesperline = max(pix->bytesperline & ~0x3, 785 pix->width * COBALT_BYTES_PER_PIXEL_RGB32); 786 break; 787 } 788 789 pix->sizeimage = pix->bytesperline * pix->height; 790 pix->field = V4L2_FIELD_NONE; 791 pix->priv = 0; 792 793 return 0; 794 } 795 796 static int cobalt_s_fmt_vid_cap(struct file *file, void *priv_fh, 797 struct v4l2_format *f) 798 { 799 struct cobalt_stream *s = video_drvdata(file); 800 struct v4l2_pix_format *pix = &f->fmt.pix; 801 802 if (vb2_is_busy(&s->q)) 803 return -EBUSY; 804 805 if (cobalt_try_fmt_vid_cap(file, priv_fh, f)) 806 return -EINVAL; 807 808 s->width = pix->width; 809 s->height = pix->height; 810 s->stride = pix->bytesperline; 811 switch (pix->pixelformat) { 812 case V4L2_PIX_FMT_YUYV: 813 s->bpp = COBALT_BYTES_PER_PIXEL_YUYV; 814 break; 815 case V4L2_PIX_FMT_RGB24: 816 s->bpp = COBALT_BYTES_PER_PIXEL_RGB24; 817 break; 818 case V4L2_PIX_FMT_BGR32: 819 s->bpp = COBALT_BYTES_PER_PIXEL_RGB32; 820 break; 821 default: 822 return -EINVAL; 823 } 824 s->pixfmt = pix->pixelformat; 825 cobalt_enable_input(s); 826 827 return 0; 828 } 829 830 static int cobalt_try_fmt_vid_out(struct file *file, void *priv_fh, 831 struct v4l2_format *f) 832 { 833 struct v4l2_pix_format *pix = &f->fmt.pix; 834 835 /* Check for min (QCIF) and max (Full HD) size */ 836 if ((pix->width < 176) || (pix->height < 144)) { 837 pix->width = 176; 838 pix->height = 144; 839 } 840 841 if ((pix->width > 1920) || (pix->height > 1080)) { 842 pix->width = 1920; 843 pix->height = 1080; 844 } 845 846 /* Make width multiple of 4 */ 847 pix->width &= ~0x3; 848 849 /* Make height multiple of 2 */ 850 pix->height &= ~0x1; 851 852 switch (pix->pixelformat) { 853 case V4L2_PIX_FMT_YUYV: 854 default: 855 pix->bytesperline = max(pix->bytesperline & ~0x3, 856 pix->width * COBALT_BYTES_PER_PIXEL_YUYV); 857 pix->pixelformat = V4L2_PIX_FMT_YUYV; 858 break; 859 case V4L2_PIX_FMT_BGR32: 860 pix->bytesperline = max(pix->bytesperline & ~0x3, 861 pix->width * COBALT_BYTES_PER_PIXEL_RGB32); 862 break; 863 } 864 865 pix->sizeimage = pix->bytesperline * pix->height; 866 pix->field = V4L2_FIELD_NONE; 867 868 return 0; 869 } 870 871 static int cobalt_g_fmt_vid_out(struct file *file, void *priv_fh, 872 struct v4l2_format *f) 873 { 874 struct cobalt_stream *s = video_drvdata(file); 875 struct v4l2_pix_format *pix = &f->fmt.pix; 876 877 pix->width = s->width; 878 pix->height = s->height; 879 pix->bytesperline = s->stride; 880 pix->field = V4L2_FIELD_NONE; 881 pix->pixelformat = s->pixfmt; 882 pix->colorspace = s->colorspace; 883 pix->xfer_func = s->xfer_func; 884 pix->ycbcr_enc = s->ycbcr_enc; 885 pix->quantization = s->quantization; 886 pix->sizeimage = pix->bytesperline * pix->height; 887 888 return 0; 889 } 890 891 static int cobalt_enum_fmt_vid_out(struct file *file, void *priv_fh, 892 struct v4l2_fmtdesc *f) 893 { 894 switch (f->index) { 895 case 0: 896 strscpy(f->description, "YUV 4:2:2", sizeof(f->description)); 897 f->pixelformat = V4L2_PIX_FMT_YUYV; 898 break; 899 case 1: 900 strscpy(f->description, "RGB32", sizeof(f->description)); 901 f->pixelformat = V4L2_PIX_FMT_BGR32; 902 break; 903 default: 904 return -EINVAL; 905 } 906 907 return 0; 908 } 909 910 static int cobalt_s_fmt_vid_out(struct file *file, void *priv_fh, 911 struct v4l2_format *f) 912 { 913 struct cobalt_stream *s = video_drvdata(file); 914 struct v4l2_pix_format *pix = &f->fmt.pix; 915 struct v4l2_subdev_format sd_fmt = { 0 }; 916 u32 code; 917 918 if (cobalt_try_fmt_vid_out(file, priv_fh, f)) 919 return -EINVAL; 920 921 if (vb2_is_busy(&s->q) && (pix->pixelformat != s->pixfmt || 922 pix->width != s->width || pix->height != s->height || 923 pix->bytesperline != s->stride)) 924 return -EBUSY; 925 926 switch (pix->pixelformat) { 927 case V4L2_PIX_FMT_YUYV: 928 s->bpp = COBALT_BYTES_PER_PIXEL_YUYV; 929 code = MEDIA_BUS_FMT_UYVY8_1X16; 930 break; 931 case V4L2_PIX_FMT_BGR32: 932 s->bpp = COBALT_BYTES_PER_PIXEL_RGB32; 933 code = MEDIA_BUS_FMT_RGB888_1X24; 934 break; 935 default: 936 return -EINVAL; 937 } 938 s->width = pix->width; 939 s->height = pix->height; 940 s->stride = pix->bytesperline; 941 s->pixfmt = pix->pixelformat; 942 s->colorspace = pix->colorspace; 943 s->xfer_func = pix->xfer_func; 944 s->ycbcr_enc = pix->ycbcr_enc; 945 s->quantization = pix->quantization; 946 sd_fmt.which = V4L2_SUBDEV_FORMAT_ACTIVE; 947 v4l2_fill_mbus_format(&sd_fmt.format, pix, code); 948 v4l2_subdev_call(s->sd, pad, set_fmt, NULL, &sd_fmt); 949 return 0; 950 } 951 952 static int cobalt_enum_input(struct file *file, void *priv_fh, 953 struct v4l2_input *inp) 954 { 955 struct cobalt_stream *s = video_drvdata(file); 956 957 if (inp->index > 1) 958 return -EINVAL; 959 if (inp->index == 0) 960 snprintf(inp->name, sizeof(inp->name), 961 "HDMI-%d", s->video_channel); 962 else 963 snprintf(inp->name, sizeof(inp->name), 964 "Generator-%d", s->video_channel); 965 inp->type = V4L2_INPUT_TYPE_CAMERA; 966 inp->capabilities = V4L2_IN_CAP_DV_TIMINGS; 967 if (inp->index == 1) 968 return 0; 969 return v4l2_subdev_call(s->sd, 970 video, g_input_status, &inp->status); 971 } 972 973 static int cobalt_g_input(struct file *file, void *priv_fh, unsigned int *i) 974 { 975 struct cobalt_stream *s = video_drvdata(file); 976 977 *i = s->input; 978 return 0; 979 } 980 981 static int cobalt_s_input(struct file *file, void *priv_fh, unsigned int i) 982 { 983 struct cobalt_stream *s = video_drvdata(file); 984 985 if (i >= 2) 986 return -EINVAL; 987 if (vb2_is_busy(&s->q)) 988 return -EBUSY; 989 s->input = i; 990 991 cobalt_enable_input(s); 992 993 if (s->input == 1) /* Test Pattern Generator */ 994 return 0; 995 996 return v4l2_subdev_call(s->sd, video, s_routing, 997 ADV76XX_PAD_HDMI_PORT_A, 0, 0); 998 } 999 1000 static int cobalt_enum_output(struct file *file, void *priv_fh, 1001 struct v4l2_output *out) 1002 { 1003 if (out->index) 1004 return -EINVAL; 1005 snprintf(out->name, sizeof(out->name), "HDMI-%d", out->index); 1006 out->type = V4L2_OUTPUT_TYPE_ANALOG; 1007 out->capabilities = V4L2_OUT_CAP_DV_TIMINGS; 1008 return 0; 1009 } 1010 1011 static int cobalt_g_output(struct file *file, void *priv_fh, unsigned int *i) 1012 { 1013 *i = 0; 1014 return 0; 1015 } 1016 1017 static int cobalt_s_output(struct file *file, void *priv_fh, unsigned int i) 1018 { 1019 return i ? -EINVAL : 0; 1020 } 1021 1022 static int cobalt_g_edid(struct file *file, void *fh, struct v4l2_edid *edid) 1023 { 1024 struct cobalt_stream *s = video_drvdata(file); 1025 u32 pad = edid->pad; 1026 int ret; 1027 1028 if (edid->pad >= (s->is_output ? 1 : 2)) 1029 return -EINVAL; 1030 edid->pad = 0; 1031 ret = v4l2_subdev_call(s->sd, pad, get_edid, edid); 1032 edid->pad = pad; 1033 return ret; 1034 } 1035 1036 static int cobalt_s_edid(struct file *file, void *fh, struct v4l2_edid *edid) 1037 { 1038 struct cobalt_stream *s = video_drvdata(file); 1039 u32 pad = edid->pad; 1040 int ret; 1041 1042 if (edid->pad >= 2) 1043 return -EINVAL; 1044 edid->pad = 0; 1045 ret = v4l2_subdev_call(s->sd, pad, set_edid, edid); 1046 edid->pad = pad; 1047 return ret; 1048 } 1049 1050 static int cobalt_subscribe_event(struct v4l2_fh *fh, 1051 const struct v4l2_event_subscription *sub) 1052 { 1053 switch (sub->type) { 1054 case V4L2_EVENT_SOURCE_CHANGE: 1055 return v4l2_event_subscribe(fh, sub, 4, NULL); 1056 } 1057 return v4l2_ctrl_subscribe_event(fh, sub); 1058 } 1059 1060 static int cobalt_g_parm(struct file *file, void *fh, struct v4l2_streamparm *a) 1061 { 1062 struct cobalt_stream *s = video_drvdata(file); 1063 struct v4l2_fract fps; 1064 1065 if (a->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) 1066 return -EINVAL; 1067 1068 fps = v4l2_calc_timeperframe(&s->timings); 1069 a->parm.capture.timeperframe.numerator = fps.numerator; 1070 a->parm.capture.timeperframe.denominator = fps.denominator; 1071 a->parm.capture.readbuffers = 3; 1072 return 0; 1073 } 1074 1075 static int cobalt_g_pixelaspect(struct file *file, void *fh, 1076 int type, struct v4l2_fract *f) 1077 { 1078 struct cobalt_stream *s = video_drvdata(file); 1079 struct v4l2_dv_timings timings; 1080 int err = 0; 1081 1082 if (type != V4L2_BUF_TYPE_VIDEO_CAPTURE) 1083 return -EINVAL; 1084 1085 if (s->input == 1) 1086 timings = cea1080p60; 1087 else 1088 err = v4l2_subdev_call(s->sd, video, g_dv_timings, &timings); 1089 if (!err) 1090 *f = v4l2_dv_timings_aspect_ratio(&timings); 1091 return err; 1092 } 1093 1094 static int cobalt_g_selection(struct file *file, void *fh, 1095 struct v4l2_selection *sel) 1096 { 1097 struct cobalt_stream *s = video_drvdata(file); 1098 struct v4l2_dv_timings timings; 1099 int err = 0; 1100 1101 if (sel->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) 1102 return -EINVAL; 1103 1104 if (s->input == 1) 1105 timings = cea1080p60; 1106 else 1107 err = v4l2_subdev_call(s->sd, video, g_dv_timings, &timings); 1108 1109 if (err) 1110 return err; 1111 1112 switch (sel->target) { 1113 case V4L2_SEL_TGT_CROP_BOUNDS: 1114 case V4L2_SEL_TGT_CROP_DEFAULT: 1115 sel->r.top = 0; 1116 sel->r.left = 0; 1117 sel->r.width = timings.bt.width; 1118 sel->r.height = timings.bt.height; 1119 break; 1120 default: 1121 return -EINVAL; 1122 } 1123 return 0; 1124 } 1125 1126 static const struct v4l2_ioctl_ops cobalt_ioctl_ops = { 1127 .vidioc_querycap = cobalt_querycap, 1128 .vidioc_g_parm = cobalt_g_parm, 1129 .vidioc_log_status = cobalt_log_status, 1130 .vidioc_streamon = vb2_ioctl_streamon, 1131 .vidioc_streamoff = vb2_ioctl_streamoff, 1132 .vidioc_g_pixelaspect = cobalt_g_pixelaspect, 1133 .vidioc_g_selection = cobalt_g_selection, 1134 .vidioc_enum_input = cobalt_enum_input, 1135 .vidioc_g_input = cobalt_g_input, 1136 .vidioc_s_input = cobalt_s_input, 1137 .vidioc_enum_fmt_vid_cap = cobalt_enum_fmt_vid_cap, 1138 .vidioc_g_fmt_vid_cap = cobalt_g_fmt_vid_cap, 1139 .vidioc_s_fmt_vid_cap = cobalt_s_fmt_vid_cap, 1140 .vidioc_try_fmt_vid_cap = cobalt_try_fmt_vid_cap, 1141 .vidioc_enum_output = cobalt_enum_output, 1142 .vidioc_g_output = cobalt_g_output, 1143 .vidioc_s_output = cobalt_s_output, 1144 .vidioc_enum_fmt_vid_out = cobalt_enum_fmt_vid_out, 1145 .vidioc_g_fmt_vid_out = cobalt_g_fmt_vid_out, 1146 .vidioc_s_fmt_vid_out = cobalt_s_fmt_vid_out, 1147 .vidioc_try_fmt_vid_out = cobalt_try_fmt_vid_out, 1148 .vidioc_s_dv_timings = cobalt_s_dv_timings, 1149 .vidioc_g_dv_timings = cobalt_g_dv_timings, 1150 .vidioc_query_dv_timings = cobalt_query_dv_timings, 1151 .vidioc_enum_dv_timings = cobalt_enum_dv_timings, 1152 .vidioc_dv_timings_cap = cobalt_dv_timings_cap, 1153 .vidioc_g_edid = cobalt_g_edid, 1154 .vidioc_s_edid = cobalt_s_edid, 1155 .vidioc_subscribe_event = cobalt_subscribe_event, 1156 .vidioc_unsubscribe_event = v4l2_event_unsubscribe, 1157 .vidioc_reqbufs = vb2_ioctl_reqbufs, 1158 .vidioc_create_bufs = vb2_ioctl_create_bufs, 1159 .vidioc_querybuf = vb2_ioctl_querybuf, 1160 .vidioc_qbuf = vb2_ioctl_qbuf, 1161 .vidioc_dqbuf = vb2_ioctl_dqbuf, 1162 .vidioc_expbuf = vb2_ioctl_expbuf, 1163 #ifdef CONFIG_VIDEO_ADV_DEBUG 1164 .vidioc_g_register = cobalt_g_register, 1165 .vidioc_s_register = cobalt_s_register, 1166 #endif 1167 }; 1168 1169 static const struct v4l2_ioctl_ops cobalt_ioctl_empty_ops = { 1170 #ifdef CONFIG_VIDEO_ADV_DEBUG 1171 .vidioc_g_register = cobalt_g_register, 1172 .vidioc_s_register = cobalt_s_register, 1173 #endif 1174 }; 1175 1176 /* Register device nodes */ 1177 1178 static const struct v4l2_file_operations cobalt_fops = { 1179 .owner = THIS_MODULE, 1180 .open = v4l2_fh_open, 1181 .unlocked_ioctl = video_ioctl2, 1182 .release = vb2_fop_release, 1183 .poll = vb2_fop_poll, 1184 .mmap = vb2_fop_mmap, 1185 .read = vb2_fop_read, 1186 }; 1187 1188 static const struct v4l2_file_operations cobalt_out_fops = { 1189 .owner = THIS_MODULE, 1190 .open = v4l2_fh_open, 1191 .unlocked_ioctl = video_ioctl2, 1192 .release = vb2_fop_release, 1193 .poll = vb2_fop_poll, 1194 .mmap = vb2_fop_mmap, 1195 .write = vb2_fop_write, 1196 }; 1197 1198 static const struct v4l2_file_operations cobalt_empty_fops = { 1199 .owner = THIS_MODULE, 1200 .open = v4l2_fh_open, 1201 .unlocked_ioctl = video_ioctl2, 1202 .release = v4l2_fh_release, 1203 }; 1204 1205 static int cobalt_node_register(struct cobalt *cobalt, int node) 1206 { 1207 static const struct v4l2_dv_timings dv1080p60 = 1208 V4L2_DV_BT_CEA_1920X1080P60; 1209 struct cobalt_stream *s = cobalt->streams + node; 1210 struct video_device *vdev = &s->vdev; 1211 struct vb2_queue *q = &s->q; 1212 int ret; 1213 1214 mutex_init(&s->lock); 1215 spin_lock_init(&s->irqlock); 1216 1217 snprintf(vdev->name, sizeof(vdev->name), 1218 "%s-%d", cobalt->v4l2_dev.name, node); 1219 s->width = 1920; 1220 /* Audio frames are just 4 lines of 1920 bytes */ 1221 s->height = s->is_audio ? 4 : 1080; 1222 1223 if (s->is_audio) { 1224 s->bpp = 1; 1225 s->pixfmt = V4L2_PIX_FMT_GREY; 1226 } else if (s->is_output) { 1227 s->bpp = COBALT_BYTES_PER_PIXEL_RGB32; 1228 s->pixfmt = V4L2_PIX_FMT_BGR32; 1229 } else { 1230 s->bpp = COBALT_BYTES_PER_PIXEL_YUYV; 1231 s->pixfmt = V4L2_PIX_FMT_YUYV; 1232 } 1233 s->colorspace = V4L2_COLORSPACE_SRGB; 1234 s->stride = s->width * s->bpp; 1235 1236 if (!s->is_audio) { 1237 if (s->is_dummy) 1238 cobalt_warn("Setting up dummy video node %d\n", node); 1239 vdev->v4l2_dev = &cobalt->v4l2_dev; 1240 if (s->is_dummy) 1241 vdev->fops = &cobalt_empty_fops; 1242 else 1243 vdev->fops = s->is_output ? &cobalt_out_fops : 1244 &cobalt_fops; 1245 vdev->release = video_device_release_empty; 1246 vdev->vfl_dir = s->is_output ? VFL_DIR_TX : VFL_DIR_RX; 1247 vdev->lock = &s->lock; 1248 if (s->sd) 1249 vdev->ctrl_handler = s->sd->ctrl_handler; 1250 s->timings = dv1080p60; 1251 v4l2_subdev_call(s->sd, video, s_dv_timings, &s->timings); 1252 if (!s->is_output && s->sd) 1253 cobalt_enable_input(s); 1254 vdev->ioctl_ops = s->is_dummy ? &cobalt_ioctl_empty_ops : 1255 &cobalt_ioctl_ops; 1256 } 1257 1258 INIT_LIST_HEAD(&s->bufs); 1259 q->type = s->is_output ? V4L2_BUF_TYPE_VIDEO_OUTPUT : 1260 V4L2_BUF_TYPE_VIDEO_CAPTURE; 1261 q->io_modes = VB2_MMAP | VB2_USERPTR | VB2_DMABUF; 1262 q->io_modes |= s->is_output ? VB2_WRITE : VB2_READ; 1263 q->drv_priv = s; 1264 q->buf_struct_size = sizeof(struct cobalt_buffer); 1265 q->ops = &cobalt_qops; 1266 q->mem_ops = &vb2_dma_sg_memops; 1267 q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC; 1268 q->min_buffers_needed = 2; 1269 q->lock = &s->lock; 1270 q->dev = &cobalt->pci_dev->dev; 1271 vdev->queue = q; 1272 vdev->device_caps = V4L2_CAP_STREAMING | V4L2_CAP_READWRITE; 1273 if (s->is_output) 1274 vdev->device_caps |= V4L2_CAP_VIDEO_OUTPUT; 1275 else 1276 vdev->device_caps |= V4L2_CAP_VIDEO_CAPTURE; 1277 1278 video_set_drvdata(vdev, s); 1279 ret = vb2_queue_init(q); 1280 if (!s->is_audio && ret == 0) 1281 ret = video_register_device(vdev, VFL_TYPE_GRABBER, -1); 1282 else if (!s->is_dummy) 1283 ret = cobalt_alsa_init(s); 1284 1285 if (ret < 0) { 1286 if (!s->is_audio) 1287 cobalt_err("couldn't register v4l2 device node %d\n", 1288 node); 1289 return ret; 1290 } 1291 cobalt_info("registered node %d\n", node); 1292 return 0; 1293 } 1294 1295 /* Initialize v4l2 variables and register v4l2 devices */ 1296 int cobalt_nodes_register(struct cobalt *cobalt) 1297 { 1298 int node, ret; 1299 1300 /* Setup V4L2 Devices */ 1301 for (node = 0; node < COBALT_NUM_STREAMS; node++) { 1302 ret = cobalt_node_register(cobalt, node); 1303 if (ret) 1304 return ret; 1305 } 1306 return 0; 1307 } 1308 1309 /* Unregister v4l2 devices */ 1310 void cobalt_nodes_unregister(struct cobalt *cobalt) 1311 { 1312 int node; 1313 1314 /* Teardown all streams */ 1315 for (node = 0; node < COBALT_NUM_STREAMS; node++) { 1316 struct cobalt_stream *s = cobalt->streams + node; 1317 struct video_device *vdev = &s->vdev; 1318 1319 if (!s->is_audio) 1320 video_unregister_device(vdev); 1321 else if (!s->is_dummy) 1322 cobalt_alsa_exit(s); 1323 } 1324 } 1325