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