drivers/media/pci/cobalt/cobalt-v4l2.c

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