1	// SPDX-License-Identifier: GPL-2.0-or-later
2	/*
3	cx231xx-video.c - driver for Conexant Cx23100/101/102
4	USB video capture devices
5
6	Copyright (C) 2008 <srinivasa.deevi at conexant dot com>
7	Based on em28xx driver
8	Based on cx23885 driver
9	Based on cx88 driver
10
11	*/
12
13	#include "cx231xx.h"
14	#include <linux/init.h>
15	#include <linux/list.h>
16	#include <linux/module.h>
17	#include <linux/kernel.h>
18	#include <linux/bitmap.h>
19	#include <linux/i2c.h>
20	#include <linux/mm.h>
21	#include <linux/mutex.h>
22	#include <linux/slab.h>
23
24	#include <media/v4l2-common.h>
25	#include <media/v4l2-ioctl.h>
26	#include <media/v4l2-event.h>
27	#include <media/drv-intf/msp3400.h>
28	#include <media/tuner.h>
29
30	#include <media/dvb_frontend.h>
31
32	#include "cx231xx-vbi.h"
33
34	#define CX231XX_VERSION "0.0.3"
35
36	#define DRIVER_AUTHOR "Srinivasa Deevi <srinivasa.deevi@conexant.com>"
37	#define DRIVER_DESC "Conexant cx231xx based USB video device driver"
38
39	#define cx231xx_videodbg(fmt, arg...) do {\
40	if (video_debug) \
41	printk(KERN_INFO "%s %s :"fmt, \
42	dev->name, __func__ , ##arg); } while (0)
43
44	static unsigned int isoc_debug;
45	module_param(isoc_debug, int, 0644);
46	MODULE_PARM_DESC(isoc_debug, "enable debug messages [isoc transfers]");
47
48	#define cx231xx_isocdbg(fmt, arg...) \
49	do {\
50	if (isoc_debug) { \
51	printk(KERN_INFO "%s %s :"fmt, \
52	dev->name, __func__ , ##arg); \
53	} \
54	} while (0)
55
56	MODULE_AUTHOR(DRIVER_AUTHOR);
57	MODULE_DESCRIPTION(DRIVER_DESC);
58	MODULE_LICENSE("GPL");
59	MODULE_VERSION(CX231XX_VERSION);
60
61	static unsigned int card[] = {[0 ... (CX231XX_MAXBOARDS - 1)] = -1U };
62	static unsigned int video_nr[] = {[0 ... (CX231XX_MAXBOARDS - 1)] = -1U };
63	static unsigned int vbi_nr[] = {[0 ... (CX231XX_MAXBOARDS - 1)] = -1U };
64	static unsigned int radio_nr[] = {[0 ... (CX231XX_MAXBOARDS - 1)] = -1U };
65
66	module_param_array(card, int, NULL, 0444);
67	module_param_array(video_nr, int, NULL, 0444);
68	module_param_array(vbi_nr, int, NULL, 0444);
69	module_param_array(radio_nr, int, NULL, 0444);
70
71	MODULE_PARM_DESC(card, "card type");
72	MODULE_PARM_DESC(video_nr, "video device numbers");
73	MODULE_PARM_DESC(vbi_nr, "vbi device numbers");
74	MODULE_PARM_DESC(radio_nr, "radio device numbers");
75
76	static unsigned int video_debug;
77	module_param(video_debug, int, 0644);
78	MODULE_PARM_DESC(video_debug, "enable debug messages [video]");
79
80	/* supported video standards */
81	static struct cx231xx_fmt format[] = {
82	{
83	.fourcc = V4L2_PIX_FMT_YUYV,
84	.depth = 16,
85	.reg = 0,
86	},
87	};
88
89
90	static int cx231xx_enable_analog_tuner(struct cx231xx *dev)
91	{
92	#ifdef CONFIG_MEDIA_CONTROLLER
93	struct media_device *mdev = dev->media_dev;
94	struct media_entity *entity, *decoder = NULL, *source;
95	struct media_link *link, *found_link = NULL;
96	int ret, active_links = 0;
97
98	if (!mdev)
99	return 0;
100
101	/*
102	* This will find the tuner that is connected into the decoder.
103	* Technically, this is not 100% correct, as the device may be
104	* using an analog input instead of the tuner. However, as we can't
105	* do DVB streaming while the DMA engine is being used for V4L2,
106	* this should be enough for the actual needs.
107	*/
108	media_device_for_each_entity(entity, mdev) {
109	if (entity->function == MEDIA_ENT_F_ATV_DECODER) {
110	decoder = entity;
111	break;
112	}
113	}
114	if (!decoder)
115	return 0;
116
117	list_for_each_entry(link, &decoder->links, list) {
118	if (link->sink->entity == decoder) {
119	found_link = link;
120	if (link->flags & MEDIA_LNK_FL_ENABLED)
121	active_links++;
122	break;
123	}
124	}
125
126	if (active_links == 1 || !found_link)
127	return 0;
128
129	source = found_link->source->entity;
130	list_for_each_entry(link, &source->links, list) {
131	struct media_entity *sink;
132	int flags = 0;
133
134	sink = link->sink->entity;
135
136	if (sink == entity)
137	flags = MEDIA_LNK_FL_ENABLED;
138
139	ret = media_entity_setup_link(link, flags);
140	if (ret) {
141	dev_err(dev->dev,
142	"Couldn't change link %s->%s to %s. Error %d\n",
143	source->name, sink->name,
144	flags ? "enabled" : "disabled",
145	ret);
146	return ret;
147	} else
148	dev_dbg(dev->dev,
149	"link %s->%s was %s\n",
150	source->name, sink->name,
151	flags ? "ENABLED" : "disabled");
152	}
153	#endif
154	return 0;
155	}
156
157	/* ------------------------------------------------------------------
158	Video buffer and parser functions
159	------------------------------------------------------------------*/
160
161	/*
162	* Announces that a buffer were filled and request the next
163	*/
164	static inline void buffer_filled(struct cx231xx *dev,
165	struct cx231xx_dmaqueue *dma_q,
166	struct cx231xx_buffer *buf)
167	{
168	/* Advice that buffer was filled */
169	cx231xx_isocdbg("[%p/%d] wakeup\n", buf, buf->vb.vb2_buf.index);
170	buf->vb.sequence = dma_q->sequence++;
171	buf->vb.field = V4L2_FIELD_INTERLACED;
172	buf->vb.vb2_buf.timestamp = ktime_get_ns();
173	vb2_set_plane_payload(vb: &buf->vb.vb2_buf, plane_no: 0, size: dev->size);
174
175	if (dev->USE_ISO)
176	dev->video_mode.isoc_ctl.buf = NULL;
177	else
178	dev->video_mode.bulk_ctl.buf = NULL;
179
180	list_del(entry: &buf->list);
181	vb2_buffer_done(vb: &buf->vb.vb2_buf, state: VB2_BUF_STATE_DONE);
182	}
183
184	static inline void print_err_status(struct cx231xx *dev, int packet, int status)
185	{
186	char *errmsg = "Unknown";
187
188	switch (status) {
189	case -ENOENT:
190	errmsg = "unlinked synchronously";
191	break;
192	case -ECONNRESET:
193	errmsg = "unlinked asynchronously";
194	break;
195	case -ENOSR:
196	errmsg = "Buffer error (overrun)";
197	break;
198	case -EPIPE:
199	errmsg = "Stalled (device not responding)";
200	break;
201	case -EOVERFLOW:
202	errmsg = "Babble (bad cable?)";
203	break;
204	case -EPROTO:
205	errmsg = "Bit-stuff error (bad cable?)";
206	break;
207	case -EILSEQ:
208	errmsg = "CRC/Timeout (could be anything)";
209	break;
210	case -ETIME:
211	errmsg = "Device does not respond";
212	break;
213	}
214	if (packet < 0) {
215	cx231xx_isocdbg("URB status %d [%s].\n", status, errmsg);
216	} else {
217	cx231xx_isocdbg("URB packet %d, status %d [%s].\n",
218	packet, status, errmsg);
219	}
220	}
221
222	/*
223	* generic routine to get the next available buffer
224	*/
225	static inline void get_next_buf(struct cx231xx_dmaqueue *dma_q,
226	struct cx231xx_buffer **buf)
227	{
228	struct cx231xx_video_mode *vmode =
229	container_of(dma_q, struct cx231xx_video_mode, vidq);
230	struct cx231xx *dev = container_of(vmode, struct cx231xx, video_mode);
231
232	char *outp;
233
234	if (list_empty(head: &dma_q->active)) {
235	cx231xx_isocdbg("No active queue to serve\n");
236	if (dev->USE_ISO)
237	dev->video_mode.isoc_ctl.buf = NULL;
238	else
239	dev->video_mode.bulk_ctl.buf = NULL;
240	*buf = NULL;
241	return;
242	}
243
244	/* Get the next buffer */
245	*buf = list_entry(dma_q->active.next, struct cx231xx_buffer, list);
246
247	/* Cleans up buffer - Useful for testing for frame/URB loss */
248	outp = vb2_plane_vaddr(vb: &(*buf)->vb.vb2_buf, plane_no: 0);
249	memset(outp, 0, dev->size);
250
251	if (dev->USE_ISO)
252	dev->video_mode.isoc_ctl.buf = *buf;
253	else
254	dev->video_mode.bulk_ctl.buf = *buf;
255
256	return;
257	}
258
259	/*
260	* Controls the isoc copy of each urb packet
261	*/
262	static inline int cx231xx_isoc_copy(struct cx231xx *dev, struct urb *urb)
263	{
264	struct cx231xx_dmaqueue *dma_q = urb->context;
265	int i;
266	unsigned char *p_buffer;
267	u32 bytes_parsed = 0, buffer_size = 0;
268	u8 sav_eav = 0;
269
270	if (!dev)
271	return 0;
272
273	if (dev->state & DEV_DISCONNECTED)
274	return 0;
275
276	if (urb->status < 0) {
277	print_err_status(dev, packet: -1, status: urb->status);
278	if (urb->status == -ENOENT)
279	return 0;
280	}
281
282	for (i = 0; i < urb->number_of_packets; i++) {
283	int status = urb->iso_frame_desc[i].status;
284
285	if (status < 0) {
286	print_err_status(dev, packet: i, status);
287	if (urb->iso_frame_desc[i].status != -EPROTO)
288	continue;
289	}
290
291	if (urb->iso_frame_desc[i].actual_length <= 0) {
292	/* cx231xx_isocdbg("packet %d is empty",i); - spammy */
293	continue;
294	}
295	if (urb->iso_frame_desc[i].actual_length >
296	dev->video_mode.max_pkt_size) {
297	cx231xx_isocdbg("packet bigger than packet size");
298	continue;
299	}
300
301	/* get buffer pointer and length */
302	p_buffer = urb->transfer_buffer + urb->iso_frame_desc[i].offset;
303	buffer_size = urb->iso_frame_desc[i].actual_length;
304	bytes_parsed = 0;
305
306	if (dma_q->is_partial_line) {
307	/* Handle the case of a partial line */
308	sav_eav = dma_q->last_sav;
309	} else {
310	/* Check for a SAV/EAV overlapping
311	the buffer boundary */
312	sav_eav =
313	cx231xx_find_boundary_SAV_EAV(p_buffer,
314	partial_buf: dma_q->partial_buf,
315	p_bytes_used: &bytes_parsed);
316	}
317
318	sav_eav &= 0xF0;
319	/* Get the first line if we have some portion of an SAV/EAV from
320	the last buffer or a partial line */
321	if (sav_eav) {
322	bytes_parsed += cx231xx_get_video_line(dev, dma_q,
323	sav_eav, /* SAV/EAV */
324	p_buffer: p_buffer + bytes_parsed, /* p_buffer */
325	buffer_size: buffer_size - bytes_parsed);/* buf size */
326	}
327
328	/* Now parse data that is completely in this buffer */
329	/* dma_q->is_partial_line = 0; */
330
331	while (bytes_parsed < buffer_size) {
332	u32 bytes_used = 0;
333
334	sav_eav = cx231xx_find_next_SAV_EAV(
335	p_buffer: p_buffer + bytes_parsed, /* p_buffer */
336	buffer_size: buffer_size - bytes_parsed, /* buf size */
337	p_bytes_used: &bytes_used);/* bytes used to get SAV/EAV */
338
339	bytes_parsed += bytes_used;
340
341	sav_eav &= 0xF0;
342	if (sav_eav && (bytes_parsed < buffer_size)) {
343	bytes_parsed += cx231xx_get_video_line(dev,
344	dma_q, sav_eav, /* SAV/EAV */
345	p_buffer: p_buffer + bytes_parsed,/* p_buffer */
346	buffer_size: buffer_size - bytes_parsed);/*buf size*/
347	}
348	}
349
350	/* Save the last four bytes of the buffer so we can check the
351	buffer boundary condition next time */
352	memcpy(dma_q->partial_buf, p_buffer + buffer_size - 4, 4);
353	bytes_parsed = 0;
354
355	}
356	return 1;
357	}
358
359	static inline int cx231xx_bulk_copy(struct cx231xx *dev, struct urb *urb)
360	{
361	struct cx231xx_dmaqueue *dma_q = urb->context;
362	unsigned char *p_buffer;
363	u32 bytes_parsed = 0, buffer_size = 0;
364	u8 sav_eav = 0;
365
366	if (!dev)
367	return 0;
368
369	if (dev->state & DEV_DISCONNECTED)
370	return 0;
371
372	if (urb->status < 0) {
373	print_err_status(dev, packet: -1, status: urb->status);
374	if (urb->status == -ENOENT)
375	return 0;
376	}
377
378	if (1) {
379
380	/* get buffer pointer and length */
381	p_buffer = urb->transfer_buffer;
382	buffer_size = urb->actual_length;
383	bytes_parsed = 0;
384
385	if (dma_q->is_partial_line) {
386	/* Handle the case of a partial line */
387	sav_eav = dma_q->last_sav;
388	} else {
389	/* Check for a SAV/EAV overlapping
390	the buffer boundary */
391	sav_eav =
392	cx231xx_find_boundary_SAV_EAV(p_buffer,
393	partial_buf: dma_q->partial_buf,
394	p_bytes_used: &bytes_parsed);
395	}
396
397	sav_eav &= 0xF0;
398	/* Get the first line if we have some portion of an SAV/EAV from
399	the last buffer or a partial line */
400	if (sav_eav) {
401	bytes_parsed += cx231xx_get_video_line(dev, dma_q,
402	sav_eav, /* SAV/EAV */
403	p_buffer: p_buffer + bytes_parsed, /* p_buffer */
404	buffer_size: buffer_size - bytes_parsed);/* buf size */
405	}
406
407	/* Now parse data that is completely in this buffer */
408	/* dma_q->is_partial_line = 0; */
409
410	while (bytes_parsed < buffer_size) {
411	u32 bytes_used = 0;
412
413	sav_eav = cx231xx_find_next_SAV_EAV(
414	p_buffer: p_buffer + bytes_parsed, /* p_buffer */
415	buffer_size: buffer_size - bytes_parsed, /* buf size */
416	p_bytes_used: &bytes_used);/* bytes used to get SAV/EAV */
417
418	bytes_parsed += bytes_used;
419
420	sav_eav &= 0xF0;
421	if (sav_eav && (bytes_parsed < buffer_size)) {
422	bytes_parsed += cx231xx_get_video_line(dev,
423	dma_q, sav_eav, /* SAV/EAV */
424	p_buffer: p_buffer + bytes_parsed,/* p_buffer */
425	buffer_size: buffer_size - bytes_parsed);/*buf size*/
426	}
427	}
428
429	/* Save the last four bytes of the buffer so we can check the
430	buffer boundary condition next time */
431	memcpy(dma_q->partial_buf, p_buffer + buffer_size - 4, 4);
432	bytes_parsed = 0;
433
434	}
435	return 1;
436	}
437
438
439	u8 cx231xx_find_boundary_SAV_EAV(u8 *p_buffer, u8 *partial_buf,
440	u32 *p_bytes_used)
441	{
442	u32 bytes_used;
443	u8 boundary_bytes[8];
444	u8 sav_eav = 0;
445
446	*p_bytes_used = 0;
447
448	/* Create an array of the last 4 bytes of the last buffer and the first
449	4 bytes of the current buffer. */
450
451	memcpy(boundary_bytes, partial_buf, 4);
452	memcpy(boundary_bytes + 4, p_buffer, 4);
453
454	/* Check for the SAV/EAV in the boundary buffer */
455	sav_eav = cx231xx_find_next_SAV_EAV(p_buffer: (u8 *)&boundary_bytes, buffer_size: 8,
456	p_bytes_used: &bytes_used);
457
458	if (sav_eav) {
459	/* found a boundary SAV/EAV. Updates the bytes used to reflect
460	only those used in the new buffer */
461	*p_bytes_used = bytes_used - 4;
462	}
463
464	return sav_eav;
465	}
466
467	u8 cx231xx_find_next_SAV_EAV(u8 *p_buffer, u32 buffer_size, u32 *p_bytes_used)
468	{
469	u32 i;
470	u8 sav_eav = 0;
471
472	/*
473	* Don't search if the buffer size is less than 4. It causes a page
474	* fault since buffer_size - 4 evaluates to a large number in that
475	* case.
476	*/
477	if (buffer_size < 4) {
478	*p_bytes_used = buffer_size;
479	return 0;
480	}
481
482	for (i = 0; i < (buffer_size - 3); i++) {
483
484	if ((p_buffer[i] == 0xFF) &&
485	(p_buffer[i + 1] == 0x00) && (p_buffer[i + 2] == 0x00)) {
486
487	*p_bytes_used = i + 4;
488	sav_eav = p_buffer[i + 3];
489	return sav_eav;
490	}
491	}
492
493	*p_bytes_used = buffer_size;
494	return 0;
495	}
496
497	u32 cx231xx_get_video_line(struct cx231xx *dev,
498	struct cx231xx_dmaqueue *dma_q, u8 sav_eav,
499	u8 *p_buffer, u32 buffer_size)
500	{
501	u32 bytes_copied = 0;
502	int current_field = -1;
503
504	switch (sav_eav) {
505	case SAV_ACTIVE_VIDEO_FIELD1:
506	/* looking for skipped line which occurred in PAL 720x480 mode.
507	In this case, there will be no active data contained
508	between the SAV and EAV */
509	if ((buffer_size > 3) && (p_buffer[0] == 0xFF) &&
510	(p_buffer[1] == 0x00) && (p_buffer[2] == 0x00) &&
511	((p_buffer[3] == EAV_ACTIVE_VIDEO_FIELD1) ||
512	(p_buffer[3] == EAV_ACTIVE_VIDEO_FIELD2) ||
513	(p_buffer[3] == EAV_VBLANK_FIELD1) ||
514	(p_buffer[3] == EAV_VBLANK_FIELD2)))
515	return bytes_copied;
516	current_field = 1;
517	break;
518
519	case SAV_ACTIVE_VIDEO_FIELD2:
520	/* looking for skipped line which occurred in PAL 720x480 mode.
521	In this case, there will be no active data contained between
522	the SAV and EAV */
523	if ((buffer_size > 3) && (p_buffer[0] == 0xFF) &&
524	(p_buffer[1] == 0x00) && (p_buffer[2] == 0x00) &&
525	((p_buffer[3] == EAV_ACTIVE_VIDEO_FIELD1) ||
526	(p_buffer[3] == EAV_ACTIVE_VIDEO_FIELD2) ||
527	(p_buffer[3] == EAV_VBLANK_FIELD1) ||
528	(p_buffer[3] == EAV_VBLANK_FIELD2)))
529	return bytes_copied;
530	current_field = 2;
531	break;
532	}
533
534	dma_q->last_sav = sav_eav;
535
536	bytes_copied = cx231xx_copy_video_line(dev, dma_q, p_line: p_buffer,
537	length: buffer_size, field_number: current_field);
538
539	return bytes_copied;
540	}
541
542	u32 cx231xx_copy_video_line(struct cx231xx *dev,
543	struct cx231xx_dmaqueue *dma_q, u8 *p_line,
544	u32 length, int field_number)
545	{
546	u32 bytes_to_copy;
547	struct cx231xx_buffer *buf;
548	u32 _line_size = dev->width * 2;
549
550	if (dma_q->current_field != field_number)
551	cx231xx_reset_video_buffer(dev, dma_q);
552
553	/* get the buffer pointer */
554	if (dev->USE_ISO)
555	buf = dev->video_mode.isoc_ctl.buf;
556	else
557	buf = dev->video_mode.bulk_ctl.buf;
558
559	/* Remember the field number for next time */
560	dma_q->current_field = field_number;
561
562	bytes_to_copy = dma_q->bytes_left_in_line;
563	if (bytes_to_copy > length)
564	bytes_to_copy = length;
565
566	if (dma_q->lines_completed >= dma_q->lines_per_field) {
567	dma_q->bytes_left_in_line -= bytes_to_copy;
568	dma_q->is_partial_line = (dma_q->bytes_left_in_line == 0) ?
569	0 : 1;
570	return 0;
571	}
572
573	dma_q->is_partial_line = 1;
574
575	/* If we don't have a buffer, just return the number of bytes we would
576	have copied if we had a buffer. */
577	if (!buf) {
578	dma_q->bytes_left_in_line -= bytes_to_copy;
579	dma_q->is_partial_line = (dma_q->bytes_left_in_line == 0)
580	? 0 : 1;
581	return bytes_to_copy;
582	}
583
584	/* copy the data to video buffer */
585	cx231xx_do_copy(dev, dma_q, p_buffer: p_line, bytes_to_copy);
586
587	dma_q->pos += bytes_to_copy;
588	dma_q->bytes_left_in_line -= bytes_to_copy;
589
590	if (dma_q->bytes_left_in_line == 0) {
591	dma_q->bytes_left_in_line = _line_size;
592	dma_q->lines_completed++;
593	dma_q->is_partial_line = 0;
594
595	if (cx231xx_is_buffer_done(dev, dma_q) && buf) {
596	buffer_filled(dev, dma_q, buf);
597
598	dma_q->pos = 0;
599	buf = NULL;
600	dma_q->lines_completed = 0;
601	}
602	}
603
604	return bytes_to_copy;
605	}
606
607	void cx231xx_reset_video_buffer(struct cx231xx *dev,
608	struct cx231xx_dmaqueue *dma_q)
609	{
610	struct cx231xx_buffer *buf;
611
612	/* handle the switch from field 1 to field 2 */
613	if (dma_q->current_field == 1) {
614	if (dma_q->lines_completed >= dma_q->lines_per_field)
615	dma_q->field1_done = 1;
616	else
617	dma_q->field1_done = 0;
618	}
619
620	if (dev->USE_ISO)
621	buf = dev->video_mode.isoc_ctl.buf;
622	else
623	buf = dev->video_mode.bulk_ctl.buf;
624
625	if (buf == NULL) {
626	/* first try to get the buffer */
627	get_next_buf(dma_q, buf: &buf);
628
629	dma_q->pos = 0;
630	dma_q->field1_done = 0;
631	dma_q->current_field = -1;
632	}
633
634	/* reset the counters */
635	dma_q->bytes_left_in_line = dev->width << 1;
636	dma_q->lines_completed = 0;
637	}
638
639	int cx231xx_do_copy(struct cx231xx *dev, struct cx231xx_dmaqueue *dma_q,
640	u8 *p_buffer, u32 bytes_to_copy)
641	{
642	u8 *p_out_buffer = NULL;
643	u32 current_line_bytes_copied = 0;
644	struct cx231xx_buffer *buf;
645	u32 _line_size = dev->width << 1;
646	void *startwrite;
647	int offset, lencopy;
648
649	if (dev->USE_ISO)
650	buf = dev->video_mode.isoc_ctl.buf;
651	else
652	buf = dev->video_mode.bulk_ctl.buf;
653
654	if (buf == NULL)
655	return -1;
656
657	p_out_buffer = vb2_plane_vaddr(vb: &buf->vb.vb2_buf, plane_no: 0);
658
659	current_line_bytes_copied = _line_size - dma_q->bytes_left_in_line;
660
661	/* Offset field 2 one line from the top of the buffer */
662	offset = (dma_q->current_field == 1) ? 0 : _line_size;
663
664	/* Offset for field 2 */
665	startwrite = p_out_buffer + offset;
666
667	/* lines already completed in the current field */
668	startwrite += (dma_q->lines_completed * _line_size * 2);
669
670	/* bytes already completed in the current line */
671	startwrite += current_line_bytes_copied;
672
673	lencopy = dma_q->bytes_left_in_line > bytes_to_copy ?
674	bytes_to_copy : dma_q->bytes_left_in_line;
675
676	if ((u8 *)(startwrite + lencopy) > (u8 *)(p_out_buffer + dev->size))
677	return 0;
678
679	/* The below copies the UYVY data straight into video buffer */
680	cx231xx_swab(from: (u16 *) p_buffer, to: (u16 *) startwrite, len: (u16) lencopy);
681
682	return 0;
683	}
684
685	void cx231xx_swab(u16 *from, u16 *to, u16 len)
686	{
687	u16 i;
688
689	if (len <= 0)
690	return;
691
692	for (i = 0; i < len / 2; i++)
693	to[i] = (from[i] << 8) | (from[i] >> 8);
694	}
695
696	u8 cx231xx_is_buffer_done(struct cx231xx *dev, struct cx231xx_dmaqueue *dma_q)
697	{
698	u8 buffer_complete = 0;
699
700	/* Dual field stream */
701	buffer_complete = ((dma_q->current_field == 2) &&
702	(dma_q->lines_completed >= dma_q->lines_per_field) &&
703	dma_q->field1_done);
704
705	return buffer_complete;
706	}
707
708	/* ------------------------------------------------------------------
709	Videobuf operations
710	------------------------------------------------------------------*/
711
712	static int queue_setup(struct vb2_queue *vq,
713	unsigned int *nbuffers, unsigned int *nplanes,
714	unsigned int sizes[], struct device *alloc_devs[])
715	{
716	struct cx231xx *dev = vb2_get_drv_priv(q: vq);
717	unsigned int q_num_bufs = vb2_get_num_buffers(q: vq);
718
719	dev->size = (dev->width * dev->height * dev->format->depth + 7) >> 3;
720
721	if (q_num_bufs + *nbuffers < CX231XX_MIN_BUF)
722	*nbuffers = CX231XX_MIN_BUF - q_num_bufs;
723
724	if (*nplanes)
725	return sizes[0] < dev->size ? -EINVAL : 0;
726	*nplanes = 1;
727	sizes[0] = dev->size;
728
729	return 0;
730	}
731
732	static void buffer_queue(struct vb2_buffer *vb)
733	{
734	struct cx231xx_buffer *buf =
735	container_of(vb, struct cx231xx_buffer, vb.vb2_buf);
736	struct cx231xx *dev = vb2_get_drv_priv(q: vb->vb2_queue);
737	struct cx231xx_dmaqueue *vidq = &dev->video_mode.vidq;
738	unsigned long flags;
739
740	spin_lock_irqsave(&dev->video_mode.slock, flags);
741	list_add_tail(new: &buf->list, head: &vidq->active);
742	spin_unlock_irqrestore(lock: &dev->video_mode.slock, flags);
743	}
744
745	static void return_all_buffers(struct cx231xx *dev,
746	enum vb2_buffer_state state)
747	{
748	struct cx231xx_dmaqueue *vidq = &dev->video_mode.vidq;
749	struct cx231xx_buffer *buf, *node;
750	unsigned long flags;
751
752	spin_lock_irqsave(&dev->video_mode.slock, flags);
753	if (dev->USE_ISO)
754	dev->video_mode.isoc_ctl.buf = NULL;
755	else
756	dev->video_mode.bulk_ctl.buf = NULL;
757	list_for_each_entry_safe(buf, node, &vidq->active, list) {
758	list_del(entry: &buf->list);
759	vb2_buffer_done(vb: &buf->vb.vb2_buf, state);
760	}
761	spin_unlock_irqrestore(lock: &dev->video_mode.slock, flags);
762	}
763
764	static int start_streaming(struct vb2_queue *vq, unsigned int count)
765	{
766	struct cx231xx *dev = vb2_get_drv_priv(q: vq);
767	struct cx231xx_dmaqueue *vidq = &dev->video_mode.vidq;
768	int ret = 0;
769
770	vidq->sequence = 0;
771	dev->mode_tv = 0;
772
773	cx231xx_enable_analog_tuner(dev);
774	if (dev->USE_ISO)
775	ret = cx231xx_init_isoc(dev, CX231XX_NUM_PACKETS,
776	CX231XX_NUM_BUFS,
777	max_pkt_size: dev->video_mode.max_pkt_size,
778	isoc_copy: cx231xx_isoc_copy);
779	else
780	ret = cx231xx_init_bulk(dev, CX231XX_NUM_PACKETS,
781	CX231XX_NUM_BUFS,
782	max_pkt_size: dev->video_mode.max_pkt_size,
783	bulk_copy: cx231xx_bulk_copy);
784	if (ret)
785	return_all_buffers(dev, state: VB2_BUF_STATE_QUEUED);
786	call_all(dev, video, s_stream, 1);
787	return ret;
788	}
789
790	static void stop_streaming(struct vb2_queue *vq)
791	{
792	struct cx231xx *dev = vb2_get_drv_priv(q: vq);
793
794	call_all(dev, video, s_stream, 0);
795	return_all_buffers(dev, state: VB2_BUF_STATE_ERROR);
796	}
797
798	static struct vb2_ops cx231xx_video_qops = {
799	.queue_setup = queue_setup,
800	.buf_queue = buffer_queue,
801	.start_streaming = start_streaming,
802	.stop_streaming = stop_streaming,
803	.wait_prepare = vb2_ops_wait_prepare,
804	.wait_finish = vb2_ops_wait_finish,
805	};
806
807	/********************* v4l2 interface **************************************/
808
809	void video_mux(struct cx231xx *dev, int index)
810	{
811	dev->video_input = index;
812	dev->ctl_ainput = INPUT(index)->amux;
813
814	cx231xx_set_video_input_mux(dev, input: index);
815
816	cx25840_call(dev, video, s_routing, INPUT(index)->vmux, 0, 0);
817
818	cx231xx_set_audio_input(dev, input: dev->ctl_ainput);
819
820	dev_dbg(dev->dev, "video_mux : %d\n", index);
821
822	/* do mode control overrides if required */
823	cx231xx_do_mode_ctrl_overrides(dev);
824	}
825
826	/* ------------------------------------------------------------------
827	IOCTL vidioc handling
828	------------------------------------------------------------------*/
829
830	static int vidioc_g_fmt_vid_cap(struct file *file, void *priv,
831	struct v4l2_format *f)
832	{
833	struct cx231xx *dev = video_drvdata(file);
834
835	f->fmt.pix.width = dev->width;
836	f->fmt.pix.height = dev->height;
837	f->fmt.pix.pixelformat = dev->format->fourcc;
838	f->fmt.pix.bytesperline = (dev->width * dev->format->depth + 7) >> 3;
839	f->fmt.pix.sizeimage = f->fmt.pix.bytesperline * dev->height;
840	f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
841
842	f->fmt.pix.field = V4L2_FIELD_INTERLACED;
843
844	return 0;
845	}
846
847	static struct cx231xx_fmt *format_by_fourcc(unsigned int fourcc)
848	{
849	unsigned int i;
850
851	for (i = 0; i < ARRAY_SIZE(format); i++)
852	if (format[i].fourcc == fourcc)
853	return &format[i];
854
855	return NULL;
856	}
857
858	static int vidioc_try_fmt_vid_cap(struct file *file, void *priv,
859	struct v4l2_format *f)
860	{
861	struct cx231xx *dev = video_drvdata(file);
862	unsigned int width = f->fmt.pix.width;
863	unsigned int height = f->fmt.pix.height;
864	unsigned int maxw = norm_maxw(dev);
865	unsigned int maxh = norm_maxh(dev);
866	struct cx231xx_fmt *fmt;
867
868	fmt = format_by_fourcc(fourcc: f->fmt.pix.pixelformat);
869	if (!fmt) {
870	cx231xx_videodbg("Fourcc format (%08x) invalid.\n",
871	f->fmt.pix.pixelformat);
872	return -EINVAL;
873	}
874
875	/* width must even because of the YUYV format
876	height must be even because of interlacing */
877	v4l_bound_align_image(width: &width, wmin: 48, wmax: maxw, walign: 1, height: &height, hmin: 32, hmax: maxh, halign: 1, salign: 0);
878
879	f->fmt.pix.width = width;
880	f->fmt.pix.height = height;
881	f->fmt.pix.pixelformat = fmt->fourcc;
882	f->fmt.pix.bytesperline = (width * fmt->depth + 7) >> 3;
883	f->fmt.pix.sizeimage = f->fmt.pix.bytesperline * height;
884	f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
885	f->fmt.pix.field = V4L2_FIELD_INTERLACED;
886
887	return 0;
888	}
889
890	static int vidioc_s_fmt_vid_cap(struct file *file, void *priv,
891	struct v4l2_format *f)
892	{
893	struct cx231xx *dev = video_drvdata(file);
894	struct v4l2_subdev_format format = {
895	.which = V4L2_SUBDEV_FORMAT_ACTIVE,
896	};
897	int rc;
898
899	rc = vidioc_try_fmt_vid_cap(file, priv, f);
900	if (rc)
901	return rc;
902
903	if (vb2_is_busy(q: &dev->vidq)) {
904	dev_err(dev->dev, "%s: queue busy\n", __func__);
905	return -EBUSY;
906	}
907
908	/* set new image size */
909	dev->width = f->fmt.pix.width;
910	dev->height = f->fmt.pix.height;
911	dev->format = format_by_fourcc(fourcc: f->fmt.pix.pixelformat);
912
913	v4l2_fill_mbus_format(mbus_fmt: &format.format, pix_fmt: &f->fmt.pix, MEDIA_BUS_FMT_FIXED);
914	call_all(dev, pad, set_fmt, NULL, &format);
915	v4l2_fill_pix_format(pix_fmt: &f->fmt.pix, mbus_fmt: &format.format);
916
917	return rc;
918	}
919
920	static int vidioc_g_std(struct file *file, void *priv, v4l2_std_id *id)
921	{
922	struct cx231xx *dev = video_drvdata(file);
923
924	*id = dev->norm;
925	return 0;
926	}
927
928	static int vidioc_s_std(struct file *file, void *priv, v4l2_std_id norm)
929	{
930	struct cx231xx *dev = video_drvdata(file);
931	struct v4l2_subdev_format format = {
932	.which = V4L2_SUBDEV_FORMAT_ACTIVE,
933	};
934
935	if (dev->norm == norm)
936	return 0;
937
938	if (vb2_is_busy(q: &dev->vidq))
939	return -EBUSY;
940
941	dev->norm = norm;
942
943	/* Adjusts width/height, if needed */
944	dev->width = 720;
945	dev->height = (dev->norm & V4L2_STD_625_50) ? 576 : 480;
946
947	call_all(dev, video, s_std, dev->norm);
948
949	/* We need to reset basic properties in the decoder related to
950	resolution (since a standard change effects things like the number
951	of lines in VACT, etc) */
952	format.format.code = MEDIA_BUS_FMT_FIXED;
953	format.format.width = dev->width;
954	format.format.height = dev->height;
955	call_all(dev, pad, set_fmt, NULL, &format);
956
957	/* do mode control overrides */
958	cx231xx_do_mode_ctrl_overrides(dev);
959
960	return 0;
961	}
962
963	static const char *iname[] = {
964	[CX231XX_VMUX_COMPOSITE1] = "Composite1",
965	[CX231XX_VMUX_SVIDEO] = "S-Video",
966	[CX231XX_VMUX_TELEVISION] = "Television",
967	[CX231XX_VMUX_CABLE] = "Cable TV",
968	[CX231XX_VMUX_DVB] = "DVB",
969	};
970
971	void cx231xx_v4l2_create_entities(struct cx231xx *dev)
972	{
973	#if defined(CONFIG_MEDIA_CONTROLLER)
974	int ret, i;
975
976	/* Create entities for each input connector */
977	for (i = 0; i < MAX_CX231XX_INPUT; i++) {
978	struct media_entity *ent = &dev->input_ent[i];
979
980	if (!INPUT(i)->type)
981	break;
982
983	ent->name = iname[INPUT(i)->type];
984	ent->flags = MEDIA_ENT_FL_CONNECTOR;
985	dev->input_pad[i].flags = MEDIA_PAD_FL_SOURCE;
986
987	switch (INPUT(i)->type) {
988	case CX231XX_VMUX_COMPOSITE1:
989	ent->function = MEDIA_ENT_F_CONN_COMPOSITE;
990	break;
991	case CX231XX_VMUX_SVIDEO:
992	ent->function = MEDIA_ENT_F_CONN_SVIDEO;
993	break;
994	case CX231XX_VMUX_TELEVISION:
995	case CX231XX_VMUX_CABLE:
996	case CX231XX_VMUX_DVB:
997	/* The DVB core will handle it */
998	if (dev->tuner_type == TUNER_ABSENT)
999	continue;
1000	fallthrough;
1001	default: /* just to shut up a gcc warning */
1002	ent->function = MEDIA_ENT_F_CONN_RF;
1003	break;
1004	}
1005
1006	ret = media_entity_pads_init(entity: ent, num_pads: 1, pads: &dev->input_pad[i]);
1007	if (ret < 0)
1008	pr_err("failed to initialize input pad[%d]!\n", i);
1009
1010	ret = media_device_register_entity(mdev: dev->media_dev, entity: ent);
1011	if (ret < 0)
1012	pr_err("failed to register input entity %d!\n", i);
1013	}
1014	#endif
1015	}
1016
1017	int cx231xx_enum_input(struct file *file, void *priv,
1018	struct v4l2_input *i)
1019	{
1020	struct cx231xx *dev = video_drvdata(file);
1021	u32 gen_stat;
1022	unsigned int n;
1023	int ret;
1024
1025	n = i->index;
1026	if (n >= MAX_CX231XX_INPUT)
1027	return -EINVAL;
1028	if (0 == INPUT(n)->type)
1029	return -EINVAL;
1030
1031	i->index = n;
1032	i->type = V4L2_INPUT_TYPE_CAMERA;
1033
1034	strscpy(i->name, iname[INPUT(n)->type], sizeof(i->name));
1035
1036	if ((CX231XX_VMUX_TELEVISION == INPUT(n)->type) ||
1037	(CX231XX_VMUX_CABLE == INPUT(n)->type))
1038	i->type = V4L2_INPUT_TYPE_TUNER;
1039
1040	i->std = dev->vdev.tvnorms;
1041
1042	/* If they are asking about the active input, read signal status */
1043	if (n == dev->video_input) {
1044	ret = cx231xx_read_i2c_data(dev, VID_BLK_I2C_ADDRESS,
1045	GEN_STAT, saddr_len: 2, data: &gen_stat, data_len: 4);
1046	if (ret > 0) {
1047	if ((gen_stat & FLD_VPRES) == 0x00)
1048	i->status |= V4L2_IN_ST_NO_SIGNAL;
1049	if ((gen_stat & FLD_HLOCK) == 0x00)
1050	i->status |= V4L2_IN_ST_NO_H_LOCK;
1051	}
1052	}
1053
1054	return 0;
1055	}
1056
1057	int cx231xx_g_input(struct file *file, void *priv, unsigned int *i)
1058	{
1059	struct cx231xx *dev = video_drvdata(file);
1060
1061	*i = dev->video_input;
1062
1063	return 0;
1064	}
1065
1066	int cx231xx_s_input(struct file *file, void *priv, unsigned int i)
1067	{
1068	struct cx231xx *dev = video_drvdata(file);
1069
1070	dev->mode_tv = 0;
1071
1072	if (i >= MAX_CX231XX_INPUT)
1073	return -EINVAL;
1074	if (0 == INPUT(i)->type)
1075	return -EINVAL;
1076
1077	video_mux(dev, index: i);
1078
1079	if (INPUT(i)->type == CX231XX_VMUX_TELEVISION ||
1080	INPUT(i)->type == CX231XX_VMUX_CABLE) {
1081	/* There's a tuner, so reset the standard and put it on the
1082	last known frequency (since it was probably powered down
1083	until now */
1084	call_all(dev, video, s_std, dev->norm);
1085	}
1086
1087	return 0;
1088	}
1089
1090	int cx231xx_g_tuner(struct file *file, void *priv, struct v4l2_tuner *t)
1091	{
1092	struct cx231xx *dev = video_drvdata(file);
1093
1094	if (0 != t->index)
1095	return -EINVAL;
1096
1097	strscpy(t->name, "Tuner", sizeof(t->name));
1098
1099	t->type = V4L2_TUNER_ANALOG_TV;
1100	t->capability = V4L2_TUNER_CAP_NORM;
1101	t->rangehigh = 0xffffffffUL;
1102	t->signal = 0xffff; /* LOCKED */
1103	call_all(dev, tuner, g_tuner, t);
1104
1105	return 0;
1106	}
1107
1108	int cx231xx_s_tuner(struct file *file, void *priv, const struct v4l2_tuner *t)
1109	{
1110	if (0 != t->index)
1111	return -EINVAL;
1112	return 0;
1113	}
1114
1115	int cx231xx_g_frequency(struct file *file, void *priv,
1116	struct v4l2_frequency *f)
1117	{
1118	struct cx231xx *dev = video_drvdata(file);
1119
1120	if (f->tuner)
1121	return -EINVAL;
1122
1123	f->frequency = dev->ctl_freq;
1124
1125	return 0;
1126	}
1127
1128	int cx231xx_s_frequency(struct file *file, void *priv,
1129	const struct v4l2_frequency *f)
1130	{
1131	struct cx231xx *dev = video_drvdata(file);
1132	struct v4l2_frequency new_freq = *f;
1133	int rc, need_if_freq = 0;
1134	u32 if_frequency = 5400000;
1135
1136	dev_dbg(dev->dev,
1137	"Enter vidioc_s_frequency()f->frequency=%d;f->type=%d\n",
1138	f->frequency, f->type);
1139
1140	if (0 != f->tuner)
1141	return -EINVAL;
1142
1143	/* set pre channel change settings in DIF first */
1144	rc = cx231xx_tuner_pre_channel_change(dev);
1145
1146	switch (dev->model) { /* i2c device tuners */
1147	case CX231XX_BOARD_HAUPPAUGE_930C_HD_1114xx:
1148	case CX231XX_BOARD_HAUPPAUGE_935C:
1149	case CX231XX_BOARD_HAUPPAUGE_955Q:
1150	case CX231XX_BOARD_HAUPPAUGE_975:
1151	case CX231XX_BOARD_EVROMEDIA_FULL_HYBRID_FULLHD:
1152	if (dev->cx231xx_set_analog_freq)
1153	dev->cx231xx_set_analog_freq(dev, f->frequency);
1154	dev->ctl_freq = f->frequency;
1155	need_if_freq = 1;
1156	break;
1157	default:
1158	call_all(dev, tuner, s_frequency, f);
1159	call_all(dev, tuner, g_frequency, &new_freq);
1160	dev->ctl_freq = new_freq.frequency;
1161	break;
1162	}
1163
1164	pr_debug("%s() %u : %u\n", __func__, f->frequency, dev->ctl_freq);
1165
1166	/* set post channel change settings in DIF first */
1167	rc = cx231xx_tuner_post_channel_change(dev);
1168
1169	if (need_if_freq || dev->tuner_type == TUNER_NXP_TDA18271) {
1170	if (dev->norm & (V4L2_STD_MN | V4L2_STD_NTSC_443))
1171	if_frequency = 5400000; /*5.4MHz */
1172	else if (dev->norm & V4L2_STD_B)
1173	if_frequency = 6000000; /*6.0MHz */
1174	else if (dev->norm & (V4L2_STD_PAL_DK | V4L2_STD_SECAM_DK))
1175	if_frequency = 6900000; /*6.9MHz */
1176	else if (dev->norm & V4L2_STD_GH)
1177	if_frequency = 7100000; /*7.1MHz */
1178	else if (dev->norm & V4L2_STD_PAL_I)
1179	if_frequency = 7250000; /*7.25MHz */
1180	else if (dev->norm & V4L2_STD_SECAM_L)
1181	if_frequency = 6900000; /*6.9MHz */
1182	else if (dev->norm & V4L2_STD_SECAM_LC)
1183	if_frequency = 1250000; /*1.25MHz */
1184
1185	dev_dbg(dev->dev,
1186	"if_frequency is set to %d\n", if_frequency);
1187	cx231xx_set_Colibri_For_LowIF(dev, if_freq: if_frequency, spectral_invert: 1, mode: 1);
1188
1189	update_HH_register_after_set_DIF(dev);
1190	}
1191
1192	dev_dbg(dev->dev, "Set New FREQUENCY to %d\n", f->frequency);
1193
1194	return rc;
1195	}
1196
1197	#ifdef CONFIG_VIDEO_ADV_DEBUG
1198
1199	int cx231xx_g_chip_info(struct file *file, void *fh,
1200	struct v4l2_dbg_chip_info *chip)
1201	{
1202	switch (chip->match.addr) {
1203	case 0: /* Cx231xx - internal registers */
1204	return 0;
1205	case 1: /* AFE - read byte */
1206	strscpy(chip->name, "AFE (byte)", sizeof(chip->name));
1207	return 0;
1208	case 2: /* Video Block - read byte */
1209	strscpy(chip->name, "Video (byte)", sizeof(chip->name));
1210	return 0;
1211	case 3: /* I2S block - read byte */
1212	strscpy(chip->name, "I2S (byte)", sizeof(chip->name));
1213	return 0;
1214	case 4: /* AFE - read dword */
1215	strscpy(chip->name, "AFE (dword)", sizeof(chip->name));
1216	return 0;
1217	case 5: /* Video Block - read dword */
1218	strscpy(chip->name, "Video (dword)", sizeof(chip->name));
1219	return 0;
1220	case 6: /* I2S Block - read dword */
1221	strscpy(chip->name, "I2S (dword)", sizeof(chip->name));
1222	return 0;
1223	}
1224	return -EINVAL;
1225	}
1226
1227	int cx231xx_g_register(struct file *file, void *priv,
1228	struct v4l2_dbg_register *reg)
1229	{
1230	struct cx231xx *dev = video_drvdata(file);
1231	int ret;
1232	u8 value[4] = { 0, 0, 0, 0 };
1233	u32 data = 0;
1234
1235	switch (reg->match.addr) {
1236	case 0: /* Cx231xx - internal registers */
1237	ret = cx231xx_read_ctrl_reg(dev, req: VRT_GET_REGISTER,
1238	reg: (u16)reg->reg, buf: value, len: 4);
1239	reg->val = value[0] | value[1] << 8 |
1240	value[2] << 16 | (u32)value[3] << 24;
1241	reg->size = 4;
1242	break;
1243	case 1: /* AFE - read byte */
1244	ret = cx231xx_read_i2c_data(dev, AFE_DEVICE_ADDRESS,
1245	saddr: (u16)reg->reg, saddr_len: 2, data: &data, data_len: 1);
1246	reg->val = data;
1247	reg->size = 1;
1248	break;
1249	case 2: /* Video Block - read byte */
1250	ret = cx231xx_read_i2c_data(dev, VID_BLK_I2C_ADDRESS,
1251	saddr: (u16)reg->reg, saddr_len: 2, data: &data, data_len: 1);
1252	reg->val = data;
1253	reg->size = 1;
1254	break;
1255	case 3: /* I2S block - read byte */
1256	ret = cx231xx_read_i2c_data(dev, I2S_BLK_DEVICE_ADDRESS,
1257	saddr: (u16)reg->reg, saddr_len: 1, data: &data, data_len: 1);
1258	reg->val = data;
1259	reg->size = 1;
1260	break;
1261	case 4: /* AFE - read dword */
1262	ret = cx231xx_read_i2c_data(dev, AFE_DEVICE_ADDRESS,
1263	saddr: (u16)reg->reg, saddr_len: 2, data: &data, data_len: 4);
1264	reg->val = data;
1265	reg->size = 4;
1266	break;
1267	case 5: /* Video Block - read dword */
1268	ret = cx231xx_read_i2c_data(dev, VID_BLK_I2C_ADDRESS,
1269	saddr: (u16)reg->reg, saddr_len: 2, data: &data, data_len: 4);
1270	reg->val = data;
1271	reg->size = 4;
1272	break;
1273	case 6: /* I2S Block - read dword */
1274	ret = cx231xx_read_i2c_data(dev, I2S_BLK_DEVICE_ADDRESS,
1275	saddr: (u16)reg->reg, saddr_len: 1, data: &data, data_len: 4);
1276	reg->val = data;
1277	reg->size = 4;
1278	break;
1279	default:
1280	return -EINVAL;
1281	}
1282	return ret < 0 ? ret : 0;
1283	}
1284
1285	int cx231xx_s_register(struct file *file, void *priv,
1286	const struct v4l2_dbg_register *reg)
1287	{
1288	struct cx231xx *dev = video_drvdata(file);
1289	int ret;
1290	u8 data[4] = { 0, 0, 0, 0 };
1291
1292	switch (reg->match.addr) {
1293	case 0: /* cx231xx internal registers */
1294	data[0] = (u8) reg->val;
1295	data[1] = (u8) (reg->val >> 8);
1296	data[2] = (u8) (reg->val >> 16);
1297	data[3] = (u8) (reg->val >> 24);
1298	ret = cx231xx_write_ctrl_reg(dev, req: VRT_SET_REGISTER,
1299	reg: (u16)reg->reg, buf: data, len: 4);
1300	break;
1301	case 1: /* AFE - write byte */
1302	ret = cx231xx_write_i2c_data(dev, AFE_DEVICE_ADDRESS,
1303	saddr: (u16)reg->reg, saddr_len: 2, data: reg->val, data_len: 1);
1304	break;
1305	case 2: /* Video Block - write byte */
1306	ret = cx231xx_write_i2c_data(dev, VID_BLK_I2C_ADDRESS,
1307	saddr: (u16)reg->reg, saddr_len: 2, data: reg->val, data_len: 1);
1308	break;
1309	case 3: /* I2S block - write byte */
1310	ret = cx231xx_write_i2c_data(dev, I2S_BLK_DEVICE_ADDRESS,
1311	saddr: (u16)reg->reg, saddr_len: 1, data: reg->val, data_len: 1);
1312	break;
1313	case 4: /* AFE - write dword */
1314	ret = cx231xx_write_i2c_data(dev, AFE_DEVICE_ADDRESS,
1315	saddr: (u16)reg->reg, saddr_len: 2, data: reg->val, data_len: 4);
1316	break;
1317	case 5: /* Video Block - write dword */
1318	ret = cx231xx_write_i2c_data(dev, VID_BLK_I2C_ADDRESS,
1319	saddr: (u16)reg->reg, saddr_len: 2, data: reg->val, data_len: 4);
1320	break;
1321	case 6: /* I2S block - write dword */
1322	ret = cx231xx_write_i2c_data(dev, I2S_BLK_DEVICE_ADDRESS,
1323	saddr: (u16)reg->reg, saddr_len: 1, data: reg->val, data_len: 4);
1324	break;
1325	default:
1326	return -EINVAL;
1327	}
1328	return ret < 0 ? ret : 0;
1329	}
1330	#endif
1331
1332	static int vidioc_g_pixelaspect(struct file *file, void *priv,
1333	int type, struct v4l2_fract *f)
1334	{
1335	struct cx231xx *dev = video_drvdata(file);
1336	bool is_50hz = dev->norm & V4L2_STD_625_50;
1337
1338	if (type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1339	return -EINVAL;
1340
1341	f->numerator = is_50hz ? 54 : 11;
1342	f->denominator = is_50hz ? 59 : 10;
1343
1344	return 0;
1345	}
1346
1347	static int vidioc_g_selection(struct file *file, void *priv,
1348	struct v4l2_selection *s)
1349	{
1350	struct cx231xx *dev = video_drvdata(file);
1351
1352	if (s->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1353	return -EINVAL;
1354
1355	switch (s->target) {
1356	case V4L2_SEL_TGT_CROP_BOUNDS:
1357	case V4L2_SEL_TGT_CROP_DEFAULT:
1358	s->r.left = 0;
1359	s->r.top = 0;
1360	s->r.width = dev->width;
1361	s->r.height = dev->height;
1362	break;
1363	default:
1364	return -EINVAL;
1365	}
1366	return 0;
1367	}
1368
1369	int cx231xx_querycap(struct file *file, void *priv,
1370	struct v4l2_capability *cap)
1371	{
1372	struct cx231xx *dev = video_drvdata(file);
1373
1374	strscpy(cap->driver, "cx231xx", sizeof(cap->driver));
1375	strscpy(cap->card, cx231xx_boards[dev->model].name, sizeof(cap->card));
1376	usb_make_path(dev: dev->udev, buf: cap->bus_info, size: sizeof(cap->bus_info));
1377	cap->capabilities = V4L2_CAP_READWRITE |
1378	V4L2_CAP_VBI_CAPTURE | V4L2_CAP_VIDEO_CAPTURE |
1379	V4L2_CAP_STREAMING | V4L2_CAP_DEVICE_CAPS;
1380	if (video_is_registered(vdev: &dev->radio_dev))
1381	cap->capabilities |= V4L2_CAP_RADIO;
1382
1383	switch (dev->model) {
1384	case CX231XX_BOARD_HAUPPAUGE_930C_HD_1114xx:
1385	case CX231XX_BOARD_HAUPPAUGE_935C:
1386	case CX231XX_BOARD_HAUPPAUGE_955Q:
1387	case CX231XX_BOARD_HAUPPAUGE_975:
1388	case CX231XX_BOARD_EVROMEDIA_FULL_HYBRID_FULLHD:
1389	cap->capabilities |= V4L2_CAP_TUNER;
1390	break;
1391	default:
1392	if (dev->tuner_type != TUNER_ABSENT)
1393	cap->capabilities |= V4L2_CAP_TUNER;
1394	break;
1395	}
1396	return 0;
1397	}
1398
1399	static int vidioc_enum_fmt_vid_cap(struct file *file, void *priv,
1400	struct v4l2_fmtdesc *f)
1401	{
1402	if (unlikely(f->index >= ARRAY_SIZE(format)))
1403	return -EINVAL;
1404
1405	f->pixelformat = format[f->index].fourcc;
1406
1407	return 0;
1408	}
1409
1410	/* RAW VBI ioctls */
1411
1412	static int vidioc_g_fmt_vbi_cap(struct file *file, void *priv,
1413	struct v4l2_format *f)
1414	{
1415	struct cx231xx *dev = video_drvdata(file);
1416
1417	f->fmt.vbi.sampling_rate = 6750000 * 4;
1418	f->fmt.vbi.samples_per_line = VBI_LINE_LENGTH;
1419	f->fmt.vbi.sample_format = V4L2_PIX_FMT_GREY;
1420	f->fmt.vbi.offset = 0;
1421	f->fmt.vbi.start[0] = (dev->norm & V4L2_STD_625_50) ?
1422	PAL_VBI_START_LINE : NTSC_VBI_START_LINE;
1423	f->fmt.vbi.count[0] = (dev->norm & V4L2_STD_625_50) ?
1424	PAL_VBI_LINES : NTSC_VBI_LINES;
1425	f->fmt.vbi.start[1] = (dev->norm & V4L2_STD_625_50) ?
1426	PAL_VBI_START_LINE + 312 : NTSC_VBI_START_LINE + 263;
1427	f->fmt.vbi.count[1] = f->fmt.vbi.count[0];
1428	memset(f->fmt.vbi.reserved, 0, sizeof(f->fmt.vbi.reserved));
1429
1430	return 0;
1431
1432	}
1433
1434	static int vidioc_try_fmt_vbi_cap(struct file *file, void *priv,
1435	struct v4l2_format *f)
1436	{
1437	struct cx231xx *dev = video_drvdata(file);
1438
1439	f->fmt.vbi.sampling_rate = 6750000 * 4;
1440	f->fmt.vbi.samples_per_line = VBI_LINE_LENGTH;
1441	f->fmt.vbi.sample_format = V4L2_PIX_FMT_GREY;
1442	f->fmt.vbi.offset = 0;
1443	f->fmt.vbi.flags = 0;
1444	f->fmt.vbi.start[0] = (dev->norm & V4L2_STD_625_50) ?
1445	PAL_VBI_START_LINE : NTSC_VBI_START_LINE;
1446	f->fmt.vbi.count[0] = (dev->norm & V4L2_STD_625_50) ?
1447	PAL_VBI_LINES : NTSC_VBI_LINES;
1448	f->fmt.vbi.start[1] = (dev->norm & V4L2_STD_625_50) ?
1449	PAL_VBI_START_LINE + 312 : NTSC_VBI_START_LINE + 263;
1450	f->fmt.vbi.count[1] = f->fmt.vbi.count[0];
1451	memset(f->fmt.vbi.reserved, 0, sizeof(f->fmt.vbi.reserved));
1452
1453	return 0;
1454
1455	}
1456
1457	static int vidioc_s_fmt_vbi_cap(struct file *file, void *priv,
1458	struct v4l2_format *f)
1459	{
1460	return vidioc_try_fmt_vbi_cap(file, priv, f);
1461	}
1462
1463	/* ----------------------------------------------------------- */
1464	/* RADIO ESPECIFIC IOCTLS */
1465	/* ----------------------------------------------------------- */
1466
1467	static int radio_g_tuner(struct file *file, void *priv, struct v4l2_tuner *t)
1468	{
1469	struct cx231xx *dev = video_drvdata(file);
1470
1471	if (t->index)
1472	return -EINVAL;
1473
1474	strscpy(t->name, "Radio", sizeof(t->name));
1475
1476	call_all(dev, tuner, g_tuner, t);
1477
1478	return 0;
1479	}
1480	static int radio_s_tuner(struct file *file, void *priv, const struct v4l2_tuner *t)
1481	{
1482	struct cx231xx *dev = video_drvdata(file);
1483
1484	if (t->index)
1485	return -EINVAL;
1486
1487	call_all(dev, tuner, s_tuner, t);
1488
1489	return 0;
1490	}
1491
1492	/*
1493	* cx231xx_v4l2_open()
1494	* inits the device and starts isoc transfer
1495	*/
1496	static int cx231xx_v4l2_open(struct file *filp)
1497	{
1498	struct video_device *vdev = video_devdata(file: filp);
1499	struct cx231xx *dev = video_drvdata(file: filp);
1500	int ret;
1501
1502	if (mutex_lock_interruptible(&dev->lock))
1503	return -ERESTARTSYS;
1504
1505	ret = v4l2_fh_open(filp);
1506	if (ret) {
1507	mutex_unlock(lock: &dev->lock);
1508	return ret;
1509	}
1510
1511	if (dev->users++ == 0) {
1512	/* Power up in Analog TV mode */
1513	if (dev->board.external_av)
1514	cx231xx_set_power_mode(dev,
1515	mode: POLARIS_AVMODE_ENXTERNAL_AV);
1516	else
1517	cx231xx_set_power_mode(dev, mode: POLARIS_AVMODE_ANALOGT_TV);
1518
1519	/* set video alternate setting */
1520	cx231xx_set_video_alternate(dev);
1521
1522	/* Needed, since GPIO might have disabled power of
1523	some i2c device */
1524	cx231xx_config_i2c(dev);
1525
1526	/* device needs to be initialized before isoc transfer */
1527	dev->video_input = dev->video_input > 2 ? 2 : dev->video_input;
1528	}
1529
1530	if (vdev->vfl_type == VFL_TYPE_RADIO) {
1531	cx231xx_videodbg("video_open: setting radio device\n");
1532
1533	/* cx231xx_start_radio(dev); */
1534
1535	call_all(dev, tuner, s_radio);
1536	}
1537	if (vdev->vfl_type == VFL_TYPE_VBI) {
1538	/* Set the required alternate setting VBI interface works in
1539	Bulk mode only */
1540	cx231xx_set_alt_setting(dev, index: INDEX_VANC, alt: 0);
1541	}
1542	mutex_unlock(lock: &dev->lock);
1543	return 0;
1544	}
1545
1546	/*
1547	* cx231xx_realease_resources()
1548	* unregisters the v4l2,i2c and usb devices
1549	* called when the device gets disconnected or at module unload
1550	*/
1551	void cx231xx_release_analog_resources(struct cx231xx *dev)
1552	{
1553
1554	/*FIXME: I2C IR should be disconnected */
1555
1556	if (video_is_registered(vdev: &dev->radio_dev))
1557	video_unregister_device(vdev: &dev->radio_dev);
1558	if (video_is_registered(vdev: &dev->vbi_dev)) {
1559	dev_info(dev->dev, "V4L2 device %s deregistered\n",
1560	video_device_node_name(&dev->vbi_dev));
1561	video_unregister_device(vdev: &dev->vbi_dev);
1562	}
1563	if (video_is_registered(vdev: &dev->vdev)) {
1564	dev_info(dev->dev, "V4L2 device %s deregistered\n",
1565	video_device_node_name(&dev->vdev));
1566
1567	if (dev->board.has_417)
1568	cx231xx_417_unregister(dev);
1569
1570	video_unregister_device(vdev: &dev->vdev);
1571	}
1572	v4l2_ctrl_handler_free(hdl: &dev->ctrl_handler);
1573	v4l2_ctrl_handler_free(hdl: &dev->radio_ctrl_handler);
1574	}
1575
1576	/*
1577	* cx231xx_close()
1578	* stops streaming and deallocates all resources allocated by the v4l2
1579	* calls and ioctls
1580	*/
1581	static int cx231xx_close(struct file *filp)
1582	{
1583	struct cx231xx *dev = video_drvdata(file: filp);
1584	struct video_device *vdev = video_devdata(file: filp);
1585
1586	_vb2_fop_release(file: filp, NULL);
1587
1588	if (--dev->users == 0) {
1589	/* Save some power by putting tuner to sleep */
1590	call_all(dev, tuner, standby);
1591
1592	/* do this before setting alternate! */
1593	if (dev->USE_ISO)
1594	cx231xx_uninit_isoc(dev);
1595	else
1596	cx231xx_uninit_bulk(dev);
1597	cx231xx_set_mode(dev, set_mode: CX231XX_SUSPEND);
1598	}
1599
1600	/*
1601	* To workaround error number=-71 on EP0 for VideoGrabber,
1602	* need exclude following.
1603	* FIXME: It is probably safe to remove most of these, as we're
1604	* now avoiding the alternate setting for INDEX_VANC
1605	*/
1606	if (!dev->board.no_alt_vanc && vdev->vfl_type == VFL_TYPE_VBI) {
1607	/* do this before setting alternate! */
1608	cx231xx_uninit_vbi_isoc(dev);
1609
1610	/* set alternate 0 */
1611	if (!dev->vbi_or_sliced_cc_mode)
1612	cx231xx_set_alt_setting(dev, index: INDEX_VANC, alt: 0);
1613	else
1614	cx231xx_set_alt_setting(dev, index: INDEX_HANC, alt: 0);
1615
1616	wake_up_interruptible_nr(&dev->open, 1);
1617	return 0;
1618	}
1619
1620	if (dev->users == 0) {
1621	/* set alternate 0 */
1622	cx231xx_set_alt_setting(dev, index: INDEX_VIDEO, alt: 0);
1623	}
1624
1625	wake_up_interruptible(&dev->open);
1626	return 0;
1627	}
1628
1629	static int cx231xx_v4l2_close(struct file *filp)
1630	{
1631	struct cx231xx *dev = video_drvdata(file: filp);
1632	int rc;
1633
1634	mutex_lock(&dev->lock);
1635	rc = cx231xx_close(filp);
1636	mutex_unlock(lock: &dev->lock);
1637	return rc;
1638	}
1639
1640	static const struct v4l2_file_operations cx231xx_v4l_fops = {
1641	.owner = THIS_MODULE,
1642	.open = cx231xx_v4l2_open,
1643	.release = cx231xx_v4l2_close,
1644	.read = vb2_fop_read,
1645	.poll = vb2_fop_poll,
1646	.mmap = vb2_fop_mmap,
1647	.unlocked_ioctl = video_ioctl2,
1648	};
1649
1650	static const struct v4l2_ioctl_ops video_ioctl_ops = {
1651	.vidioc_querycap = cx231xx_querycap,
1652	.vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid_cap,
1653	.vidioc_g_fmt_vid_cap = vidioc_g_fmt_vid_cap,
1654	.vidioc_try_fmt_vid_cap = vidioc_try_fmt_vid_cap,
1655	.vidioc_s_fmt_vid_cap = vidioc_s_fmt_vid_cap,
1656	.vidioc_g_fmt_vbi_cap = vidioc_g_fmt_vbi_cap,
1657	.vidioc_try_fmt_vbi_cap = vidioc_try_fmt_vbi_cap,
1658	.vidioc_s_fmt_vbi_cap = vidioc_s_fmt_vbi_cap,
1659	.vidioc_g_pixelaspect = vidioc_g_pixelaspect,
1660	.vidioc_g_selection = vidioc_g_selection,
1661	.vidioc_reqbufs = vb2_ioctl_reqbufs,
1662	.vidioc_querybuf = vb2_ioctl_querybuf,
1663	.vidioc_qbuf = vb2_ioctl_qbuf,
1664	.vidioc_dqbuf = vb2_ioctl_dqbuf,
1665	.vidioc_s_std = vidioc_s_std,
1666	.vidioc_g_std = vidioc_g_std,
1667	.vidioc_enum_input = cx231xx_enum_input,
1668	.vidioc_g_input = cx231xx_g_input,
1669	.vidioc_s_input = cx231xx_s_input,
1670	.vidioc_streamon = vb2_ioctl_streamon,
1671	.vidioc_streamoff = vb2_ioctl_streamoff,
1672	.vidioc_g_tuner = cx231xx_g_tuner,
1673	.vidioc_s_tuner = cx231xx_s_tuner,
1674	.vidioc_g_frequency = cx231xx_g_frequency,
1675	.vidioc_s_frequency = cx231xx_s_frequency,
1676	#ifdef CONFIG_VIDEO_ADV_DEBUG
1677	.vidioc_g_chip_info = cx231xx_g_chip_info,
1678	.vidioc_g_register = cx231xx_g_register,
1679	.vidioc_s_register = cx231xx_s_register,
1680	#endif
1681	.vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
1682	.vidioc_unsubscribe_event = v4l2_event_unsubscribe,
1683	};
1684
1685	static struct video_device cx231xx_vbi_template;
1686
1687	static const struct video_device cx231xx_video_template = {
1688	.fops = &cx231xx_v4l_fops,
1689	.release = video_device_release_empty,
1690	.ioctl_ops = &video_ioctl_ops,
1691	.tvnorms = V4L2_STD_ALL,
1692	};
1693
1694	static const struct v4l2_file_operations radio_fops = {
1695	.owner = THIS_MODULE,
1696	.open = cx231xx_v4l2_open,
1697	.release = cx231xx_v4l2_close,
1698	.poll = v4l2_ctrl_poll,
1699	.unlocked_ioctl = video_ioctl2,
1700	};
1701
1702	static const struct v4l2_ioctl_ops radio_ioctl_ops = {
1703	.vidioc_querycap = cx231xx_querycap,
1704	.vidioc_g_tuner = radio_g_tuner,
1705	.vidioc_s_tuner = radio_s_tuner,
1706	.vidioc_g_frequency = cx231xx_g_frequency,
1707	.vidioc_s_frequency = cx231xx_s_frequency,
1708	#ifdef CONFIG_VIDEO_ADV_DEBUG
1709	.vidioc_g_chip_info = cx231xx_g_chip_info,
1710	.vidioc_g_register = cx231xx_g_register,
1711	.vidioc_s_register = cx231xx_s_register,
1712	#endif
1713	.vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
1714	.vidioc_unsubscribe_event = v4l2_event_unsubscribe,
1715	};
1716
1717	static struct video_device cx231xx_radio_template = {
1718	.name = "cx231xx-radio",
1719	.fops = &radio_fops,
1720	.ioctl_ops = &radio_ioctl_ops,
1721	};
1722
1723	/******************************** usb interface ******************************/
1724
1725	static void cx231xx_vdev_init(struct cx231xx *dev,
1726	struct video_device *vfd,
1727	const struct video_device *template,
1728	const char *type_name)
1729	{
1730	*vfd = *template;
1731	vfd->v4l2_dev = &dev->v4l2_dev;
1732	vfd->release = video_device_release_empty;
1733	vfd->lock = &dev->lock;
1734
1735	snprintf(buf: vfd->name, size: sizeof(vfd->name), fmt: "%s %s", dev->name, type_name);
1736
1737	video_set_drvdata(vdev: vfd, data: dev);
1738	if (dev->tuner_type == TUNER_ABSENT) {
1739	switch (dev->model) {
1740	case CX231XX_BOARD_HAUPPAUGE_930C_HD_1114xx:
1741	case CX231XX_BOARD_HAUPPAUGE_935C:
1742	case CX231XX_BOARD_HAUPPAUGE_955Q:
1743	case CX231XX_BOARD_HAUPPAUGE_975:
1744	case CX231XX_BOARD_EVROMEDIA_FULL_HYBRID_FULLHD:
1745	break;
1746	default:
1747	v4l2_disable_ioctl(vdev: vfd, VIDIOC_G_FREQUENCY);
1748	v4l2_disable_ioctl(vdev: vfd, VIDIOC_S_FREQUENCY);
1749	v4l2_disable_ioctl(vdev: vfd, VIDIOC_G_TUNER);
1750	v4l2_disable_ioctl(vdev: vfd, VIDIOC_S_TUNER);
1751	break;
1752	}
1753	}
1754	}
1755
1756	int cx231xx_register_analog_devices(struct cx231xx *dev)
1757	{
1758	struct vb2_queue *q;
1759	int ret;
1760
1761	dev_info(dev->dev, "v4l2 driver version %s\n", CX231XX_VERSION);
1762
1763	/* set default norm */
1764	dev->norm = V4L2_STD_PAL;
1765	dev->width = norm_maxw(dev);
1766	dev->height = norm_maxh(dev);
1767	dev->interlaced = 0;
1768
1769	/* Analog specific initialization */
1770	dev->format = &format[0];
1771
1772	/* Set the initial input */
1773	video_mux(dev, index: dev->video_input);
1774
1775	call_all(dev, video, s_std, dev->norm);
1776
1777	v4l2_ctrl_handler_init(&dev->ctrl_handler, 10);
1778	v4l2_ctrl_handler_init(&dev->radio_ctrl_handler, 5);
1779
1780	if (dev->sd_cx25840) {
1781	v4l2_ctrl_add_handler(hdl: &dev->ctrl_handler,
1782	add: dev->sd_cx25840->ctrl_handler, NULL, from_other_dev: true);
1783	v4l2_ctrl_add_handler(hdl: &dev->radio_ctrl_handler,
1784	add: dev->sd_cx25840->ctrl_handler,
1785	filter: v4l2_ctrl_radio_filter, from_other_dev: true);
1786	}
1787
1788	if (dev->ctrl_handler.error)
1789	return dev->ctrl_handler.error;
1790	if (dev->radio_ctrl_handler.error)
1791	return dev->radio_ctrl_handler.error;
1792
1793	/* enable vbi capturing */
1794	/* write code here... */
1795
1796	/* allocate and fill video video_device struct */
1797	cx231xx_vdev_init(dev, vfd: &dev->vdev, template: &cx231xx_video_template, type_name: "video");
1798	#if defined(CONFIG_MEDIA_CONTROLLER)
1799	dev->video_pad.flags = MEDIA_PAD_FL_SINK;
1800	ret = media_entity_pads_init(entity: &dev->vdev.entity, num_pads: 1, pads: &dev->video_pad);
1801	if (ret < 0)
1802	dev_err(dev->dev, "failed to initialize video media entity!\n");
1803	#endif
1804	dev->vdev.ctrl_handler = &dev->ctrl_handler;
1805
1806	q = &dev->vidq;
1807	q->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1808	q->io_modes = VB2_USERPTR | VB2_MMAP | VB2_DMABUF | VB2_READ;
1809	q->drv_priv = dev;
1810	q->buf_struct_size = sizeof(struct cx231xx_buffer);
1811	q->ops = &cx231xx_video_qops;
1812	q->mem_ops = &vb2_vmalloc_memops;
1813	q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1814	q->min_queued_buffers = 1;
1815	q->lock = &dev->lock;
1816	ret = vb2_queue_init(q);
1817	if (ret)
1818	return ret;
1819	dev->vdev.queue = q;
1820	dev->vdev.device_caps = V4L2_CAP_READWRITE | V4L2_CAP_STREAMING |
1821	V4L2_CAP_VIDEO_CAPTURE;
1822
1823	switch (dev->model) { /* i2c device tuners */
1824	case CX231XX_BOARD_HAUPPAUGE_930C_HD_1114xx:
1825	case CX231XX_BOARD_HAUPPAUGE_935C:
1826	case CX231XX_BOARD_HAUPPAUGE_955Q:
1827	case CX231XX_BOARD_HAUPPAUGE_975:
1828	case CX231XX_BOARD_EVROMEDIA_FULL_HYBRID_FULLHD:
1829	dev->vdev.device_caps |= V4L2_CAP_TUNER;
1830	break;
1831	default:
1832	if (dev->tuner_type != TUNER_ABSENT)
1833	dev->vdev.device_caps |= V4L2_CAP_TUNER;
1834	break;
1835	}
1836
1837	/* register v4l2 video video_device */
1838	ret = video_register_device(vdev: &dev->vdev, type: VFL_TYPE_VIDEO,
1839	nr: video_nr[dev->devno]);
1840	if (ret) {
1841	dev_err(dev->dev,
1842	"unable to register video device (error=%i).\n",
1843	ret);
1844	return ret;
1845	}
1846
1847	dev_info(dev->dev, "Registered video device %s [v4l2]\n",
1848	video_device_node_name(&dev->vdev));
1849
1850	/* Initialize VBI template */
1851	cx231xx_vbi_template = cx231xx_video_template;
1852	strscpy(cx231xx_vbi_template.name, "cx231xx-vbi",
1853	sizeof(cx231xx_vbi_template.name));
1854
1855	/* Allocate and fill vbi video_device struct */
1856	cx231xx_vdev_init(dev, vfd: &dev->vbi_dev, template: &cx231xx_vbi_template, type_name: "vbi");
1857
1858	#if defined(CONFIG_MEDIA_CONTROLLER)
1859	dev->vbi_pad.flags = MEDIA_PAD_FL_SINK;
1860	ret = media_entity_pads_init(entity: &dev->vbi_dev.entity, num_pads: 1, pads: &dev->vbi_pad);
1861	if (ret < 0)
1862	dev_err(dev->dev, "failed to initialize vbi media entity!\n");
1863	#endif
1864	dev->vbi_dev.ctrl_handler = &dev->ctrl_handler;
1865
1866	q = &dev->vbiq;
1867	q->type = V4L2_BUF_TYPE_VBI_CAPTURE;
1868	q->io_modes = VB2_USERPTR | VB2_MMAP | VB2_DMABUF | VB2_READ;
1869	q->drv_priv = dev;
1870	q->buf_struct_size = sizeof(struct cx231xx_buffer);
1871	q->ops = &cx231xx_vbi_qops;
1872	q->mem_ops = &vb2_vmalloc_memops;
1873	q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1874	q->min_queued_buffers = 1;
1875	q->lock = &dev->lock;
1876	ret = vb2_queue_init(q);
1877	if (ret)
1878	return ret;
1879	dev->vbi_dev.queue = q;
1880	dev->vbi_dev.device_caps = V4L2_CAP_READWRITE | V4L2_CAP_STREAMING |
1881	V4L2_CAP_VBI_CAPTURE;
1882	switch (dev->model) { /* i2c device tuners */
1883	case CX231XX_BOARD_HAUPPAUGE_930C_HD_1114xx:
1884	case CX231XX_BOARD_HAUPPAUGE_935C:
1885	case CX231XX_BOARD_HAUPPAUGE_955Q:
1886	case CX231XX_BOARD_HAUPPAUGE_975:
1887	case CX231XX_BOARD_EVROMEDIA_FULL_HYBRID_FULLHD:
1888	dev->vbi_dev.device_caps |= V4L2_CAP_TUNER;
1889	break;
1890	default:
1891	if (dev->tuner_type != TUNER_ABSENT)
1892	dev->vbi_dev.device_caps |= V4L2_CAP_TUNER;
1893	}
1894
1895	/* register v4l2 vbi video_device */
1896	ret = video_register_device(vdev: &dev->vbi_dev, type: VFL_TYPE_VBI,
1897	nr: vbi_nr[dev->devno]);
1898	if (ret < 0) {
1899	dev_err(dev->dev, "unable to register vbi device\n");
1900	return ret;
1901	}
1902
1903	dev_info(dev->dev, "Registered VBI device %s\n",
1904	video_device_node_name(&dev->vbi_dev));
1905
1906	if (cx231xx_boards[dev->model].radio.type == CX231XX_RADIO) {
1907	cx231xx_vdev_init(dev, vfd: &dev->radio_dev,
1908	template: &cx231xx_radio_template, type_name: "radio");
1909	dev->radio_dev.ctrl_handler = &dev->radio_ctrl_handler;
1910	dev->radio_dev.device_caps = V4L2_CAP_RADIO | V4L2_CAP_TUNER;
1911	ret = video_register_device(vdev: &dev->radio_dev, type: VFL_TYPE_RADIO,
1912	nr: radio_nr[dev->devno]);
1913	if (ret < 0) {
1914	dev_err(dev->dev,
1915	"can't register radio device\n");
1916	return ret;
1917	}
1918	dev_info(dev->dev, "Registered radio device as %s\n",
1919	video_device_node_name(&dev->radio_dev));
1920	}
1921
1922	return 0;
1923	}
1924