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 millisecond for DMA to finish, abort on timeout. */
379 	if (!wait_event_timeout(s->q.done_wq, is_dma_done(s),
380 				msecs_to_jiffies(timeout_msec))) {
381 		omni_sg_dma_abort_channel(s);
382 		pr_warn("aborted\n");
383 	}
384 	cobalt_write_bar0(cobalt, DMA_INTERRUPT_STATUS_REG,
385 			1 << s->dma_channel);
386 }
387 
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_g_pixelaspect(struct file *file, void *fh,
1081 				int type, struct v4l2_fract *f)
1082 {
1083 	struct cobalt_stream *s = video_drvdata(file);
1084 	struct v4l2_dv_timings timings;
1085 	int err = 0;
1086 
1087 	if (type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1088 		return -EINVAL;
1089 
1090 	if (s->input == 1)
1091 		timings = cea1080p60;
1092 	else
1093 		err = v4l2_subdev_call(s->sd, video, g_dv_timings, &timings);
1094 	if (!err)
1095 		*f = v4l2_dv_timings_aspect_ratio(&timings);
1096 	return err;
1097 }
1098 
1099 static int cobalt_g_selection(struct file *file, void *fh,
1100 			      struct v4l2_selection *sel)
1101 {
1102 	struct cobalt_stream *s = video_drvdata(file);
1103 	struct v4l2_dv_timings timings;
1104 	int err = 0;
1105 
1106 	if (sel->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1107 		return -EINVAL;
1108 
1109 	if (s->input == 1)
1110 		timings = cea1080p60;
1111 	else
1112 		err = v4l2_subdev_call(s->sd, video, g_dv_timings, &timings);
1113 
1114 	if (err)
1115 		return err;
1116 
1117 	switch (sel->target) {
1118 	case V4L2_SEL_TGT_CROP_BOUNDS:
1119 	case V4L2_SEL_TGT_CROP_DEFAULT:
1120 		sel->r.top = 0;
1121 		sel->r.left = 0;
1122 		sel->r.width = timings.bt.width;
1123 		sel->r.height = timings.bt.height;
1124 		break;
1125 	default:
1126 		return -EINVAL;
1127 	}
1128 	return 0;
1129 }
1130 
1131 static const struct v4l2_ioctl_ops cobalt_ioctl_ops = {
1132 	.vidioc_querycap		= cobalt_querycap,
1133 	.vidioc_g_parm			= cobalt_g_parm,
1134 	.vidioc_log_status		= cobalt_log_status,
1135 	.vidioc_streamon		= vb2_ioctl_streamon,
1136 	.vidioc_streamoff		= vb2_ioctl_streamoff,
1137 	.vidioc_g_pixelaspect		= cobalt_g_pixelaspect,
1138 	.vidioc_g_selection		= cobalt_g_selection,
1139 	.vidioc_enum_input		= cobalt_enum_input,
1140 	.vidioc_g_input			= cobalt_g_input,
1141 	.vidioc_s_input			= cobalt_s_input,
1142 	.vidioc_enum_fmt_vid_cap	= cobalt_enum_fmt_vid_cap,
1143 	.vidioc_g_fmt_vid_cap		= cobalt_g_fmt_vid_cap,
1144 	.vidioc_s_fmt_vid_cap		= cobalt_s_fmt_vid_cap,
1145 	.vidioc_try_fmt_vid_cap		= cobalt_try_fmt_vid_cap,
1146 	.vidioc_enum_output		= cobalt_enum_output,
1147 	.vidioc_g_output		= cobalt_g_output,
1148 	.vidioc_s_output		= cobalt_s_output,
1149 	.vidioc_enum_fmt_vid_out	= cobalt_enum_fmt_vid_out,
1150 	.vidioc_g_fmt_vid_out		= cobalt_g_fmt_vid_out,
1151 	.vidioc_s_fmt_vid_out		= cobalt_s_fmt_vid_out,
1152 	.vidioc_try_fmt_vid_out		= cobalt_try_fmt_vid_out,
1153 	.vidioc_s_dv_timings		= cobalt_s_dv_timings,
1154 	.vidioc_g_dv_timings		= cobalt_g_dv_timings,
1155 	.vidioc_query_dv_timings	= cobalt_query_dv_timings,
1156 	.vidioc_enum_dv_timings		= cobalt_enum_dv_timings,
1157 	.vidioc_dv_timings_cap		= cobalt_dv_timings_cap,
1158 	.vidioc_g_edid			= cobalt_g_edid,
1159 	.vidioc_s_edid			= cobalt_s_edid,
1160 	.vidioc_subscribe_event		= cobalt_subscribe_event,
1161 	.vidioc_unsubscribe_event	= v4l2_event_unsubscribe,
1162 	.vidioc_reqbufs			= vb2_ioctl_reqbufs,
1163 	.vidioc_create_bufs		= vb2_ioctl_create_bufs,
1164 	.vidioc_querybuf		= vb2_ioctl_querybuf,
1165 	.vidioc_qbuf			= vb2_ioctl_qbuf,
1166 	.vidioc_dqbuf			= vb2_ioctl_dqbuf,
1167 	.vidioc_expbuf			= vb2_ioctl_expbuf,
1168 #ifdef CONFIG_VIDEO_ADV_DEBUG
1169 	.vidioc_g_register              = cobalt_g_register,
1170 	.vidioc_s_register              = cobalt_s_register,
1171 #endif
1172 };
1173 
1174 static const struct v4l2_ioctl_ops cobalt_ioctl_empty_ops = {
1175 #ifdef CONFIG_VIDEO_ADV_DEBUG
1176 	.vidioc_g_register              = cobalt_g_register,
1177 	.vidioc_s_register              = cobalt_s_register,
1178 #endif
1179 };
1180 
1181 /* Register device nodes */
1182 
1183 static const struct v4l2_file_operations cobalt_fops = {
1184 	.owner = THIS_MODULE,
1185 	.open = v4l2_fh_open,
1186 	.unlocked_ioctl = video_ioctl2,
1187 	.release = vb2_fop_release,
1188 	.poll = vb2_fop_poll,
1189 	.mmap = vb2_fop_mmap,
1190 	.read = vb2_fop_read,
1191 };
1192 
1193 static const struct v4l2_file_operations cobalt_out_fops = {
1194 	.owner = THIS_MODULE,
1195 	.open = v4l2_fh_open,
1196 	.unlocked_ioctl = video_ioctl2,
1197 	.release = vb2_fop_release,
1198 	.poll = vb2_fop_poll,
1199 	.mmap = vb2_fop_mmap,
1200 	.write = vb2_fop_write,
1201 };
1202 
1203 static const struct v4l2_file_operations cobalt_empty_fops = {
1204 	.owner = THIS_MODULE,
1205 	.open = v4l2_fh_open,
1206 	.unlocked_ioctl = video_ioctl2,
1207 	.release = v4l2_fh_release,
1208 };
1209 
1210 static int cobalt_node_register(struct cobalt *cobalt, int node)
1211 {
1212 	static const struct v4l2_dv_timings dv1080p60 =
1213 		V4L2_DV_BT_CEA_1920X1080P60;
1214 	struct cobalt_stream *s = cobalt->streams + node;
1215 	struct video_device *vdev = &s->vdev;
1216 	struct vb2_queue *q = &s->q;
1217 	int ret;
1218 
1219 	mutex_init(&s->lock);
1220 	spin_lock_init(&s->irqlock);
1221 
1222 	snprintf(vdev->name, sizeof(vdev->name),
1223 			"%s-%d", cobalt->v4l2_dev.name, node);
1224 	s->width = 1920;
1225 	/* Audio frames are just 4 lines of 1920 bytes */
1226 	s->height = s->is_audio ? 4 : 1080;
1227 
1228 	if (s->is_audio) {
1229 		s->bpp = 1;
1230 		s->pixfmt = V4L2_PIX_FMT_GREY;
1231 	} else if (s->is_output) {
1232 		s->bpp = COBALT_BYTES_PER_PIXEL_RGB32;
1233 		s->pixfmt = V4L2_PIX_FMT_BGR32;
1234 	} else {
1235 		s->bpp = COBALT_BYTES_PER_PIXEL_YUYV;
1236 		s->pixfmt = V4L2_PIX_FMT_YUYV;
1237 	}
1238 	s->colorspace = V4L2_COLORSPACE_SRGB;
1239 	s->stride = s->width * s->bpp;
1240 
1241 	if (!s->is_audio) {
1242 		if (s->is_dummy)
1243 			cobalt_warn("Setting up dummy video node %d\n", node);
1244 		vdev->v4l2_dev = &cobalt->v4l2_dev;
1245 		if (s->is_dummy)
1246 			vdev->fops = &cobalt_empty_fops;
1247 		else
1248 			vdev->fops = s->is_output ? &cobalt_out_fops :
1249 						    &cobalt_fops;
1250 		vdev->release = video_device_release_empty;
1251 		vdev->vfl_dir = s->is_output ? VFL_DIR_TX : VFL_DIR_RX;
1252 		vdev->lock = &s->lock;
1253 		if (s->sd)
1254 			vdev->ctrl_handler = s->sd->ctrl_handler;
1255 		s->timings = dv1080p60;
1256 		v4l2_subdev_call(s->sd, video, s_dv_timings, &s->timings);
1257 		if (!s->is_output && s->sd)
1258 			cobalt_enable_input(s);
1259 		vdev->ioctl_ops = s->is_dummy ? &cobalt_ioctl_empty_ops :
1260 				  &cobalt_ioctl_ops;
1261 	}
1262 
1263 	INIT_LIST_HEAD(&s->bufs);
1264 	q->type = s->is_output ? V4L2_BUF_TYPE_VIDEO_OUTPUT :
1265 				 V4L2_BUF_TYPE_VIDEO_CAPTURE;
1266 	q->io_modes = VB2_MMAP | VB2_USERPTR | VB2_DMABUF;
1267 	q->io_modes |= s->is_output ? VB2_WRITE : VB2_READ;
1268 	q->drv_priv = s;
1269 	q->buf_struct_size = sizeof(struct cobalt_buffer);
1270 	q->ops = &cobalt_qops;
1271 	q->mem_ops = &vb2_dma_sg_memops;
1272 	q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1273 	q->min_buffers_needed = 2;
1274 	q->lock = &s->lock;
1275 	q->dev = &cobalt->pci_dev->dev;
1276 	vdev->queue = q;
1277 
1278 	video_set_drvdata(vdev, s);
1279 	ret = vb2_queue_init(q);
1280 	if (!s->is_audio && ret == 0)
1281 		ret = video_register_device(vdev, VFL_TYPE_GRABBER, -1);
1282 	else if (!s->is_dummy)
1283 		ret = cobalt_alsa_init(s);
1284 
1285 	if (ret < 0) {
1286 		if (!s->is_audio)
1287 			cobalt_err("couldn't register v4l2 device node %d\n",
1288 					node);
1289 		return ret;
1290 	}
1291 	cobalt_info("registered node %d\n", node);
1292 	return 0;
1293 }
1294 
1295 /* Initialize v4l2 variables and register v4l2 devices */
1296 int cobalt_nodes_register(struct cobalt *cobalt)
1297 {
1298 	int node, ret;
1299 
1300 	/* Setup V4L2 Devices */
1301 	for (node = 0; node < COBALT_NUM_STREAMS; node++) {
1302 		ret = cobalt_node_register(cobalt, node);
1303 		if (ret)
1304 			return ret;
1305 	}
1306 	return 0;
1307 }
1308 
1309 /* Unregister v4l2 devices */
1310 void cobalt_nodes_unregister(struct cobalt *cobalt)
1311 {
1312 	int node;
1313 
1314 	/* Teardown all streams */
1315 	for (node = 0; node < COBALT_NUM_STREAMS; node++) {
1316 		struct cobalt_stream *s = cobalt->streams + node;
1317 		struct video_device *vdev = &s->vdev;
1318 
1319 		if (!s->is_audio)
1320 			video_unregister_device(vdev);
1321 		else if (!s->is_dummy)
1322 			cobalt_alsa_exit(s);
1323 	}
1324 }
1325