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