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