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

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