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