1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  *  Driver for the Conexant CX23885 PCIe bridge
4  *
5  *  Copyright (c) 2007 Steven Toth <stoth@linuxtv.org>
6  */
7 
8 #include "cx23885.h"
9 #include "cx23885-video.h"
10 
11 #include <linux/init.h>
12 #include <linux/list.h>
13 #include <linux/module.h>
14 #include <linux/moduleparam.h>
15 #include <linux/kmod.h>
16 #include <linux/kernel.h>
17 #include <linux/slab.h>
18 #include <linux/interrupt.h>
19 #include <linux/delay.h>
20 #include <linux/kthread.h>
21 #include <asm/div64.h>
22 
23 #include <media/v4l2-common.h>
24 #include <media/v4l2-ioctl.h>
25 #include <media/v4l2-event.h>
26 #include "cx23885-ioctl.h"
27 #include "xc2028.h"
28 
29 #include <media/drv-intf/cx25840.h>
30 
31 MODULE_DESCRIPTION("v4l2 driver module for cx23885 based TV cards");
32 MODULE_AUTHOR("Steven Toth <stoth@linuxtv.org>");
33 MODULE_LICENSE("GPL");
34 
35 /* ------------------------------------------------------------------ */
36 
37 static unsigned int video_nr[] = {[0 ... (CX23885_MAXBOARDS - 1)] = UNSET };
38 static unsigned int vbi_nr[]   = {[0 ... (CX23885_MAXBOARDS - 1)] = UNSET };
39 
40 module_param_array(video_nr, int, NULL, 0444);
41 module_param_array(vbi_nr,   int, NULL, 0444);
42 
43 MODULE_PARM_DESC(video_nr, "video device numbers");
44 MODULE_PARM_DESC(vbi_nr, "vbi device numbers");
45 
46 static unsigned int video_debug;
47 module_param(video_debug, int, 0644);
48 MODULE_PARM_DESC(video_debug, "enable debug messages [video]");
49 
50 static unsigned int irq_debug;
51 module_param(irq_debug, int, 0644);
52 MODULE_PARM_DESC(irq_debug, "enable debug messages [IRQ handler]");
53 
54 static unsigned int vid_limit = 16;
55 module_param(vid_limit, int, 0644);
56 MODULE_PARM_DESC(vid_limit, "capture memory limit in megabytes");
57 
58 #define dprintk(level, fmt, arg...)\
59 	do { if (video_debug >= level)\
60 		printk(KERN_DEBUG pr_fmt("%s: video:" fmt), \
61 			__func__, ##arg); \
62 	} while (0)
63 
64 /* ------------------------------------------------------------------- */
65 /* static data                                                         */
66 
67 #define FORMAT_FLAGS_PACKED       0x01
68 static struct cx23885_fmt formats[] = {
69 	{
70 		.fourcc   = V4L2_PIX_FMT_YUYV,
71 		.depth    = 16,
72 		.flags    = FORMAT_FLAGS_PACKED,
73 	}
74 };
75 
76 static struct cx23885_fmt *format_by_fourcc(unsigned int fourcc)
77 {
78 	unsigned int i;
79 
80 	for (i = 0; i < ARRAY_SIZE(formats); i++)
81 		if (formats[i].fourcc == fourcc)
82 			return formats+i;
83 	return NULL;
84 }
85 
86 /* ------------------------------------------------------------------- */
87 
88 void cx23885_video_wakeup(struct cx23885_dev *dev,
89 	struct cx23885_dmaqueue *q, u32 count)
90 {
91 	struct cx23885_buffer *buf;
92 
93 	if (list_empty(&q->active))
94 		return;
95 	buf = list_entry(q->active.next,
96 			struct cx23885_buffer, queue);
97 
98 	buf->vb.sequence = q->count++;
99 	buf->vb.vb2_buf.timestamp = ktime_get_ns();
100 	dprintk(2, "[%p/%d] wakeup reg=%d buf=%d\n", buf,
101 			buf->vb.vb2_buf.index, count, q->count);
102 	list_del(&buf->queue);
103 	vb2_buffer_done(&buf->vb.vb2_buf, VB2_BUF_STATE_DONE);
104 }
105 
106 int cx23885_set_tvnorm(struct cx23885_dev *dev, v4l2_std_id norm)
107 {
108 	struct v4l2_subdev_format format = {
109 		.which = V4L2_SUBDEV_FORMAT_ACTIVE,
110 		.format.code = MEDIA_BUS_FMT_FIXED,
111 	};
112 
113 	dprintk(1, "%s(norm = 0x%08x) name: [%s]\n",
114 		__func__,
115 		(unsigned int)norm,
116 		v4l2_norm_to_name(norm));
117 
118 	if (dev->tvnorm == norm)
119 		return 0;
120 
121 	if (dev->tvnorm != norm) {
122 		if (vb2_is_busy(&dev->vb2_vidq) || vb2_is_busy(&dev->vb2_vbiq) ||
123 		    vb2_is_busy(&dev->vb2_mpegq))
124 			return -EBUSY;
125 	}
126 
127 	dev->tvnorm = norm;
128 	dev->width = 720;
129 	dev->height = norm_maxh(norm);
130 	dev->field = V4L2_FIELD_INTERLACED;
131 
132 	call_all(dev, video, s_std, norm);
133 
134 	format.format.width = dev->width;
135 	format.format.height = dev->height;
136 	format.format.field = dev->field;
137 	call_all(dev, pad, set_fmt, NULL, &format);
138 
139 	return 0;
140 }
141 
142 static struct video_device *cx23885_vdev_init(struct cx23885_dev *dev,
143 				    struct pci_dev *pci,
144 				    struct video_device *template,
145 				    char *type)
146 {
147 	struct video_device *vfd;
148 	dprintk(1, "%s()\n", __func__);
149 
150 	vfd = video_device_alloc();
151 	if (NULL == vfd)
152 		return NULL;
153 	*vfd = *template;
154 	vfd->v4l2_dev = &dev->v4l2_dev;
155 	vfd->release = video_device_release;
156 	vfd->lock = &dev->lock;
157 	snprintf(vfd->name, sizeof(vfd->name), "%s (%s)",
158 		 cx23885_boards[dev->board].name, type);
159 	video_set_drvdata(vfd, dev);
160 	return vfd;
161 }
162 
163 int cx23885_flatiron_write(struct cx23885_dev *dev, u8 reg, u8 data)
164 {
165 	/* 8 bit registers, 8 bit values */
166 	u8 buf[] = { reg, data };
167 
168 	struct i2c_msg msg = { .addr = 0x98 >> 1,
169 		.flags = 0, .buf = buf, .len = 2 };
170 
171 	return i2c_transfer(&dev->i2c_bus[2].i2c_adap, &msg, 1);
172 }
173 
174 u8 cx23885_flatiron_read(struct cx23885_dev *dev, u8 reg)
175 {
176 	/* 8 bit registers, 8 bit values */
177 	int ret;
178 	u8 b0[] = { reg };
179 	u8 b1[] = { 0 };
180 
181 	struct i2c_msg msg[] = {
182 		{ .addr = 0x98 >> 1, .flags = 0, .buf = b0, .len = 1 },
183 		{ .addr = 0x98 >> 1, .flags = I2C_M_RD, .buf = b1, .len = 1 }
184 	};
185 
186 	ret = i2c_transfer(&dev->i2c_bus[2].i2c_adap, &msg[0], 2);
187 	if (ret != 2)
188 		pr_err("%s() error\n", __func__);
189 
190 	return b1[0];
191 }
192 
193 static void cx23885_flatiron_dump(struct cx23885_dev *dev)
194 {
195 	int i;
196 	dprintk(1, "Flatiron dump\n");
197 	for (i = 0; i < 0x24; i++) {
198 		dprintk(1, "FI[%02x] = %02x\n", i,
199 			cx23885_flatiron_read(dev, i));
200 	}
201 }
202 
203 static int cx23885_flatiron_mux(struct cx23885_dev *dev, int input)
204 {
205 	u8 val;
206 	dprintk(1, "%s(input = %d)\n", __func__, input);
207 
208 	if (input == 1)
209 		val = cx23885_flatiron_read(dev, CH_PWR_CTRL1) & ~FLD_CH_SEL;
210 	else if (input == 2)
211 		val = cx23885_flatiron_read(dev, CH_PWR_CTRL1) | FLD_CH_SEL;
212 	else
213 		return -EINVAL;
214 
215 	val |= 0x20; /* Enable clock to delta-sigma and dec filter */
216 
217 	cx23885_flatiron_write(dev, CH_PWR_CTRL1, val);
218 
219 	/* Wake up */
220 	cx23885_flatiron_write(dev, CH_PWR_CTRL2, 0);
221 
222 	if (video_debug)
223 		cx23885_flatiron_dump(dev);
224 
225 	return 0;
226 }
227 
228 static int cx23885_video_mux(struct cx23885_dev *dev, unsigned int input)
229 {
230 	dprintk(1, "%s() video_mux: %d [vmux=%d, gpio=0x%x,0x%x,0x%x,0x%x]\n",
231 		__func__,
232 		input, INPUT(input)->vmux,
233 		INPUT(input)->gpio0, INPUT(input)->gpio1,
234 		INPUT(input)->gpio2, INPUT(input)->gpio3);
235 	dev->input = input;
236 
237 	if (dev->board == CX23885_BOARD_MYGICA_X8506 ||
238 		dev->board == CX23885_BOARD_MAGICPRO_PROHDTVE2 ||
239 		dev->board == CX23885_BOARD_MYGICA_X8507) {
240 		/* Select Analog TV */
241 		if (INPUT(input)->type == CX23885_VMUX_TELEVISION)
242 			cx23885_gpio_clear(dev, GPIO_0);
243 	}
244 
245 	/* Tell the internal A/V decoder */
246 	v4l2_subdev_call(dev->sd_cx25840, video, s_routing,
247 			INPUT(input)->vmux, 0, 0);
248 
249 	if ((dev->board == CX23885_BOARD_HAUPPAUGE_HVR1800) ||
250 		(dev->board == CX23885_BOARD_MPX885) ||
251 		(dev->board == CX23885_BOARD_HAUPPAUGE_HVR1250) ||
252 		(dev->board == CX23885_BOARD_HAUPPAUGE_IMPACTVCBE) ||
253 		(dev->board == CX23885_BOARD_HAUPPAUGE_HVR1255) ||
254 		(dev->board == CX23885_BOARD_HAUPPAUGE_HVR1255_22111) ||
255 		(dev->board == CX23885_BOARD_HAUPPAUGE_HVR1265_K4) ||
256 		(dev->board == CX23885_BOARD_HAUPPAUGE_QUADHD_ATSC) ||
257 		(dev->board == CX23885_BOARD_HAUPPAUGE_QUADHD_DVB) ||
258 		(dev->board == CX23885_BOARD_HAUPPAUGE_HVR1850) ||
259 		(dev->board == CX23885_BOARD_HAUPPAUGE_HVR5525) ||
260 		(dev->board == CX23885_BOARD_MYGICA_X8507) ||
261 		(dev->board == CX23885_BOARD_AVERMEDIA_HC81R) ||
262 		(dev->board == CX23885_BOARD_VIEWCAST_260E) ||
263 		(dev->board == CX23885_BOARD_VIEWCAST_460E) ||
264 		(dev->board == CX23885_BOARD_AVERMEDIA_CE310B)) {
265 		/* Configure audio routing */
266 		v4l2_subdev_call(dev->sd_cx25840, audio, s_routing,
267 			INPUT(input)->amux, 0, 0);
268 
269 		if (INPUT(input)->amux == CX25840_AUDIO7)
270 			cx23885_flatiron_mux(dev, 1);
271 		else if (INPUT(input)->amux == CX25840_AUDIO6)
272 			cx23885_flatiron_mux(dev, 2);
273 	}
274 
275 	return 0;
276 }
277 
278 static int cx23885_audio_mux(struct cx23885_dev *dev, unsigned int input)
279 {
280 	dprintk(1, "%s(input=%d)\n", __func__, input);
281 
282 	/* The baseband video core of the cx23885 has two audio inputs.
283 	 * LR1 and LR2. In almost every single case so far only HVR1xxx
284 	 * cards we've only ever supported LR1. Time to support LR2,
285 	 * which is available via the optional white breakout header on
286 	 * the board.
287 	 * We'll use a could of existing enums in the card struct to allow
288 	 * devs to specify which baseband input they need, or just default
289 	 * to what we've always used.
290 	 */
291 	if (INPUT(input)->amux == CX25840_AUDIO7)
292 		cx23885_flatiron_mux(dev, 1);
293 	else if (INPUT(input)->amux == CX25840_AUDIO6)
294 		cx23885_flatiron_mux(dev, 2);
295 	else {
296 		/* Not specifically defined, assume the default. */
297 		cx23885_flatiron_mux(dev, 1);
298 	}
299 
300 	return 0;
301 }
302 
303 /* ------------------------------------------------------------------ */
304 static int cx23885_start_video_dma(struct cx23885_dev *dev,
305 			   struct cx23885_dmaqueue *q,
306 			   struct cx23885_buffer *buf)
307 {
308 	dprintk(1, "%s()\n", __func__);
309 
310 	/* Stop the dma/fifo before we tamper with it's risc programs */
311 	cx_clear(VID_A_DMA_CTL, 0x11);
312 
313 	/* setup fifo + format */
314 	cx23885_sram_channel_setup(dev, &dev->sram_channels[SRAM_CH01],
315 				buf->bpl, buf->risc.dma);
316 
317 	/* reset counter */
318 	cx_write(VID_A_GPCNT_CTL, 3);
319 	q->count = 0;
320 
321 	/* enable irq */
322 	cx23885_irq_add_enable(dev, 0x01);
323 	cx_set(VID_A_INT_MSK, 0x000011);
324 
325 	/* start dma */
326 	cx_set(DEV_CNTRL2, (1<<5));
327 	cx_set(VID_A_DMA_CTL, 0x11); /* FIFO and RISC enable */
328 
329 	return 0;
330 }
331 
332 static int queue_setup(struct vb2_queue *q,
333 			   unsigned int *num_buffers, unsigned int *num_planes,
334 			   unsigned int sizes[], struct device *alloc_devs[])
335 {
336 	struct cx23885_dev *dev = q->drv_priv;
337 
338 	*num_planes = 1;
339 	sizes[0] = (dev->fmt->depth * dev->width * dev->height) >> 3;
340 	return 0;
341 }
342 
343 static int buffer_prepare(struct vb2_buffer *vb)
344 {
345 	int ret;
346 	struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
347 	struct cx23885_dev *dev = vb->vb2_queue->drv_priv;
348 	struct cx23885_buffer *buf =
349 		container_of(vbuf, struct cx23885_buffer, vb);
350 	u32 line0_offset, line1_offset;
351 	struct sg_table *sgt = vb2_dma_sg_plane_desc(vb, 0);
352 	int field_tff;
353 
354 	buf->bpl = (dev->width * dev->fmt->depth) >> 3;
355 
356 	if (vb2_plane_size(vb, 0) < dev->height * buf->bpl)
357 		return -EINVAL;
358 	vb2_set_plane_payload(vb, 0, dev->height * buf->bpl);
359 
360 	switch (dev->field) {
361 	case V4L2_FIELD_TOP:
362 		ret = cx23885_risc_buffer(dev->pci, &buf->risc,
363 				sgt->sgl, 0, UNSET,
364 				buf->bpl, 0, dev->height);
365 		break;
366 	case V4L2_FIELD_BOTTOM:
367 		ret = cx23885_risc_buffer(dev->pci, &buf->risc,
368 				sgt->sgl, UNSET, 0,
369 				buf->bpl, 0, dev->height);
370 		break;
371 	case V4L2_FIELD_INTERLACED:
372 		if (dev->tvnorm & V4L2_STD_525_60)
373 			/* NTSC or  */
374 			field_tff = 1;
375 		else
376 			field_tff = 0;
377 
378 		if (cx23885_boards[dev->board].force_bff)
379 			/* PAL / SECAM OR 888 in NTSC MODE */
380 			field_tff = 0;
381 
382 		if (field_tff) {
383 			/* cx25840 transmits NTSC bottom field first */
384 			dprintk(1, "%s() Creating TFF/NTSC risc\n",
385 					__func__);
386 			line0_offset = buf->bpl;
387 			line1_offset = 0;
388 		} else {
389 			/* All other formats are top field first */
390 			dprintk(1, "%s() Creating BFF/PAL/SECAM risc\n",
391 					__func__);
392 			line0_offset = 0;
393 			line1_offset = buf->bpl;
394 		}
395 		ret = cx23885_risc_buffer(dev->pci, &buf->risc,
396 				sgt->sgl, line0_offset,
397 				line1_offset,
398 				buf->bpl, buf->bpl,
399 				dev->height >> 1);
400 		break;
401 	case V4L2_FIELD_SEQ_TB:
402 		ret = cx23885_risc_buffer(dev->pci, &buf->risc,
403 				sgt->sgl,
404 				0, buf->bpl * (dev->height >> 1),
405 				buf->bpl, 0,
406 				dev->height >> 1);
407 		break;
408 	case V4L2_FIELD_SEQ_BT:
409 		ret = cx23885_risc_buffer(dev->pci, &buf->risc,
410 				sgt->sgl,
411 				buf->bpl * (dev->height >> 1), 0,
412 				buf->bpl, 0,
413 				dev->height >> 1);
414 		break;
415 	default:
416 		BUG();
417 	}
418 	dprintk(2, "[%p/%d] buffer_init - %dx%d %dbpp 0x%08x - dma=0x%08lx\n",
419 		buf, buf->vb.vb2_buf.index,
420 		dev->width, dev->height, dev->fmt->depth, dev->fmt->fourcc,
421 		(unsigned long)buf->risc.dma);
422 	return ret;
423 }
424 
425 static void buffer_finish(struct vb2_buffer *vb)
426 {
427 	struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
428 	struct cx23885_buffer *buf = container_of(vbuf,
429 		struct cx23885_buffer, vb);
430 
431 	cx23885_free_buffer(vb->vb2_queue->drv_priv, buf);
432 }
433 
434 /*
435  * The risc program for each buffer works as follows: it starts with a simple
436  * 'JUMP to addr + 12', which is effectively a NOP. Then the code to DMA the
437  * buffer follows and at the end we have a JUMP back to the start + 12 (skipping
438  * the initial JUMP).
439  *
440  * This is the risc program of the first buffer to be queued if the active list
441  * is empty and it just keeps DMAing this buffer without generating any
442  * interrupts.
443  *
444  * If a new buffer is added then the initial JUMP in the code for that buffer
445  * will generate an interrupt which signals that the previous buffer has been
446  * DMAed successfully and that it can be returned to userspace.
447  *
448  * It also sets the final jump of the previous buffer to the start of the new
449  * buffer, thus chaining the new buffer into the DMA chain. This is a single
450  * atomic u32 write, so there is no race condition.
451  *
452  * The end-result of all this that you only get an interrupt when a buffer
453  * is ready, so the control flow is very easy.
454  */
455 static void buffer_queue(struct vb2_buffer *vb)
456 {
457 	struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
458 	struct cx23885_dev *dev = vb->vb2_queue->drv_priv;
459 	struct cx23885_buffer   *buf = container_of(vbuf,
460 		struct cx23885_buffer, vb);
461 	struct cx23885_buffer   *prev;
462 	struct cx23885_dmaqueue *q    = &dev->vidq;
463 	unsigned long flags;
464 
465 	/* add jump to start */
466 	buf->risc.cpu[1] = cpu_to_le32(buf->risc.dma + 12);
467 	buf->risc.jmp[0] = cpu_to_le32(RISC_JUMP | RISC_CNT_INC);
468 	buf->risc.jmp[1] = cpu_to_le32(buf->risc.dma + 12);
469 	buf->risc.jmp[2] = cpu_to_le32(0); /* bits 63-32 */
470 
471 	spin_lock_irqsave(&dev->slock, flags);
472 	if (list_empty(&q->active)) {
473 		list_add_tail(&buf->queue, &q->active);
474 		dprintk(2, "[%p/%d] buffer_queue - first active\n",
475 			buf, buf->vb.vb2_buf.index);
476 	} else {
477 		buf->risc.cpu[0] |= cpu_to_le32(RISC_IRQ1);
478 		prev = list_entry(q->active.prev, struct cx23885_buffer,
479 			queue);
480 		list_add_tail(&buf->queue, &q->active);
481 		prev->risc.jmp[1] = cpu_to_le32(buf->risc.dma);
482 		dprintk(2, "[%p/%d] buffer_queue - append to active\n",
483 				buf, buf->vb.vb2_buf.index);
484 	}
485 	spin_unlock_irqrestore(&dev->slock, flags);
486 }
487 
488 static int cx23885_start_streaming(struct vb2_queue *q, unsigned int count)
489 {
490 	struct cx23885_dev *dev = q->drv_priv;
491 	struct cx23885_dmaqueue *dmaq = &dev->vidq;
492 	struct cx23885_buffer *buf = list_entry(dmaq->active.next,
493 			struct cx23885_buffer, queue);
494 
495 	cx23885_start_video_dma(dev, dmaq, buf);
496 	return 0;
497 }
498 
499 static void cx23885_stop_streaming(struct vb2_queue *q)
500 {
501 	struct cx23885_dev *dev = q->drv_priv;
502 	struct cx23885_dmaqueue *dmaq = &dev->vidq;
503 	unsigned long flags;
504 
505 	cx_clear(VID_A_DMA_CTL, 0x11);
506 	spin_lock_irqsave(&dev->slock, flags);
507 	while (!list_empty(&dmaq->active)) {
508 		struct cx23885_buffer *buf = list_entry(dmaq->active.next,
509 			struct cx23885_buffer, queue);
510 
511 		list_del(&buf->queue);
512 		vb2_buffer_done(&buf->vb.vb2_buf, VB2_BUF_STATE_ERROR);
513 	}
514 	spin_unlock_irqrestore(&dev->slock, flags);
515 }
516 
517 static const struct vb2_ops cx23885_video_qops = {
518 	.queue_setup    = queue_setup,
519 	.buf_prepare  = buffer_prepare,
520 	.buf_finish = buffer_finish,
521 	.buf_queue    = buffer_queue,
522 	.wait_prepare = vb2_ops_wait_prepare,
523 	.wait_finish = vb2_ops_wait_finish,
524 	.start_streaming = cx23885_start_streaming,
525 	.stop_streaming = cx23885_stop_streaming,
526 };
527 
528 /* ------------------------------------------------------------------ */
529 /* VIDEO IOCTLS                                                       */
530 
531 static int vidioc_g_fmt_vid_cap(struct file *file, void *priv,
532 	struct v4l2_format *f)
533 {
534 	struct cx23885_dev *dev = video_drvdata(file);
535 
536 	f->fmt.pix.width        = dev->width;
537 	f->fmt.pix.height       = dev->height;
538 	f->fmt.pix.field        = dev->field;
539 	f->fmt.pix.pixelformat  = dev->fmt->fourcc;
540 	f->fmt.pix.bytesperline =
541 		(f->fmt.pix.width * dev->fmt->depth) >> 3;
542 	f->fmt.pix.sizeimage =
543 		f->fmt.pix.height * f->fmt.pix.bytesperline;
544 	f->fmt.pix.colorspace   = V4L2_COLORSPACE_SMPTE170M;
545 
546 	return 0;
547 }
548 
549 static int vidioc_try_fmt_vid_cap(struct file *file, void *priv,
550 	struct v4l2_format *f)
551 {
552 	struct cx23885_dev *dev = video_drvdata(file);
553 	struct cx23885_fmt *fmt;
554 	enum v4l2_field   field;
555 	unsigned int      maxw, maxh;
556 
557 	fmt = format_by_fourcc(f->fmt.pix.pixelformat);
558 	if (NULL == fmt)
559 		return -EINVAL;
560 
561 	field = f->fmt.pix.field;
562 	maxw  = 720;
563 	maxh  = norm_maxh(dev->tvnorm);
564 
565 	if (V4L2_FIELD_ANY == field) {
566 		field = (f->fmt.pix.height > maxh/2)
567 			? V4L2_FIELD_INTERLACED
568 			: V4L2_FIELD_BOTTOM;
569 	}
570 
571 	switch (field) {
572 	case V4L2_FIELD_TOP:
573 	case V4L2_FIELD_BOTTOM:
574 		maxh = maxh / 2;
575 		break;
576 	case V4L2_FIELD_INTERLACED:
577 	case V4L2_FIELD_SEQ_TB:
578 	case V4L2_FIELD_SEQ_BT:
579 		break;
580 	default:
581 		field = V4L2_FIELD_INTERLACED;
582 		break;
583 	}
584 
585 	f->fmt.pix.field = field;
586 	v4l_bound_align_image(&f->fmt.pix.width, 48, maxw, 2,
587 			      &f->fmt.pix.height, 32, maxh, 0, 0);
588 	f->fmt.pix.bytesperline =
589 		(f->fmt.pix.width * fmt->depth) >> 3;
590 	f->fmt.pix.sizeimage =
591 		f->fmt.pix.height * f->fmt.pix.bytesperline;
592 	f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
593 
594 	return 0;
595 }
596 
597 static int vidioc_s_fmt_vid_cap(struct file *file, void *priv,
598 	struct v4l2_format *f)
599 {
600 	struct cx23885_dev *dev = video_drvdata(file);
601 	struct v4l2_subdev_format format = {
602 		.which = V4L2_SUBDEV_FORMAT_ACTIVE,
603 	};
604 	int err;
605 
606 	dprintk(2, "%s()\n", __func__);
607 	err = vidioc_try_fmt_vid_cap(file, priv, f);
608 
609 	if (0 != err)
610 		return err;
611 
612 	if (vb2_is_busy(&dev->vb2_vidq) || vb2_is_busy(&dev->vb2_vbiq) ||
613 	    vb2_is_busy(&dev->vb2_mpegq))
614 		return -EBUSY;
615 
616 	dev->fmt        = format_by_fourcc(f->fmt.pix.pixelformat);
617 	dev->width      = f->fmt.pix.width;
618 	dev->height     = f->fmt.pix.height;
619 	dev->field	= f->fmt.pix.field;
620 	dprintk(2, "%s() width=%d height=%d field=%d\n", __func__,
621 		dev->width, dev->height, dev->field);
622 	v4l2_fill_mbus_format(&format.format, &f->fmt.pix, MEDIA_BUS_FMT_FIXED);
623 	call_all(dev, pad, set_fmt, NULL, &format);
624 	v4l2_fill_pix_format(&f->fmt.pix, &format.format);
625 	/* set_fmt overwrites f->fmt.pix.field, restore it */
626 	f->fmt.pix.field = dev->field;
627 	return 0;
628 }
629 
630 static int vidioc_querycap(struct file *file, void  *priv,
631 	struct v4l2_capability *cap)
632 {
633 	struct cx23885_dev *dev = video_drvdata(file);
634 
635 	strscpy(cap->driver, "cx23885", sizeof(cap->driver));
636 	strscpy(cap->card, cx23885_boards[dev->board].name,
637 		sizeof(cap->card));
638 	sprintf(cap->bus_info, "PCIe:%s", pci_name(dev->pci));
639 	cap->capabilities = V4L2_CAP_READWRITE | V4L2_CAP_STREAMING |
640 			    V4L2_CAP_AUDIO | V4L2_CAP_VBI_CAPTURE |
641 			    V4L2_CAP_VIDEO_CAPTURE |
642 			    V4L2_CAP_DEVICE_CAPS;
643 	switch (dev->board) { /* i2c device tuners */
644 	case CX23885_BOARD_HAUPPAUGE_HVR1265_K4:
645 	case CX23885_BOARD_HAUPPAUGE_HVR5525:
646 	case CX23885_BOARD_HAUPPAUGE_QUADHD_DVB:
647 	case CX23885_BOARD_HAUPPAUGE_QUADHD_ATSC:
648 		cap->capabilities |= V4L2_CAP_TUNER;
649 		break;
650 	default:
651 		if (dev->tuner_type != TUNER_ABSENT)
652 			cap->capabilities |= V4L2_CAP_TUNER;
653 		break;
654 	}
655 	return 0;
656 }
657 
658 static int vidioc_enum_fmt_vid_cap(struct file *file, void  *priv,
659 	struct v4l2_fmtdesc *f)
660 {
661 	if (unlikely(f->index >= ARRAY_SIZE(formats)))
662 		return -EINVAL;
663 
664 	f->pixelformat = formats[f->index].fourcc;
665 
666 	return 0;
667 }
668 
669 static int vidioc_g_pixelaspect(struct file *file, void *priv,
670 				int type, struct v4l2_fract *f)
671 {
672 	struct cx23885_dev *dev = video_drvdata(file);
673 	bool is_50hz = dev->tvnorm & V4L2_STD_625_50;
674 
675 	if (type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
676 		return -EINVAL;
677 
678 	f->numerator = is_50hz ? 54 : 11;
679 	f->denominator = is_50hz ? 59 : 10;
680 
681 	return 0;
682 }
683 
684 static int vidioc_g_selection(struct file *file, void *fh,
685 			      struct v4l2_selection *sel)
686 {
687 	struct cx23885_dev *dev = video_drvdata(file);
688 
689 	if (sel->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
690 		return -EINVAL;
691 
692 	switch (sel->target) {
693 	case V4L2_SEL_TGT_CROP_BOUNDS:
694 	case V4L2_SEL_TGT_CROP_DEFAULT:
695 		sel->r.top = 0;
696 		sel->r.left = 0;
697 		sel->r.width = 720;
698 		sel->r.height = norm_maxh(dev->tvnorm);
699 		break;
700 	default:
701 		return -EINVAL;
702 	}
703 	return 0;
704 }
705 
706 static int vidioc_g_std(struct file *file, void *priv, v4l2_std_id *id)
707 {
708 	struct cx23885_dev *dev = video_drvdata(file);
709 	dprintk(1, "%s()\n", __func__);
710 
711 	*id = dev->tvnorm;
712 	return 0;
713 }
714 
715 static int vidioc_s_std(struct file *file, void *priv, v4l2_std_id tvnorms)
716 {
717 	struct cx23885_dev *dev = video_drvdata(file);
718 	dprintk(1, "%s()\n", __func__);
719 
720 	return cx23885_set_tvnorm(dev, tvnorms);
721 }
722 
723 int cx23885_enum_input(struct cx23885_dev *dev, struct v4l2_input *i)
724 {
725 	static const char *iname[] = {
726 		[CX23885_VMUX_COMPOSITE1] = "Composite1",
727 		[CX23885_VMUX_COMPOSITE2] = "Composite2",
728 		[CX23885_VMUX_COMPOSITE3] = "Composite3",
729 		[CX23885_VMUX_COMPOSITE4] = "Composite4",
730 		[CX23885_VMUX_SVIDEO]     = "S-Video",
731 		[CX23885_VMUX_COMPONENT]  = "Component",
732 		[CX23885_VMUX_TELEVISION] = "Television",
733 		[CX23885_VMUX_CABLE]      = "Cable TV",
734 		[CX23885_VMUX_DVB]        = "DVB",
735 		[CX23885_VMUX_DEBUG]      = "for debug only",
736 	};
737 	unsigned int n;
738 	dprintk(1, "%s()\n", __func__);
739 
740 	n = i->index;
741 	if (n >= MAX_CX23885_INPUT)
742 		return -EINVAL;
743 
744 	if (0 == INPUT(n)->type)
745 		return -EINVAL;
746 
747 	i->index = n;
748 	i->type  = V4L2_INPUT_TYPE_CAMERA;
749 	strscpy(i->name, iname[INPUT(n)->type], sizeof(i->name));
750 	i->std = CX23885_NORMS;
751 	if ((CX23885_VMUX_TELEVISION == INPUT(n)->type) ||
752 		(CX23885_VMUX_CABLE == INPUT(n)->type)) {
753 		i->type = V4L2_INPUT_TYPE_TUNER;
754 		i->audioset = 4;
755 	} else {
756 		/* Two selectable audio inputs for non-tv inputs */
757 		i->audioset = 3;
758 	}
759 
760 	if (dev->input == n) {
761 		/* enum'd input matches our configured input.
762 		 * Ask the video decoder to process the call
763 		 * and give it an oppertunity to update the
764 		 * status field.
765 		 */
766 		call_all(dev, video, g_input_status, &i->status);
767 	}
768 
769 	return 0;
770 }
771 
772 static int vidioc_enum_input(struct file *file, void *priv,
773 				struct v4l2_input *i)
774 {
775 	struct cx23885_dev *dev = video_drvdata(file);
776 	dprintk(1, "%s()\n", __func__);
777 	return cx23885_enum_input(dev, i);
778 }
779 
780 int cx23885_get_input(struct file *file, void *priv, unsigned int *i)
781 {
782 	struct cx23885_dev *dev = video_drvdata(file);
783 
784 	*i = dev->input;
785 	dprintk(1, "%s() returns %d\n", __func__, *i);
786 	return 0;
787 }
788 
789 static int vidioc_g_input(struct file *file, void *priv, unsigned int *i)
790 {
791 	return cx23885_get_input(file, priv, i);
792 }
793 
794 int cx23885_set_input(struct file *file, void *priv, unsigned int i)
795 {
796 	struct cx23885_dev *dev = video_drvdata(file);
797 
798 	dprintk(1, "%s(%d)\n", __func__, i);
799 
800 	if (i >= MAX_CX23885_INPUT) {
801 		dprintk(1, "%s() -EINVAL\n", __func__);
802 		return -EINVAL;
803 	}
804 
805 	if (INPUT(i)->type == 0)
806 		return -EINVAL;
807 
808 	cx23885_video_mux(dev, i);
809 
810 	/* By default establish the default audio input for the card also */
811 	/* Caller is free to use VIDIOC_S_AUDIO to override afterwards */
812 	cx23885_audio_mux(dev, i);
813 	return 0;
814 }
815 
816 static int vidioc_s_input(struct file *file, void *priv, unsigned int i)
817 {
818 	return cx23885_set_input(file, priv, i);
819 }
820 
821 static int vidioc_log_status(struct file *file, void *priv)
822 {
823 	struct cx23885_dev *dev = video_drvdata(file);
824 
825 	call_all(dev, core, log_status);
826 	return 0;
827 }
828 
829 static int cx23885_query_audinput(struct file *file, void *priv,
830 	struct v4l2_audio *i)
831 {
832 	static const char *iname[] = {
833 		[0] = "Baseband L/R 1",
834 		[1] = "Baseband L/R 2",
835 		[2] = "TV",
836 	};
837 	unsigned int n;
838 	dprintk(1, "%s()\n", __func__);
839 
840 	n = i->index;
841 	if (n >= 3)
842 		return -EINVAL;
843 
844 	memset(i, 0, sizeof(*i));
845 	i->index = n;
846 	strscpy(i->name, iname[n], sizeof(i->name));
847 	i->capability = V4L2_AUDCAP_STEREO;
848 	return 0;
849 
850 }
851 
852 static int vidioc_enum_audinput(struct file *file, void *priv,
853 				struct v4l2_audio *i)
854 {
855 	return cx23885_query_audinput(file, priv, i);
856 }
857 
858 static int vidioc_g_audinput(struct file *file, void *priv,
859 	struct v4l2_audio *i)
860 {
861 	struct cx23885_dev *dev = video_drvdata(file);
862 
863 	if ((CX23885_VMUX_TELEVISION == INPUT(dev->input)->type) ||
864 		(CX23885_VMUX_CABLE == INPUT(dev->input)->type))
865 		i->index = 2;
866 	else
867 		i->index = dev->audinput;
868 	dprintk(1, "%s(input=%d)\n", __func__, i->index);
869 
870 	return cx23885_query_audinput(file, priv, i);
871 }
872 
873 static int vidioc_s_audinput(struct file *file, void *priv,
874 	const struct v4l2_audio *i)
875 {
876 	struct cx23885_dev *dev = video_drvdata(file);
877 
878 	if ((CX23885_VMUX_TELEVISION == INPUT(dev->input)->type) ||
879 		(CX23885_VMUX_CABLE == INPUT(dev->input)->type)) {
880 		return i->index != 2 ? -EINVAL : 0;
881 	}
882 	if (i->index > 1)
883 		return -EINVAL;
884 
885 	dprintk(1, "%s(%d)\n", __func__, i->index);
886 
887 	dev->audinput = i->index;
888 
889 	/* Skip the audio defaults from the cards struct, caller wants
890 	 * directly touch the audio mux hardware. */
891 	cx23885_flatiron_mux(dev, dev->audinput + 1);
892 	return 0;
893 }
894 
895 static int vidioc_g_tuner(struct file *file, void *priv,
896 				struct v4l2_tuner *t)
897 {
898 	struct cx23885_dev *dev = video_drvdata(file);
899 
900 	switch (dev->board) { /* i2c device tuners */
901 	case CX23885_BOARD_HAUPPAUGE_HVR1265_K4:
902 	case CX23885_BOARD_HAUPPAUGE_HVR5525:
903 	case CX23885_BOARD_HAUPPAUGE_QUADHD_DVB:
904 	case CX23885_BOARD_HAUPPAUGE_QUADHD_ATSC:
905 		break;
906 	default:
907 		if (dev->tuner_type == TUNER_ABSENT)
908 			return -EINVAL;
909 		break;
910 	}
911 	if (0 != t->index)
912 		return -EINVAL;
913 
914 	strscpy(t->name, "Television", sizeof(t->name));
915 
916 	call_all(dev, tuner, g_tuner, t);
917 	return 0;
918 }
919 
920 static int vidioc_s_tuner(struct file *file, void *priv,
921 				const struct v4l2_tuner *t)
922 {
923 	struct cx23885_dev *dev = video_drvdata(file);
924 
925 	switch (dev->board) { /* i2c device tuners */
926 	case CX23885_BOARD_HAUPPAUGE_HVR1265_K4:
927 	case CX23885_BOARD_HAUPPAUGE_HVR5525:
928 	case CX23885_BOARD_HAUPPAUGE_QUADHD_DVB:
929 	case CX23885_BOARD_HAUPPAUGE_QUADHD_ATSC:
930 		break;
931 	default:
932 		if (dev->tuner_type == TUNER_ABSENT)
933 			return -EINVAL;
934 		break;
935 	}
936 	if (0 != t->index)
937 		return -EINVAL;
938 	/* Update the A/V core */
939 	call_all(dev, tuner, s_tuner, t);
940 
941 	return 0;
942 }
943 
944 static int vidioc_g_frequency(struct file *file, void *priv,
945 				struct v4l2_frequency *f)
946 {
947 	struct cx23885_dev *dev = video_drvdata(file);
948 
949 	switch (dev->board) { /* i2c device tuners */
950 	case CX23885_BOARD_HAUPPAUGE_HVR1265_K4:
951 	case CX23885_BOARD_HAUPPAUGE_HVR5525:
952 	case CX23885_BOARD_HAUPPAUGE_QUADHD_DVB:
953 	case CX23885_BOARD_HAUPPAUGE_QUADHD_ATSC:
954 		break;
955 	default:
956 		if (dev->tuner_type == TUNER_ABSENT)
957 			return -EINVAL;
958 		break;
959 	}
960 	f->type = V4L2_TUNER_ANALOG_TV;
961 	f->frequency = dev->freq;
962 
963 	call_all(dev, tuner, g_frequency, f);
964 
965 	return 0;
966 }
967 
968 static int cx23885_set_freq(struct cx23885_dev *dev, const struct v4l2_frequency *f)
969 {
970 	struct v4l2_ctrl *mute;
971 	int old_mute_val = 1;
972 
973 	switch (dev->board) { /* i2c device tuners */
974 	case CX23885_BOARD_HAUPPAUGE_HVR1265_K4:
975 	case CX23885_BOARD_HAUPPAUGE_HVR5525:
976 	case CX23885_BOARD_HAUPPAUGE_QUADHD_DVB:
977 	case CX23885_BOARD_HAUPPAUGE_QUADHD_ATSC:
978 		break;
979 	default:
980 		if (dev->tuner_type == TUNER_ABSENT)
981 			return -EINVAL;
982 		break;
983 	}
984 	if (unlikely(f->tuner != 0))
985 		return -EINVAL;
986 
987 	dev->freq = f->frequency;
988 
989 	/* I need to mute audio here */
990 	mute = v4l2_ctrl_find(&dev->ctrl_handler, V4L2_CID_AUDIO_MUTE);
991 	if (mute) {
992 		old_mute_val = v4l2_ctrl_g_ctrl(mute);
993 		if (!old_mute_val)
994 			v4l2_ctrl_s_ctrl(mute, 1);
995 	}
996 
997 	call_all(dev, tuner, s_frequency, f);
998 
999 	/* When changing channels it is required to reset TVAUDIO */
1000 	msleep(100);
1001 
1002 	/* I need to unmute audio here */
1003 	if (old_mute_val == 0)
1004 		v4l2_ctrl_s_ctrl(mute, old_mute_val);
1005 
1006 	return 0;
1007 }
1008 
1009 static int cx23885_set_freq_via_ops(struct cx23885_dev *dev,
1010 	const struct v4l2_frequency *f)
1011 {
1012 	struct v4l2_ctrl *mute;
1013 	int old_mute_val = 1;
1014 	struct vb2_dvb_frontend *vfe;
1015 	struct dvb_frontend *fe;
1016 
1017 	struct analog_parameters params = {
1018 		.mode      = V4L2_TUNER_ANALOG_TV,
1019 		.audmode   = V4L2_TUNER_MODE_STEREO,
1020 		.std       = dev->tvnorm,
1021 		.frequency = f->frequency
1022 	};
1023 
1024 	dev->freq = f->frequency;
1025 
1026 	/* I need to mute audio here */
1027 	mute = v4l2_ctrl_find(&dev->ctrl_handler, V4L2_CID_AUDIO_MUTE);
1028 	if (mute) {
1029 		old_mute_val = v4l2_ctrl_g_ctrl(mute);
1030 		if (!old_mute_val)
1031 			v4l2_ctrl_s_ctrl(mute, 1);
1032 	}
1033 
1034 	/* If HVR1850 */
1035 	dprintk(1, "%s() frequency=%d tuner=%d std=0x%llx\n", __func__,
1036 		params.frequency, f->tuner, params.std);
1037 
1038 	vfe = vb2_dvb_get_frontend(&dev->ts2.frontends, 1);
1039 	if (!vfe) {
1040 		return -EINVAL;
1041 	}
1042 
1043 	fe = vfe->dvb.frontend;
1044 
1045 	if ((dev->board == CX23885_BOARD_HAUPPAUGE_HVR1850) ||
1046 	    (dev->board == CX23885_BOARD_HAUPPAUGE_HVR1255) ||
1047 	    (dev->board == CX23885_BOARD_HAUPPAUGE_HVR1255_22111) ||
1048 	    (dev->board == CX23885_BOARD_HAUPPAUGE_HVR1265_K4) ||
1049 	    (dev->board == CX23885_BOARD_HAUPPAUGE_HVR5525) ||
1050 	    (dev->board == CX23885_BOARD_HAUPPAUGE_QUADHD_DVB) ||
1051 	    (dev->board == CX23885_BOARD_HAUPPAUGE_QUADHD_ATSC))
1052 		fe = &dev->ts1.analog_fe;
1053 
1054 	if (fe && fe->ops.tuner_ops.set_analog_params) {
1055 		call_all(dev, video, s_std, dev->tvnorm);
1056 		fe->ops.tuner_ops.set_analog_params(fe, &params);
1057 	}
1058 	else
1059 		pr_err("%s() No analog tuner, aborting\n", __func__);
1060 
1061 	/* When changing channels it is required to reset TVAUDIO */
1062 	msleep(100);
1063 
1064 	/* I need to unmute audio here */
1065 	if (old_mute_val == 0)
1066 		v4l2_ctrl_s_ctrl(mute, old_mute_val);
1067 
1068 	return 0;
1069 }
1070 
1071 int cx23885_set_frequency(struct file *file, void *priv,
1072 	const struct v4l2_frequency *f)
1073 {
1074 	struct cx23885_dev *dev = video_drvdata(file);
1075 	int ret;
1076 
1077 	switch (dev->board) {
1078 	case CX23885_BOARD_HAUPPAUGE_HVR1255:
1079 	case CX23885_BOARD_HAUPPAUGE_HVR1255_22111:
1080 	case CX23885_BOARD_HAUPPAUGE_HVR1265_K4:
1081 	case CX23885_BOARD_HAUPPAUGE_HVR1850:
1082 	case CX23885_BOARD_HAUPPAUGE_HVR5525:
1083 	case CX23885_BOARD_HAUPPAUGE_QUADHD_DVB:
1084 	case CX23885_BOARD_HAUPPAUGE_QUADHD_ATSC:
1085 		ret = cx23885_set_freq_via_ops(dev, f);
1086 		break;
1087 	default:
1088 		ret = cx23885_set_freq(dev, f);
1089 	}
1090 
1091 	return ret;
1092 }
1093 
1094 static int vidioc_s_frequency(struct file *file, void *priv,
1095 	const struct v4l2_frequency *f)
1096 {
1097 	return cx23885_set_frequency(file, priv, f);
1098 }
1099 
1100 /* ----------------------------------------------------------- */
1101 
1102 int cx23885_video_irq(struct cx23885_dev *dev, u32 status)
1103 {
1104 	u32 mask, count;
1105 	int handled = 0;
1106 
1107 	mask   = cx_read(VID_A_INT_MSK);
1108 	if (0 == (status & mask))
1109 		return handled;
1110 
1111 	cx_write(VID_A_INT_STAT, status);
1112 
1113 	/* risc op code error, fifo overflow or line sync detection error */
1114 	if ((status & VID_BC_MSK_OPC_ERR) ||
1115 		(status & VID_BC_MSK_SYNC) ||
1116 		(status & VID_BC_MSK_OF)) {
1117 
1118 		if (status & VID_BC_MSK_OPC_ERR) {
1119 			dprintk(7, " (VID_BC_MSK_OPC_ERR 0x%08x)\n",
1120 				VID_BC_MSK_OPC_ERR);
1121 			pr_warn("%s: video risc op code error\n",
1122 				dev->name);
1123 			cx23885_sram_channel_dump(dev,
1124 				&dev->sram_channels[SRAM_CH01]);
1125 		}
1126 
1127 		if (status & VID_BC_MSK_SYNC)
1128 			dprintk(7, " (VID_BC_MSK_SYNC 0x%08x) video lines miss-match\n",
1129 				VID_BC_MSK_SYNC);
1130 
1131 		if (status & VID_BC_MSK_OF)
1132 			dprintk(7, " (VID_BC_MSK_OF 0x%08x) fifo overflow\n",
1133 				VID_BC_MSK_OF);
1134 
1135 	}
1136 
1137 	/* Video */
1138 	if (status & VID_BC_MSK_RISCI1) {
1139 		spin_lock(&dev->slock);
1140 		count = cx_read(VID_A_GPCNT);
1141 		cx23885_video_wakeup(dev, &dev->vidq, count);
1142 		spin_unlock(&dev->slock);
1143 		handled++;
1144 	}
1145 
1146 	/* Allow the VBI framework to process it's payload */
1147 	handled += cx23885_vbi_irq(dev, status);
1148 
1149 	return handled;
1150 }
1151 
1152 /* ----------------------------------------------------------- */
1153 /* exported stuff                                              */
1154 
1155 static const struct v4l2_file_operations video_fops = {
1156 	.owner	       = THIS_MODULE,
1157 	.open           = v4l2_fh_open,
1158 	.release        = vb2_fop_release,
1159 	.read           = vb2_fop_read,
1160 	.poll		= vb2_fop_poll,
1161 	.unlocked_ioctl = video_ioctl2,
1162 	.mmap           = vb2_fop_mmap,
1163 };
1164 
1165 static const struct v4l2_ioctl_ops video_ioctl_ops = {
1166 	.vidioc_querycap      = vidioc_querycap,
1167 	.vidioc_enum_fmt_vid_cap  = vidioc_enum_fmt_vid_cap,
1168 	.vidioc_g_fmt_vid_cap     = vidioc_g_fmt_vid_cap,
1169 	.vidioc_try_fmt_vid_cap   = vidioc_try_fmt_vid_cap,
1170 	.vidioc_s_fmt_vid_cap     = vidioc_s_fmt_vid_cap,
1171 	.vidioc_g_fmt_vbi_cap     = cx23885_vbi_fmt,
1172 	.vidioc_try_fmt_vbi_cap   = cx23885_vbi_fmt,
1173 	.vidioc_s_fmt_vbi_cap     = cx23885_vbi_fmt,
1174 	.vidioc_reqbufs       = vb2_ioctl_reqbufs,
1175 	.vidioc_prepare_buf   = vb2_ioctl_prepare_buf,
1176 	.vidioc_querybuf      = vb2_ioctl_querybuf,
1177 	.vidioc_qbuf          = vb2_ioctl_qbuf,
1178 	.vidioc_dqbuf         = vb2_ioctl_dqbuf,
1179 	.vidioc_streamon      = vb2_ioctl_streamon,
1180 	.vidioc_streamoff     = vb2_ioctl_streamoff,
1181 	.vidioc_g_pixelaspect = vidioc_g_pixelaspect,
1182 	.vidioc_g_selection   = vidioc_g_selection,
1183 	.vidioc_s_std         = vidioc_s_std,
1184 	.vidioc_g_std         = vidioc_g_std,
1185 	.vidioc_enum_input    = vidioc_enum_input,
1186 	.vidioc_g_input       = vidioc_g_input,
1187 	.vidioc_s_input       = vidioc_s_input,
1188 	.vidioc_log_status    = vidioc_log_status,
1189 	.vidioc_g_tuner       = vidioc_g_tuner,
1190 	.vidioc_s_tuner       = vidioc_s_tuner,
1191 	.vidioc_g_frequency   = vidioc_g_frequency,
1192 	.vidioc_s_frequency   = vidioc_s_frequency,
1193 #ifdef CONFIG_VIDEO_ADV_DEBUG
1194 	.vidioc_g_chip_info   = cx23885_g_chip_info,
1195 	.vidioc_g_register    = cx23885_g_register,
1196 	.vidioc_s_register    = cx23885_s_register,
1197 #endif
1198 	.vidioc_enumaudio     = vidioc_enum_audinput,
1199 	.vidioc_g_audio       = vidioc_g_audinput,
1200 	.vidioc_s_audio       = vidioc_s_audinput,
1201 	.vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
1202 	.vidioc_unsubscribe_event = v4l2_event_unsubscribe,
1203 };
1204 
1205 static struct video_device cx23885_vbi_template;
1206 static struct video_device cx23885_video_template = {
1207 	.name                 = "cx23885-video",
1208 	.fops                 = &video_fops,
1209 	.ioctl_ops	      = &video_ioctl_ops,
1210 	.tvnorms              = CX23885_NORMS,
1211 };
1212 
1213 void cx23885_video_unregister(struct cx23885_dev *dev)
1214 {
1215 	dprintk(1, "%s()\n", __func__);
1216 	cx23885_irq_remove(dev, 0x01);
1217 
1218 	if (dev->vbi_dev) {
1219 		if (video_is_registered(dev->vbi_dev))
1220 			video_unregister_device(dev->vbi_dev);
1221 		else
1222 			video_device_release(dev->vbi_dev);
1223 		dev->vbi_dev = NULL;
1224 	}
1225 	if (dev->video_dev) {
1226 		if (video_is_registered(dev->video_dev))
1227 			video_unregister_device(dev->video_dev);
1228 		else
1229 			video_device_release(dev->video_dev);
1230 		dev->video_dev = NULL;
1231 	}
1232 
1233 	if (dev->audio_dev)
1234 		cx23885_audio_unregister(dev);
1235 }
1236 
1237 int cx23885_video_register(struct cx23885_dev *dev)
1238 {
1239 	struct vb2_queue *q;
1240 	int err;
1241 
1242 	dprintk(1, "%s()\n", __func__);
1243 
1244 	/* Initialize VBI template */
1245 	cx23885_vbi_template = cx23885_video_template;
1246 	strscpy(cx23885_vbi_template.name, "cx23885-vbi",
1247 		sizeof(cx23885_vbi_template.name));
1248 
1249 	dev->tvnorm = V4L2_STD_NTSC_M;
1250 	dev->fmt = format_by_fourcc(V4L2_PIX_FMT_YUYV);
1251 	dev->field = V4L2_FIELD_INTERLACED;
1252 	dev->width = 720;
1253 	dev->height = norm_maxh(dev->tvnorm);
1254 
1255 	/* init video dma queues */
1256 	INIT_LIST_HEAD(&dev->vidq.active);
1257 
1258 	/* init vbi dma queues */
1259 	INIT_LIST_HEAD(&dev->vbiq.active);
1260 
1261 	cx23885_irq_add_enable(dev, 0x01);
1262 
1263 	if ((TUNER_ABSENT != dev->tuner_type) &&
1264 			((dev->tuner_bus == 0) || (dev->tuner_bus == 1))) {
1265 		struct v4l2_subdev *sd = NULL;
1266 
1267 		if (dev->tuner_addr)
1268 			sd = v4l2_i2c_new_subdev(&dev->v4l2_dev,
1269 				&dev->i2c_bus[dev->tuner_bus].i2c_adap,
1270 				"tuner", dev->tuner_addr, NULL);
1271 		else
1272 			sd = v4l2_i2c_new_subdev(&dev->v4l2_dev,
1273 				&dev->i2c_bus[dev->tuner_bus].i2c_adap,
1274 				"tuner", 0, v4l2_i2c_tuner_addrs(ADDRS_TV));
1275 		if (sd) {
1276 			struct tuner_setup tun_setup;
1277 
1278 			memset(&tun_setup, 0, sizeof(tun_setup));
1279 			tun_setup.mode_mask = T_ANALOG_TV;
1280 			tun_setup.type = dev->tuner_type;
1281 			tun_setup.addr = v4l2_i2c_subdev_addr(sd);
1282 			tun_setup.tuner_callback = cx23885_tuner_callback;
1283 
1284 			v4l2_subdev_call(sd, tuner, s_type_addr, &tun_setup);
1285 
1286 			if ((dev->board == CX23885_BOARD_LEADTEK_WINFAST_PXTV1200) ||
1287 			    (dev->board == CX23885_BOARD_LEADTEK_WINFAST_PXPVR2200)) {
1288 				struct xc2028_ctrl ctrl = {
1289 					.fname = XC2028_DEFAULT_FIRMWARE,
1290 					.max_len = 64
1291 				};
1292 				struct v4l2_priv_tun_config cfg = {
1293 					.tuner = dev->tuner_type,
1294 					.priv = &ctrl
1295 				};
1296 				v4l2_subdev_call(sd, tuner, s_config, &cfg);
1297 			}
1298 
1299 			if (dev->board == CX23885_BOARD_AVERMEDIA_HC81R) {
1300 				struct xc2028_ctrl ctrl = {
1301 					.fname = "xc3028L-v36.fw",
1302 					.max_len = 64
1303 				};
1304 				struct v4l2_priv_tun_config cfg = {
1305 					.tuner = dev->tuner_type,
1306 					.priv = &ctrl
1307 				};
1308 				v4l2_subdev_call(sd, tuner, s_config, &cfg);
1309 			}
1310 		}
1311 	}
1312 
1313 	/* initial device configuration */
1314 	mutex_lock(&dev->lock);
1315 	cx23885_set_tvnorm(dev, dev->tvnorm);
1316 	cx23885_video_mux(dev, 0);
1317 	cx23885_audio_mux(dev, 0);
1318 	mutex_unlock(&dev->lock);
1319 
1320 	q = &dev->vb2_vidq;
1321 	q->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1322 	q->io_modes = VB2_MMAP | VB2_USERPTR | VB2_DMABUF | VB2_READ;
1323 	q->gfp_flags = GFP_DMA32;
1324 	q->min_buffers_needed = 2;
1325 	q->drv_priv = dev;
1326 	q->buf_struct_size = sizeof(struct cx23885_buffer);
1327 	q->ops = &cx23885_video_qops;
1328 	q->mem_ops = &vb2_dma_sg_memops;
1329 	q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1330 	q->lock = &dev->lock;
1331 	q->dev = &dev->pci->dev;
1332 
1333 	err = vb2_queue_init(q);
1334 	if (err < 0)
1335 		goto fail_unreg;
1336 
1337 	q = &dev->vb2_vbiq;
1338 	q->type = V4L2_BUF_TYPE_VBI_CAPTURE;
1339 	q->io_modes = VB2_MMAP | VB2_USERPTR | VB2_DMABUF | VB2_READ;
1340 	q->gfp_flags = GFP_DMA32;
1341 	q->min_buffers_needed = 2;
1342 	q->drv_priv = dev;
1343 	q->buf_struct_size = sizeof(struct cx23885_buffer);
1344 	q->ops = &cx23885_vbi_qops;
1345 	q->mem_ops = &vb2_dma_sg_memops;
1346 	q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1347 	q->lock = &dev->lock;
1348 	q->dev = &dev->pci->dev;
1349 
1350 	err = vb2_queue_init(q);
1351 	if (err < 0)
1352 		goto fail_unreg;
1353 
1354 	/* register Video device */
1355 	dev->video_dev = cx23885_vdev_init(dev, dev->pci,
1356 		&cx23885_video_template, "video");
1357 	dev->video_dev->queue = &dev->vb2_vidq;
1358 	dev->video_dev->device_caps = V4L2_CAP_READWRITE | V4L2_CAP_STREAMING |
1359 				      V4L2_CAP_AUDIO | V4L2_CAP_VIDEO_CAPTURE;
1360 	switch (dev->board) { /* i2c device tuners */
1361 	case CX23885_BOARD_HAUPPAUGE_HVR1265_K4:
1362 	case CX23885_BOARD_HAUPPAUGE_HVR5525:
1363 	case CX23885_BOARD_HAUPPAUGE_QUADHD_DVB:
1364 	case CX23885_BOARD_HAUPPAUGE_QUADHD_ATSC:
1365 		dev->video_dev->device_caps |= V4L2_CAP_TUNER;
1366 		break;
1367 	default:
1368 		if (dev->tuner_type != TUNER_ABSENT)
1369 			dev->video_dev->device_caps |= V4L2_CAP_TUNER;
1370 	}
1371 
1372 	err = video_register_device(dev->video_dev, VFL_TYPE_VIDEO,
1373 				    video_nr[dev->nr]);
1374 	if (err < 0) {
1375 		pr_info("%s: can't register video device\n",
1376 			dev->name);
1377 		goto fail_unreg;
1378 	}
1379 	pr_info("%s: registered device %s [v4l2]\n",
1380 	       dev->name, video_device_node_name(dev->video_dev));
1381 
1382 	/* register VBI device */
1383 	dev->vbi_dev = cx23885_vdev_init(dev, dev->pci,
1384 		&cx23885_vbi_template, "vbi");
1385 	dev->vbi_dev->queue = &dev->vb2_vbiq;
1386 	dev->vbi_dev->device_caps = V4L2_CAP_READWRITE | V4L2_CAP_STREAMING |
1387 				    V4L2_CAP_AUDIO | V4L2_CAP_VBI_CAPTURE;
1388 	switch (dev->board) { /* i2c device tuners */
1389 	case CX23885_BOARD_HAUPPAUGE_HVR1265_K4:
1390 	case CX23885_BOARD_HAUPPAUGE_HVR5525:
1391 	case CX23885_BOARD_HAUPPAUGE_QUADHD_DVB:
1392 	case CX23885_BOARD_HAUPPAUGE_QUADHD_ATSC:
1393 		dev->vbi_dev->device_caps |= V4L2_CAP_TUNER;
1394 		break;
1395 	default:
1396 		if (dev->tuner_type != TUNER_ABSENT)
1397 			dev->vbi_dev->device_caps |= V4L2_CAP_TUNER;
1398 	}
1399 	err = video_register_device(dev->vbi_dev, VFL_TYPE_VBI,
1400 				    vbi_nr[dev->nr]);
1401 	if (err < 0) {
1402 		pr_info("%s: can't register vbi device\n",
1403 			dev->name);
1404 		goto fail_unreg;
1405 	}
1406 	pr_info("%s: registered device %s\n",
1407 	       dev->name, video_device_node_name(dev->vbi_dev));
1408 
1409 	/* Register ALSA audio device */
1410 	dev->audio_dev = cx23885_audio_register(dev);
1411 
1412 	return 0;
1413 
1414 fail_unreg:
1415 	cx23885_video_unregister(dev);
1416 	return err;
1417 }
1418