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