1 /*
2    em28xx-video.c - driver for Empia EM2800/EM2820/2840 USB
3 		    video capture devices
4 
5    Copyright (C) 2005 Ludovico Cavedon <cavedon@sssup.it>
6 		      Markus Rechberger <mrechberger@gmail.com>
7 		      Mauro Carvalho Chehab <mchehab@infradead.org>
8 		      Sascha Sommer <saschasommer@freenet.de>
9    Copyright (C) 2012 Frank Schäfer <fschaefer.oss@googlemail.com>
10 
11 	Some parts based on SN9C10x PC Camera Controllers GPL driver made
12 		by Luca Risolia <luca.risolia@studio.unibo.it>
13 
14    This program is free software; you can redistribute it and/or modify
15    it under the terms of the GNU General Public License as published by
16    the Free Software Foundation; either version 2 of the License, or
17    (at your option) any later version.
18 
19    This program is distributed in the hope that it will be useful,
20    but WITHOUT ANY WARRANTY; without even the implied warranty of
21    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
22    GNU General Public License for more details.
23 
24    You should have received a copy of the GNU General Public License
25    along with this program; if not, write to the Free Software
26    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
27  */
28 
29 #include "em28xx.h"
30 
31 #include <linux/init.h>
32 #include <linux/list.h>
33 #include <linux/module.h>
34 #include <linux/kernel.h>
35 #include <linux/bitmap.h>
36 #include <linux/usb.h>
37 #include <linux/i2c.h>
38 #include <linux/mm.h>
39 #include <linux/mutex.h>
40 #include <linux/slab.h>
41 
42 #include "em28xx-v4l.h"
43 #include <media/v4l2-common.h>
44 #include <media/v4l2-ioctl.h>
45 #include <media/v4l2-event.h>
46 #include <media/drv-intf/msp3400.h>
47 #include <media/tuner.h>
48 
49 #define DRIVER_AUTHOR "Ludovico Cavedon <cavedon@sssup.it>, " \
50 		      "Markus Rechberger <mrechberger@gmail.com>, " \
51 		      "Mauro Carvalho Chehab <mchehab@infradead.org>, " \
52 		      "Sascha Sommer <saschasommer@freenet.de>"
53 
54 static unsigned int isoc_debug;
55 module_param(isoc_debug, int, 0644);
56 MODULE_PARM_DESC(isoc_debug, "enable debug messages [isoc transfers]");
57 
58 static unsigned int disable_vbi;
59 module_param(disable_vbi, int, 0644);
60 MODULE_PARM_DESC(disable_vbi, "disable vbi support");
61 
62 static int alt;
63 module_param(alt, int, 0644);
64 MODULE_PARM_DESC(alt, "alternate setting to use for video endpoint");
65 
66 #define em28xx_videodbg(fmt, arg...) do {				\
67 	if (video_debug)						\
68 		dev_printk(KERN_DEBUG, &dev->intf->dev,			\
69 			   "video: %s: " fmt, __func__, ## arg);	\
70 } while (0)
71 
72 #define em28xx_isocdbg(fmt, arg...) do {\
73 	if (isoc_debug) \
74 		dev_printk(KERN_DEBUG, &dev->intf->dev,			\
75 			   "isoc: %s: " fmt, __func__, ## arg);		\
76 } while (0)
77 
78 MODULE_AUTHOR(DRIVER_AUTHOR);
79 MODULE_DESCRIPTION(DRIVER_DESC " - v4l2 interface");
80 MODULE_LICENSE("GPL");
81 MODULE_VERSION(EM28XX_VERSION);
82 
83 #define EM25XX_FRMDATAHDR_BYTE1			0x02
84 #define EM25XX_FRMDATAHDR_BYTE2_STILL_IMAGE	0x20
85 #define EM25XX_FRMDATAHDR_BYTE2_FRAME_END	0x02
86 #define EM25XX_FRMDATAHDR_BYTE2_FRAME_ID	0x01
87 #define EM25XX_FRMDATAHDR_BYTE2_MASK	(EM25XX_FRMDATAHDR_BYTE2_STILL_IMAGE | \
88 					 EM25XX_FRMDATAHDR_BYTE2_FRAME_END |   \
89 					 EM25XX_FRMDATAHDR_BYTE2_FRAME_ID)
90 
91 static unsigned int video_nr[] = {[0 ... (EM28XX_MAXBOARDS - 1)] = -1U };
92 static unsigned int vbi_nr[]   = {[0 ... (EM28XX_MAXBOARDS - 1)] = -1U };
93 static unsigned int radio_nr[] = {[0 ... (EM28XX_MAXBOARDS - 1)] = -1U };
94 
95 module_param_array(video_nr, int, NULL, 0444);
96 module_param_array(vbi_nr, int, NULL, 0444);
97 module_param_array(radio_nr, int, NULL, 0444);
98 MODULE_PARM_DESC(video_nr, "video device numbers");
99 MODULE_PARM_DESC(vbi_nr,   "vbi device numbers");
100 MODULE_PARM_DESC(radio_nr, "radio device numbers");
101 
102 static unsigned int video_debug;
103 module_param(video_debug, int, 0644);
104 MODULE_PARM_DESC(video_debug, "enable debug messages [video]");
105 
106 /* supported video standards */
107 static struct em28xx_fmt format[] = {
108 	{
109 		.name     = "16 bpp YUY2, 4:2:2, packed",
110 		.fourcc   = V4L2_PIX_FMT_YUYV,
111 		.depth    = 16,
112 		.reg	  = EM28XX_OUTFMT_YUV422_Y0UY1V,
113 	}, {
114 		.name     = "16 bpp RGB 565, LE",
115 		.fourcc   = V4L2_PIX_FMT_RGB565,
116 		.depth    = 16,
117 		.reg      = EM28XX_OUTFMT_RGB_16_656,
118 	}, {
119 		.name     = "8 bpp Bayer RGRG..GBGB",
120 		.fourcc   = V4L2_PIX_FMT_SRGGB8,
121 		.depth    = 8,
122 		.reg      = EM28XX_OUTFMT_RGB_8_RGRG,
123 	}, {
124 		.name     = "8 bpp Bayer BGBG..GRGR",
125 		.fourcc   = V4L2_PIX_FMT_SBGGR8,
126 		.depth    = 8,
127 		.reg      = EM28XX_OUTFMT_RGB_8_BGBG,
128 	}, {
129 		.name     = "8 bpp Bayer GRGR..BGBG",
130 		.fourcc   = V4L2_PIX_FMT_SGRBG8,
131 		.depth    = 8,
132 		.reg      = EM28XX_OUTFMT_RGB_8_GRGR,
133 	}, {
134 		.name     = "8 bpp Bayer GBGB..RGRG",
135 		.fourcc   = V4L2_PIX_FMT_SGBRG8,
136 		.depth    = 8,
137 		.reg      = EM28XX_OUTFMT_RGB_8_GBGB,
138 	}, {
139 		.name     = "12 bpp YUV411",
140 		.fourcc   = V4L2_PIX_FMT_YUV411P,
141 		.depth    = 12,
142 		.reg      = EM28XX_OUTFMT_YUV411,
143 	},
144 };
145 
146 /*FIXME: maxw should be dependent of alt mode */
147 static inline unsigned int norm_maxw(struct em28xx *dev)
148 {
149 	struct em28xx_v4l2 *v4l2 = dev->v4l2;
150 
151 	if (dev->board.is_webcam)
152 		return v4l2->sensor_xres;
153 
154 	if (dev->board.max_range_640_480)
155 		return 640;
156 
157 	return 720;
158 }
159 
160 static inline unsigned int norm_maxh(struct em28xx *dev)
161 {
162 	struct em28xx_v4l2 *v4l2 = dev->v4l2;
163 
164 	if (dev->board.is_webcam)
165 		return v4l2->sensor_yres;
166 
167 	if (dev->board.max_range_640_480)
168 		return 480;
169 
170 	return (v4l2->norm & V4L2_STD_625_50) ? 576 : 480;
171 }
172 
173 static int em28xx_vbi_supported(struct em28xx *dev)
174 {
175 	/* Modprobe option to manually disable */
176 	if (disable_vbi == 1)
177 		return 0;
178 
179 	if (dev->board.is_webcam)
180 		return 0;
181 
182 	/* FIXME: check subdevices for VBI support */
183 
184 	if (dev->chip_id == CHIP_ID_EM2860 ||
185 	    dev->chip_id == CHIP_ID_EM2883)
186 		return 1;
187 
188 	/* Version of em28xx that does not support VBI */
189 	return 0;
190 }
191 
192 /*
193  * em28xx_wake_i2c()
194  * configure i2c attached devices
195  */
196 static void em28xx_wake_i2c(struct em28xx *dev)
197 {
198 	struct v4l2_device *v4l2_dev = &dev->v4l2->v4l2_dev;
199 
200 	v4l2_device_call_all(v4l2_dev, 0, core,  reset, 0);
201 	v4l2_device_call_all(v4l2_dev, 0, video, s_routing,
202 			     INPUT(dev->ctl_input)->vmux, 0, 0);
203 }
204 
205 static int em28xx_colorlevels_set_default(struct em28xx *dev)
206 {
207 	em28xx_write_reg(dev, EM28XX_R20_YGAIN, CONTRAST_DEFAULT);
208 	em28xx_write_reg(dev, EM28XX_R21_YOFFSET, BRIGHTNESS_DEFAULT);
209 	em28xx_write_reg(dev, EM28XX_R22_UVGAIN, SATURATION_DEFAULT);
210 	em28xx_write_reg(dev, EM28XX_R23_UOFFSET, BLUE_BALANCE_DEFAULT);
211 	em28xx_write_reg(dev, EM28XX_R24_VOFFSET, RED_BALANCE_DEFAULT);
212 	em28xx_write_reg(dev, EM28XX_R25_SHARPNESS, SHARPNESS_DEFAULT);
213 
214 	em28xx_write_reg(dev, EM28XX_R14_GAMMA, 0x20);
215 	em28xx_write_reg(dev, EM28XX_R15_RGAIN, 0x20);
216 	em28xx_write_reg(dev, EM28XX_R16_GGAIN, 0x20);
217 	em28xx_write_reg(dev, EM28XX_R17_BGAIN, 0x20);
218 	em28xx_write_reg(dev, EM28XX_R18_ROFFSET, 0x00);
219 	em28xx_write_reg(dev, EM28XX_R19_GOFFSET, 0x00);
220 	return em28xx_write_reg(dev, EM28XX_R1A_BOFFSET, 0x00);
221 }
222 
223 static int em28xx_set_outfmt(struct em28xx *dev)
224 {
225 	int ret;
226 	u8 fmt, vinctrl;
227 	struct em28xx_v4l2 *v4l2 = dev->v4l2;
228 
229 	fmt = v4l2->format->reg;
230 	if (!dev->is_em25xx)
231 		fmt |= 0x20;
232 	/*
233 	 * NOTE: it's not clear if this is really needed !
234 	 * The datasheets say bit 5 is a reserved bit and devices seem to work
235 	 * fine without it. But the Windows driver sets it for em2710/50+em28xx
236 	 * devices and we've always been setting it, too.
237 	 *
238 	 * em2765 (em25xx, em276x/7x/8x) devices do NOT work with this bit set,
239 	 * it's likely used for an additional (compressed ?) format there.
240 	 */
241 	ret = em28xx_write_reg(dev, EM28XX_R27_OUTFMT, fmt);
242 	if (ret < 0)
243 		return ret;
244 
245 	ret = em28xx_write_reg(dev, EM28XX_R10_VINMODE, v4l2->vinmode);
246 	if (ret < 0)
247 		return ret;
248 
249 	vinctrl = v4l2->vinctl;
250 	if (em28xx_vbi_supported(dev) == 1) {
251 		vinctrl |= EM28XX_VINCTRL_VBI_RAW;
252 		em28xx_write_reg(dev, EM28XX_R34_VBI_START_H, 0x00);
253 		em28xx_write_reg(dev, EM28XX_R36_VBI_WIDTH, v4l2->vbi_width/4);
254 		em28xx_write_reg(dev, EM28XX_R37_VBI_HEIGHT, v4l2->vbi_height);
255 		if (v4l2->norm & V4L2_STD_525_60) {
256 			/* NTSC */
257 			em28xx_write_reg(dev, EM28XX_R35_VBI_START_V, 0x09);
258 		} else if (v4l2->norm & V4L2_STD_625_50) {
259 			/* PAL */
260 			em28xx_write_reg(dev, EM28XX_R35_VBI_START_V, 0x07);
261 		}
262 	}
263 
264 	return em28xx_write_reg(dev, EM28XX_R11_VINCTRL, vinctrl);
265 }
266 
267 static int em28xx_accumulator_set(struct em28xx *dev, u8 xmin, u8 xmax,
268 				  u8 ymin, u8 ymax)
269 {
270 	em28xx_videodbg("em28xx Scale: (%d,%d)-(%d,%d)\n",
271 			xmin, ymin, xmax, ymax);
272 
273 	em28xx_write_regs(dev, EM28XX_R28_XMIN, &xmin, 1);
274 	em28xx_write_regs(dev, EM28XX_R29_XMAX, &xmax, 1);
275 	em28xx_write_regs(dev, EM28XX_R2A_YMIN, &ymin, 1);
276 	return em28xx_write_regs(dev, EM28XX_R2B_YMAX, &ymax, 1);
277 }
278 
279 static void em28xx_capture_area_set(struct em28xx *dev, u8 hstart, u8 vstart,
280 				    u16 width, u16 height)
281 {
282 	u8 cwidth = width >> 2;
283 	u8 cheight = height >> 2;
284 	u8 overflow = (height >> 9 & 0x02) | (width >> 10 & 0x01);
285 	/* NOTE: size limit: 2047x1023 = 2MPix */
286 
287 	em28xx_videodbg("capture area set to (%d,%d): %dx%d\n",
288 			hstart, vstart,
289 		       ((overflow & 2) << 9 | cwidth << 2),
290 		       ((overflow & 1) << 10 | cheight << 2));
291 
292 	em28xx_write_regs(dev, EM28XX_R1C_HSTART, &hstart, 1);
293 	em28xx_write_regs(dev, EM28XX_R1D_VSTART, &vstart, 1);
294 	em28xx_write_regs(dev, EM28XX_R1E_CWIDTH, &cwidth, 1);
295 	em28xx_write_regs(dev, EM28XX_R1F_CHEIGHT, &cheight, 1);
296 	em28xx_write_regs(dev, EM28XX_R1B_OFLOW, &overflow, 1);
297 
298 	/* FIXME: function/meaning of these registers ? */
299 	/* FIXME: align width+height to multiples of 4 ?! */
300 	if (dev->is_em25xx) {
301 		em28xx_write_reg(dev, 0x34, width >> 4);
302 		em28xx_write_reg(dev, 0x35, height >> 4);
303 	}
304 }
305 
306 static int em28xx_scaler_set(struct em28xx *dev, u16 h, u16 v)
307 {
308 	u8 mode = 0x00;
309 	/* the em2800 scaler only supports scaling down to 50% */
310 
311 	if (dev->board.is_em2800) {
312 		mode = (v ? 0x20 : 0x00) | (h ? 0x10 : 0x00);
313 	} else {
314 		u8 buf[2];
315 
316 		buf[0] = h;
317 		buf[1] = h >> 8;
318 		em28xx_write_regs(dev, EM28XX_R30_HSCALELOW, (char *)buf, 2);
319 
320 		buf[0] = v;
321 		buf[1] = v >> 8;
322 		em28xx_write_regs(dev, EM28XX_R32_VSCALELOW, (char *)buf, 2);
323 		/* it seems that both H and V scalers must be active
324 		   to work correctly */
325 		mode = (h || v) ? 0x30 : 0x00;
326 	}
327 	return em28xx_write_reg(dev, EM28XX_R26_COMPR, mode);
328 }
329 
330 /* FIXME: this only function read values from dev */
331 static int em28xx_resolution_set(struct em28xx *dev)
332 {
333 	struct em28xx_v4l2 *v4l2 = dev->v4l2;
334 	int width = norm_maxw(dev);
335 	int height = norm_maxh(dev);
336 
337 	/* Properly setup VBI */
338 	v4l2->vbi_width = 720;
339 	if (v4l2->norm & V4L2_STD_525_60)
340 		v4l2->vbi_height = 12;
341 	else
342 		v4l2->vbi_height = 18;
343 
344 	em28xx_set_outfmt(dev);
345 
346 	em28xx_accumulator_set(dev, 1, (width - 4) >> 2, 1, (height - 4) >> 2);
347 
348 	/* If we don't set the start position to 2 in VBI mode, we end up
349 	   with line 20/21 being YUYV encoded instead of being in 8-bit
350 	   greyscale.  The core of the issue is that line 21 (and line 23 for
351 	   PAL WSS) are inside of active video region, and as a result they
352 	   get the pixelformatting associated with that area.  So by cropping
353 	   it out, we end up with the same format as the rest of the VBI
354 	   region */
355 	if (em28xx_vbi_supported(dev) == 1)
356 		em28xx_capture_area_set(dev, 0, 2, width, height);
357 	else
358 		em28xx_capture_area_set(dev, 0, 0, width, height);
359 
360 	return em28xx_scaler_set(dev, v4l2->hscale, v4l2->vscale);
361 }
362 
363 /* Set USB alternate setting for analog video */
364 static int em28xx_set_alternate(struct em28xx *dev)
365 {
366 	struct em28xx_v4l2 *v4l2 = dev->v4l2;
367 	struct usb_device *udev = interface_to_usbdev(dev->intf);
368 	int errCode;
369 	int i;
370 	unsigned int min_pkt_size = v4l2->width * 2 + 4;
371 
372 	/* NOTE: for isoc transfers, only alt settings > 0 are allowed
373 		 bulk transfers seem to work only with alt=0 ! */
374 	dev->alt = 0;
375 	if ((alt > 0) && (alt < dev->num_alt)) {
376 		em28xx_videodbg("alternate forced to %d\n", dev->alt);
377 		dev->alt = alt;
378 		goto set_alt;
379 	}
380 	if (dev->analog_xfer_bulk)
381 		goto set_alt;
382 
383 	/* When image size is bigger than a certain value,
384 	   the frame size should be increased, otherwise, only
385 	   green screen will be received.
386 	 */
387 	if (v4l2->width * 2 * v4l2->height > 720 * 240 * 2)
388 		min_pkt_size *= 2;
389 
390 	for (i = 0; i < dev->num_alt; i++) {
391 		/* stop when the selected alt setting offers enough bandwidth */
392 		if (dev->alt_max_pkt_size_isoc[i] >= min_pkt_size) {
393 			dev->alt = i;
394 			break;
395 		/* otherwise make sure that we end up with the maximum bandwidth
396 		   because the min_pkt_size equation might be wrong...
397 		*/
398 		} else if (dev->alt_max_pkt_size_isoc[i] >
399 			   dev->alt_max_pkt_size_isoc[dev->alt])
400 			dev->alt = i;
401 	}
402 
403 set_alt:
404 	/* NOTE: for bulk transfers, we need to call usb_set_interface()
405 	 * even if the previous settings were the same. Otherwise streaming
406 	 * fails with all urbs having status = -EOVERFLOW ! */
407 	if (dev->analog_xfer_bulk) {
408 		dev->max_pkt_size = 512; /* USB 2.0 spec */
409 		dev->packet_multiplier = EM28XX_BULK_PACKET_MULTIPLIER;
410 	} else { /* isoc */
411 		em28xx_videodbg("minimum isoc packet size: %u (alt=%d)\n",
412 				min_pkt_size, dev->alt);
413 		dev->max_pkt_size =
414 				  dev->alt_max_pkt_size_isoc[dev->alt];
415 		dev->packet_multiplier = EM28XX_NUM_ISOC_PACKETS;
416 	}
417 	em28xx_videodbg("setting alternate %d with wMaxPacketSize=%u\n",
418 			dev->alt, dev->max_pkt_size);
419 	errCode = usb_set_interface(udev, dev->ifnum, dev->alt);
420 	if (errCode < 0) {
421 		dev_err(&dev->intf->dev,
422 			"cannot change alternate number to %d (error=%i)\n",
423 			dev->alt, errCode);
424 		return errCode;
425 	}
426 	return 0;
427 }
428 
429 /* ------------------------------------------------------------------
430 	DMA and thread functions
431    ------------------------------------------------------------------*/
432 
433 /*
434  * Finish the current buffer
435  */
436 static inline void finish_buffer(struct em28xx *dev,
437 				 struct em28xx_buffer *buf)
438 {
439 	em28xx_isocdbg("[%p/%d] wakeup\n", buf, buf->top_field);
440 
441 	buf->vb.sequence = dev->v4l2->field_count++;
442 	if (dev->v4l2->progressive)
443 		buf->vb.field = V4L2_FIELD_NONE;
444 	else
445 		buf->vb.field = V4L2_FIELD_INTERLACED;
446 	buf->vb.vb2_buf.timestamp = ktime_get_ns();
447 
448 	vb2_buffer_done(&buf->vb.vb2_buf, VB2_BUF_STATE_DONE);
449 }
450 
451 /*
452  * Copy picture data from USB buffer to videobuf buffer
453  */
454 static void em28xx_copy_video(struct em28xx *dev,
455 			      struct em28xx_buffer *buf,
456 			      unsigned char *usb_buf,
457 			      unsigned long len)
458 {
459 	struct em28xx_v4l2 *v4l2 = dev->v4l2;
460 	void *fieldstart, *startwrite, *startread;
461 	int  linesdone, currlinedone, offset, lencopy, remain;
462 	int bytesperline = v4l2->width << 1;
463 
464 	if (buf->pos + len > buf->length)
465 		len = buf->length - buf->pos;
466 
467 	startread = usb_buf;
468 	remain = len;
469 
470 	if (v4l2->progressive || buf->top_field)
471 		fieldstart = buf->vb_buf;
472 	else /* interlaced mode, even nr. of lines */
473 		fieldstart = buf->vb_buf + bytesperline;
474 
475 	linesdone = buf->pos / bytesperline;
476 	currlinedone = buf->pos % bytesperline;
477 
478 	if (v4l2->progressive)
479 		offset = linesdone * bytesperline + currlinedone;
480 	else
481 		offset = linesdone * bytesperline * 2 + currlinedone;
482 
483 	startwrite = fieldstart + offset;
484 	lencopy = bytesperline - currlinedone;
485 	lencopy = lencopy > remain ? remain : lencopy;
486 
487 	if ((char *)startwrite + lencopy > (char *)buf->vb_buf + buf->length) {
488 		em28xx_isocdbg("Overflow of %zu bytes past buffer end (1)\n",
489 			       ((char *)startwrite + lencopy) -
490 			      ((char *)buf->vb_buf + buf->length));
491 		remain = (char *)buf->vb_buf + buf->length -
492 			 (char *)startwrite;
493 		lencopy = remain;
494 	}
495 	if (lencopy <= 0)
496 		return;
497 	memcpy(startwrite, startread, lencopy);
498 
499 	remain -= lencopy;
500 
501 	while (remain > 0) {
502 		if (v4l2->progressive)
503 			startwrite += lencopy;
504 		else
505 			startwrite += lencopy + bytesperline;
506 		startread += lencopy;
507 		if (bytesperline > remain)
508 			lencopy = remain;
509 		else
510 			lencopy = bytesperline;
511 
512 		if ((char *)startwrite + lencopy > (char *)buf->vb_buf +
513 		    buf->length) {
514 			em28xx_isocdbg("Overflow of %zu bytes past buffer end(2)\n",
515 				       ((char *)startwrite + lencopy) -
516 				       ((char *)buf->vb_buf + buf->length));
517 			lencopy = remain = (char *)buf->vb_buf + buf->length -
518 				(char *)startwrite;
519 		}
520 		if (lencopy <= 0)
521 			break;
522 
523 		memcpy(startwrite, startread, lencopy);
524 
525 		remain -= lencopy;
526 	}
527 
528 	buf->pos += len;
529 }
530 
531 /*
532  * Copy VBI data from USB buffer to videobuf buffer
533  */
534 static void em28xx_copy_vbi(struct em28xx *dev,
535 			    struct em28xx_buffer *buf,
536 			    unsigned char *usb_buf,
537 			    unsigned long len)
538 {
539 	unsigned int offset;
540 
541 	if (buf->pos + len > buf->length)
542 		len = buf->length - buf->pos;
543 
544 	offset = buf->pos;
545 	/* Make sure the bottom field populates the second half of the frame */
546 	if (buf->top_field == 0)
547 		offset += dev->v4l2->vbi_width * dev->v4l2->vbi_height;
548 
549 	memcpy(buf->vb_buf + offset, usb_buf, len);
550 	buf->pos += len;
551 }
552 
553 static inline void print_err_status(struct em28xx *dev,
554 				    int packet, int status)
555 {
556 	char *errmsg = "Unknown";
557 
558 	switch (status) {
559 	case -ENOENT:
560 		errmsg = "unlinked synchronuously";
561 		break;
562 	case -ECONNRESET:
563 		errmsg = "unlinked asynchronuously";
564 		break;
565 	case -ENOSR:
566 		errmsg = "Buffer error (overrun)";
567 		break;
568 	case -EPIPE:
569 		errmsg = "Stalled (device not responding)";
570 		break;
571 	case -EOVERFLOW:
572 		errmsg = "Babble (bad cable?)";
573 		break;
574 	case -EPROTO:
575 		errmsg = "Bit-stuff error (bad cable?)";
576 		break;
577 	case -EILSEQ:
578 		errmsg = "CRC/Timeout (could be anything)";
579 		break;
580 	case -ETIME:
581 		errmsg = "Device does not respond";
582 		break;
583 	}
584 	if (packet < 0) {
585 		em28xx_isocdbg("URB status %d [%s].\n",	status, errmsg);
586 	} else {
587 		em28xx_isocdbg("URB packet %d, status %d [%s].\n",
588 			       packet, status, errmsg);
589 	}
590 }
591 
592 /*
593  * get the next available buffer from dma queue
594  */
595 static inline struct em28xx_buffer *get_next_buf(struct em28xx *dev,
596 						 struct em28xx_dmaqueue *dma_q)
597 {
598 	struct em28xx_buffer *buf;
599 
600 	if (list_empty(&dma_q->active)) {
601 		em28xx_isocdbg("No active queue to serve\n");
602 		return NULL;
603 	}
604 
605 	/* Get the next buffer */
606 	buf = list_entry(dma_q->active.next, struct em28xx_buffer, list);
607 	/* Cleans up buffer - Useful for testing for frame/URB loss */
608 	list_del(&buf->list);
609 	buf->pos = 0;
610 	buf->vb_buf = buf->mem;
611 
612 	return buf;
613 }
614 
615 /*
616  * Finish the current buffer if completed and prepare for the next field
617  */
618 static struct em28xx_buffer *
619 finish_field_prepare_next(struct em28xx *dev,
620 			  struct em28xx_buffer *buf,
621 			  struct em28xx_dmaqueue *dma_q)
622 {
623 	struct em28xx_v4l2 *v4l2 = dev->v4l2;
624 
625 	if (v4l2->progressive || v4l2->top_field) { /* Brand new frame */
626 		if (buf != NULL)
627 			finish_buffer(dev, buf);
628 		buf = get_next_buf(dev, dma_q);
629 	}
630 	if (buf != NULL) {
631 		buf->top_field = v4l2->top_field;
632 		buf->pos = 0;
633 	}
634 
635 	return buf;
636 }
637 
638 /*
639  * Process data packet according to the em2710/em2750/em28xx frame data format
640  */
641 static inline void process_frame_data_em28xx(struct em28xx *dev,
642 					     unsigned char *data_pkt,
643 					     unsigned int  data_len)
644 {
645 	struct em28xx_v4l2      *v4l2 = dev->v4l2;
646 	struct em28xx_buffer    *buf = dev->usb_ctl.vid_buf;
647 	struct em28xx_buffer    *vbi_buf = dev->usb_ctl.vbi_buf;
648 	struct em28xx_dmaqueue  *dma_q = &dev->vidq;
649 	struct em28xx_dmaqueue  *vbi_dma_q = &dev->vbiq;
650 
651 	/* capture type 0 = vbi start
652 	   capture type 1 = vbi in progress
653 	   capture type 2 = video start
654 	   capture type 3 = video in progress */
655 	if (data_len >= 4) {
656 		/* NOTE: Headers are always 4 bytes and
657 		 * never split across packets */
658 		if (data_pkt[0] == 0x88 && data_pkt[1] == 0x88 &&
659 		    data_pkt[2] == 0x88 && data_pkt[3] == 0x88) {
660 			/* Continuation */
661 			data_pkt += 4;
662 			data_len -= 4;
663 		} else if (data_pkt[0] == 0x33 && data_pkt[1] == 0x95) {
664 			/* Field start (VBI mode) */
665 			v4l2->capture_type = 0;
666 			v4l2->vbi_read = 0;
667 			em28xx_isocdbg("VBI START HEADER !!!\n");
668 			v4l2->top_field = !(data_pkt[2] & 1);
669 			data_pkt += 4;
670 			data_len -= 4;
671 		} else if (data_pkt[0] == 0x22 && data_pkt[1] == 0x5a) {
672 			/* Field start (VBI disabled) */
673 			v4l2->capture_type = 2;
674 			em28xx_isocdbg("VIDEO START HEADER !!!\n");
675 			v4l2->top_field = !(data_pkt[2] & 1);
676 			data_pkt += 4;
677 			data_len -= 4;
678 		}
679 	}
680 	/* NOTE: With bulk transfers, intermediate data packets
681 	 * have no continuation header */
682 
683 	if (v4l2->capture_type == 0) {
684 		vbi_buf = finish_field_prepare_next(dev, vbi_buf, vbi_dma_q);
685 		dev->usb_ctl.vbi_buf = vbi_buf;
686 		v4l2->capture_type = 1;
687 	}
688 
689 	if (v4l2->capture_type == 1) {
690 		int vbi_size = v4l2->vbi_width * v4l2->vbi_height;
691 		int vbi_data_len = ((v4l2->vbi_read + data_len) > vbi_size) ?
692 				   (vbi_size - v4l2->vbi_read) : data_len;
693 
694 		/* Copy VBI data */
695 		if (vbi_buf != NULL)
696 			em28xx_copy_vbi(dev, vbi_buf, data_pkt, vbi_data_len);
697 		v4l2->vbi_read += vbi_data_len;
698 
699 		if (vbi_data_len < data_len) {
700 			/* Continue with copying video data */
701 			v4l2->capture_type = 2;
702 			data_pkt += vbi_data_len;
703 			data_len -= vbi_data_len;
704 		}
705 	}
706 
707 	if (v4l2->capture_type == 2) {
708 		buf = finish_field_prepare_next(dev, buf, dma_q);
709 		dev->usb_ctl.vid_buf = buf;
710 		v4l2->capture_type = 3;
711 	}
712 
713 	if (v4l2->capture_type == 3 && buf != NULL && data_len > 0)
714 		em28xx_copy_video(dev, buf, data_pkt, data_len);
715 }
716 
717 /*
718  * Process data packet according to the em25xx/em276x/7x/8x frame data format
719  */
720 static inline void process_frame_data_em25xx(struct em28xx *dev,
721 					     unsigned char *data_pkt,
722 					     unsigned int  data_len)
723 {
724 	struct em28xx_buffer    *buf = dev->usb_ctl.vid_buf;
725 	struct em28xx_dmaqueue  *dmaq = &dev->vidq;
726 	struct em28xx_v4l2      *v4l2 = dev->v4l2;
727 	bool frame_end = false;
728 
729 	/* Check for header */
730 	/* NOTE: at least with bulk transfers, only the first packet
731 	 * has a header and has always set the FRAME_END bit         */
732 	if (data_len >= 2) {	/* em25xx header is only 2 bytes long */
733 		if ((data_pkt[0] == EM25XX_FRMDATAHDR_BYTE1) &&
734 		    ((data_pkt[1] & ~EM25XX_FRMDATAHDR_BYTE2_MASK) == 0x00)) {
735 			v4l2->top_field = !(data_pkt[1] &
736 					   EM25XX_FRMDATAHDR_BYTE2_FRAME_ID);
737 			frame_end = data_pkt[1] &
738 				    EM25XX_FRMDATAHDR_BYTE2_FRAME_END;
739 			data_pkt += 2;
740 			data_len -= 2;
741 		}
742 
743 		/* Finish field and prepare next (BULK only) */
744 		if (dev->analog_xfer_bulk && frame_end) {
745 			buf = finish_field_prepare_next(dev, buf, dmaq);
746 			dev->usb_ctl.vid_buf = buf;
747 		}
748 		/* NOTE: in ISOC mode when a new frame starts and buf==NULL,
749 		 * we COULD already prepare a buffer here to avoid skipping the
750 		 * first frame.
751 		 */
752 	}
753 
754 	/* Copy data */
755 	if (buf != NULL && data_len > 0)
756 		em28xx_copy_video(dev, buf, data_pkt, data_len);
757 
758 	/* Finish frame (ISOC only) => avoids lag of 1 frame */
759 	if (!dev->analog_xfer_bulk && frame_end) {
760 		buf = finish_field_prepare_next(dev, buf, dmaq);
761 		dev->usb_ctl.vid_buf = buf;
762 	}
763 
764 	/* NOTE: Tested with USB bulk transfers only !
765 	 * The wording in the datasheet suggests that isoc might work different.
766 	 * The current code assumes that with isoc transfers each packet has a
767 	 * header like with the other em28xx devices.
768 	 */
769 	/* NOTE: Support for interlaced mode is pure theory. It has not been
770 	 * tested and it is unknown if these devices actually support it. */
771 	/* NOTE: No VBI support yet (these chips likely do not support VBI). */
772 }
773 
774 /* Processes and copies the URB data content (video and VBI data) */
775 static inline int em28xx_urb_data_copy(struct em28xx *dev, struct urb *urb)
776 {
777 	int xfer_bulk, num_packets, i;
778 	unsigned char *usb_data_pkt;
779 	unsigned int usb_data_len;
780 
781 	if (!dev)
782 		return 0;
783 
784 	if (dev->disconnected)
785 		return 0;
786 
787 	if (urb->status < 0)
788 		print_err_status(dev, -1, urb->status);
789 
790 	xfer_bulk = usb_pipebulk(urb->pipe);
791 
792 	if (xfer_bulk) /* bulk */
793 		num_packets = 1;
794 	else /* isoc */
795 		num_packets = urb->number_of_packets;
796 
797 	for (i = 0; i < num_packets; i++) {
798 		if (xfer_bulk) { /* bulk */
799 			usb_data_len = urb->actual_length;
800 
801 			usb_data_pkt = urb->transfer_buffer;
802 		} else { /* isoc */
803 			if (urb->iso_frame_desc[i].status < 0) {
804 				print_err_status(dev, i,
805 						 urb->iso_frame_desc[i].status);
806 				if (urb->iso_frame_desc[i].status != -EPROTO)
807 					continue;
808 			}
809 
810 			usb_data_len = urb->iso_frame_desc[i].actual_length;
811 			if (usb_data_len > dev->max_pkt_size) {
812 				em28xx_isocdbg("packet bigger than packet size");
813 				continue;
814 			}
815 
816 			usb_data_pkt = urb->transfer_buffer +
817 				       urb->iso_frame_desc[i].offset;
818 		}
819 
820 		if (usb_data_len == 0) {
821 			/* NOTE: happens very often with isoc transfers */
822 			/* em28xx_usbdbg("packet %d is empty",i); - spammy */
823 			continue;
824 		}
825 
826 		if (dev->is_em25xx)
827 			process_frame_data_em25xx(dev,
828 						  usb_data_pkt, usb_data_len);
829 		else
830 			process_frame_data_em28xx(dev,
831 						  usb_data_pkt, usb_data_len);
832 
833 	}
834 	return 1;
835 }
836 
837 static int get_ressource(enum v4l2_buf_type f_type)
838 {
839 	switch (f_type) {
840 	case V4L2_BUF_TYPE_VIDEO_CAPTURE:
841 		return EM28XX_RESOURCE_VIDEO;
842 	case V4L2_BUF_TYPE_VBI_CAPTURE:
843 		return EM28XX_RESOURCE_VBI;
844 	default:
845 		BUG();
846 	}
847 }
848 
849 /* Usage lock check functions */
850 static int res_get(struct em28xx *dev, enum v4l2_buf_type f_type)
851 {
852 	int res_type = get_ressource(f_type);
853 
854 	/* is it free? */
855 	if (dev->resources & res_type) {
856 		/* no, someone else uses it */
857 		return -EBUSY;
858 	}
859 
860 	/* it's free, grab it */
861 	dev->resources |= res_type;
862 	em28xx_videodbg("res: get %d\n", res_type);
863 	return 0;
864 }
865 
866 static void res_free(struct em28xx *dev, enum v4l2_buf_type f_type)
867 {
868 	int res_type = get_ressource(f_type);
869 
870 	dev->resources &= ~res_type;
871 	em28xx_videodbg("res: put %d\n", res_type);
872 }
873 
874 static void em28xx_v4l2_media_release(struct em28xx *dev)
875 {
876 #ifdef CONFIG_MEDIA_CONTROLLER
877 	int i;
878 
879 	for (i = 0; i < MAX_EM28XX_INPUT; i++) {
880 		if (!INPUT(i)->type)
881 			return;
882 		media_device_unregister_entity(&dev->input_ent[i]);
883 	}
884 #endif
885 }
886 
887 /*
888  * Media Controller helper functions
889  */
890 
891 static int em28xx_enable_analog_tuner(struct em28xx *dev)
892 {
893 #ifdef CONFIG_MEDIA_CONTROLLER
894 	struct media_device *mdev = dev->media_dev;
895 	struct em28xx_v4l2 *v4l2 = dev->v4l2;
896 	struct media_entity *source;
897 	struct media_link *link, *found_link = NULL;
898 	int ret, active_links = 0;
899 
900 	if (!mdev || !v4l2->decoder)
901 		return 0;
902 
903 	/*
904 	 * This will find the tuner that is connected into the decoder.
905 	 * Technically, this is not 100% correct, as the device may be
906 	 * using an analog input instead of the tuner. However, as we can't
907 	 * do DVB streaming while the DMA engine is being used for V4L2,
908 	 * this should be enough for the actual needs.
909 	 */
910 	list_for_each_entry(link, &v4l2->decoder->links, list) {
911 		if (link->sink->entity == v4l2->decoder) {
912 			found_link = link;
913 			if (link->flags & MEDIA_LNK_FL_ENABLED)
914 				active_links++;
915 			break;
916 		}
917 	}
918 
919 	if (active_links == 1 || !found_link)
920 		return 0;
921 
922 	source = found_link->source->entity;
923 	list_for_each_entry(link, &source->links, list) {
924 		struct media_entity *sink;
925 		int flags = 0;
926 
927 		sink = link->sink->entity;
928 
929 		if (sink == v4l2->decoder)
930 			flags = MEDIA_LNK_FL_ENABLED;
931 
932 		ret = media_entity_setup_link(link, flags);
933 		if (ret) {
934 			dev_err(&dev->intf->dev,
935 				"Couldn't change link %s->%s to %s. Error %d\n",
936 				source->name, sink->name,
937 				flags ? "enabled" : "disabled",
938 				ret);
939 			return ret;
940 		} else
941 			em28xx_videodbg("link %s->%s was %s\n",
942 					source->name, sink->name,
943 					flags ? "ENABLED" : "disabled");
944 	}
945 #endif
946 	return 0;
947 }
948 
949 static const char * const iname[] = {
950 	[EM28XX_VMUX_COMPOSITE]  = "Composite",
951 	[EM28XX_VMUX_SVIDEO]     = "S-Video",
952 	[EM28XX_VMUX_TELEVISION] = "Television",
953 	[EM28XX_RADIO]           = "Radio",
954 };
955 
956 static void em28xx_v4l2_create_entities(struct em28xx *dev)
957 {
958 #if defined(CONFIG_MEDIA_CONTROLLER)
959 	struct em28xx_v4l2 *v4l2 = dev->v4l2;
960 	int ret, i;
961 
962 	/* Initialize Video, VBI and Radio pads */
963 	v4l2->video_pad.flags = MEDIA_PAD_FL_SINK;
964 	ret = media_entity_pads_init(&v4l2->vdev.entity, 1, &v4l2->video_pad);
965 	if (ret < 0)
966 		dev_err(&dev->intf->dev,
967 			"failed to initialize video media entity!\n");
968 
969 	if (em28xx_vbi_supported(dev)) {
970 		v4l2->vbi_pad.flags = MEDIA_PAD_FL_SINK;
971 		ret = media_entity_pads_init(&v4l2->vbi_dev.entity, 1,
972 					     &v4l2->vbi_pad);
973 		if (ret < 0)
974 			dev_err(&dev->intf->dev,
975 				"failed to initialize vbi media entity!\n");
976 	}
977 
978 	/* Webcams don't have input connectors */
979 	if (dev->board.is_webcam)
980 		return;
981 
982 	/* Create entities for each input connector */
983 	for (i = 0; i < MAX_EM28XX_INPUT; i++) {
984 		struct media_entity *ent = &dev->input_ent[i];
985 
986 		if (!INPUT(i)->type)
987 			break;
988 
989 		ent->name = iname[INPUT(i)->type];
990 		ent->flags = MEDIA_ENT_FL_CONNECTOR;
991 		dev->input_pad[i].flags = MEDIA_PAD_FL_SOURCE;
992 
993 		switch (INPUT(i)->type) {
994 		case EM28XX_VMUX_COMPOSITE:
995 			ent->function = MEDIA_ENT_F_CONN_COMPOSITE;
996 			break;
997 		case EM28XX_VMUX_SVIDEO:
998 			ent->function = MEDIA_ENT_F_CONN_SVIDEO;
999 			break;
1000 		default: /* EM28XX_VMUX_TELEVISION or EM28XX_RADIO */
1001 			if (dev->tuner_type != TUNER_ABSENT)
1002 				ent->function = MEDIA_ENT_F_CONN_RF;
1003 			break;
1004 		}
1005 
1006 		ret = media_entity_pads_init(ent, 1, &dev->input_pad[i]);
1007 		if (ret < 0)
1008 			dev_err(&dev->intf->dev,
1009 				"failed to initialize input pad[%d]!\n", i);
1010 
1011 		ret = media_device_register_entity(dev->media_dev, ent);
1012 		if (ret < 0)
1013 			dev_err(&dev->intf->dev,
1014 				"failed to register input entity %d!\n", i);
1015 	}
1016 #endif
1017 }
1018 
1019 
1020 /* ------------------------------------------------------------------
1021 	Videobuf2 operations
1022    ------------------------------------------------------------------*/
1023 
1024 static int queue_setup(struct vb2_queue *vq,
1025 		       unsigned int *nbuffers, unsigned int *nplanes,
1026 		       unsigned int sizes[], struct device *alloc_devs[])
1027 {
1028 	struct em28xx *dev = vb2_get_drv_priv(vq);
1029 	struct em28xx_v4l2 *v4l2 = dev->v4l2;
1030 	unsigned long size =
1031 		    (v4l2->width * v4l2->height * v4l2->format->depth + 7) >> 3;
1032 
1033 	if (*nplanes)
1034 		return sizes[0] < size ? -EINVAL : 0;
1035 	*nplanes = 1;
1036 	sizes[0] = size;
1037 
1038 	em28xx_enable_analog_tuner(dev);
1039 
1040 	return 0;
1041 }
1042 
1043 static int
1044 buffer_prepare(struct vb2_buffer *vb)
1045 {
1046 	struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
1047 	struct em28xx        *dev = vb2_get_drv_priv(vb->vb2_queue);
1048 	struct em28xx_v4l2   *v4l2 = dev->v4l2;
1049 	unsigned long size;
1050 
1051 	em28xx_videodbg("%s, field=%d\n", __func__, vbuf->field);
1052 
1053 	size = (v4l2->width * v4l2->height * v4l2->format->depth + 7) >> 3;
1054 
1055 	if (vb2_plane_size(vb, 0) < size) {
1056 		em28xx_videodbg("%s data will not fit into plane (%lu < %lu)\n",
1057 				__func__, vb2_plane_size(vb, 0), size);
1058 		return -EINVAL;
1059 	}
1060 	vb2_set_plane_payload(vb, 0, size);
1061 
1062 	return 0;
1063 }
1064 
1065 int em28xx_start_analog_streaming(struct vb2_queue *vq, unsigned int count)
1066 {
1067 	struct em28xx *dev = vb2_get_drv_priv(vq);
1068 	struct em28xx_v4l2 *v4l2 = dev->v4l2;
1069 	struct v4l2_frequency f;
1070 	struct v4l2_fh *owner;
1071 	int rc = 0;
1072 
1073 	em28xx_videodbg("%s\n", __func__);
1074 
1075 	/* Make sure streaming is not already in progress for this type
1076 	   of filehandle (e.g. video, vbi) */
1077 	rc = res_get(dev, vq->type);
1078 	if (rc)
1079 		return rc;
1080 
1081 	if (v4l2->streaming_users == 0) {
1082 		/* First active streaming user, so allocate all the URBs */
1083 
1084 		/* Allocate the USB bandwidth */
1085 		em28xx_set_alternate(dev);
1086 
1087 		/* Needed, since GPIO might have disabled power of
1088 		   some i2c device
1089 		*/
1090 		em28xx_wake_i2c(dev);
1091 
1092 		v4l2->capture_type = -1;
1093 		rc = em28xx_init_usb_xfer(dev, EM28XX_ANALOG_MODE,
1094 					  dev->analog_xfer_bulk,
1095 					  EM28XX_NUM_BUFS,
1096 					  dev->max_pkt_size,
1097 					  dev->packet_multiplier,
1098 					  em28xx_urb_data_copy);
1099 		if (rc < 0)
1100 			return rc;
1101 
1102 		/*
1103 		 * djh: it's not clear whether this code is still needed.  I'm
1104 		 * leaving it in here for now entirely out of concern for
1105 		 * backward compatibility (the old code did it)
1106 		 */
1107 
1108 		/* Ask tuner to go to analog or radio mode */
1109 		memset(&f, 0, sizeof(f));
1110 		f.frequency = v4l2->frequency;
1111 		owner = (struct v4l2_fh *)vq->owner;
1112 		if (owner && owner->vdev->vfl_type == VFL_TYPE_RADIO)
1113 			f.type = V4L2_TUNER_RADIO;
1114 		else
1115 			f.type = V4L2_TUNER_ANALOG_TV;
1116 		v4l2_device_call_all(&v4l2->v4l2_dev,
1117 				     0, tuner, s_frequency, &f);
1118 
1119 		/* Enable video stream at TV decoder */
1120 		v4l2_device_call_all(&v4l2->v4l2_dev, 0, video, s_stream, 1);
1121 	}
1122 
1123 	v4l2->streaming_users++;
1124 
1125 	return rc;
1126 }
1127 
1128 static void em28xx_stop_streaming(struct vb2_queue *vq)
1129 {
1130 	struct em28xx *dev = vb2_get_drv_priv(vq);
1131 	struct em28xx_v4l2 *v4l2 = dev->v4l2;
1132 	struct em28xx_dmaqueue *vidq = &dev->vidq;
1133 	unsigned long flags = 0;
1134 
1135 	em28xx_videodbg("%s\n", __func__);
1136 
1137 	res_free(dev, vq->type);
1138 
1139 	if (v4l2->streaming_users-- == 1) {
1140 		/* Disable video stream at TV decoder */
1141 		v4l2_device_call_all(&v4l2->v4l2_dev, 0, video, s_stream, 0);
1142 
1143 		/* Last active user, so shutdown all the URBS */
1144 		em28xx_uninit_usb_xfer(dev, EM28XX_ANALOG_MODE);
1145 	}
1146 
1147 	spin_lock_irqsave(&dev->slock, flags);
1148 	if (dev->usb_ctl.vid_buf != NULL) {
1149 		vb2_buffer_done(&dev->usb_ctl.vid_buf->vb.vb2_buf,
1150 				VB2_BUF_STATE_ERROR);
1151 		dev->usb_ctl.vid_buf = NULL;
1152 	}
1153 	while (!list_empty(&vidq->active)) {
1154 		struct em28xx_buffer *buf;
1155 
1156 		buf = list_entry(vidq->active.next, struct em28xx_buffer, list);
1157 		list_del(&buf->list);
1158 		vb2_buffer_done(&buf->vb.vb2_buf, VB2_BUF_STATE_ERROR);
1159 	}
1160 	spin_unlock_irqrestore(&dev->slock, flags);
1161 }
1162 
1163 void em28xx_stop_vbi_streaming(struct vb2_queue *vq)
1164 {
1165 	struct em28xx *dev = vb2_get_drv_priv(vq);
1166 	struct em28xx_v4l2 *v4l2 = dev->v4l2;
1167 	struct em28xx_dmaqueue *vbiq = &dev->vbiq;
1168 	unsigned long flags = 0;
1169 
1170 	em28xx_videodbg("%s\n", __func__);
1171 
1172 	res_free(dev, vq->type);
1173 
1174 	if (v4l2->streaming_users-- == 1) {
1175 		/* Disable video stream at TV decoder */
1176 		v4l2_device_call_all(&v4l2->v4l2_dev, 0, video, s_stream, 0);
1177 
1178 		/* Last active user, so shutdown all the URBS */
1179 		em28xx_uninit_usb_xfer(dev, EM28XX_ANALOG_MODE);
1180 	}
1181 
1182 	spin_lock_irqsave(&dev->slock, flags);
1183 	if (dev->usb_ctl.vbi_buf != NULL) {
1184 		vb2_buffer_done(&dev->usb_ctl.vbi_buf->vb.vb2_buf,
1185 				VB2_BUF_STATE_ERROR);
1186 		dev->usb_ctl.vbi_buf = NULL;
1187 	}
1188 	while (!list_empty(&vbiq->active)) {
1189 		struct em28xx_buffer *buf;
1190 
1191 		buf = list_entry(vbiq->active.next, struct em28xx_buffer, list);
1192 		list_del(&buf->list);
1193 		vb2_buffer_done(&buf->vb.vb2_buf, VB2_BUF_STATE_ERROR);
1194 	}
1195 	spin_unlock_irqrestore(&dev->slock, flags);
1196 }
1197 
1198 static void
1199 buffer_queue(struct vb2_buffer *vb)
1200 {
1201 	struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
1202 	struct em28xx *dev = vb2_get_drv_priv(vb->vb2_queue);
1203 	struct em28xx_buffer *buf =
1204 		container_of(vbuf, struct em28xx_buffer, vb);
1205 	struct em28xx_dmaqueue *vidq = &dev->vidq;
1206 	unsigned long flags = 0;
1207 
1208 	em28xx_videodbg("%s\n", __func__);
1209 	buf->mem = vb2_plane_vaddr(vb, 0);
1210 	buf->length = vb2_plane_size(vb, 0);
1211 
1212 	spin_lock_irqsave(&dev->slock, flags);
1213 	list_add_tail(&buf->list, &vidq->active);
1214 	spin_unlock_irqrestore(&dev->slock, flags);
1215 }
1216 
1217 static const struct vb2_ops em28xx_video_qops = {
1218 	.queue_setup    = queue_setup,
1219 	.buf_prepare    = buffer_prepare,
1220 	.buf_queue      = buffer_queue,
1221 	.start_streaming = em28xx_start_analog_streaming,
1222 	.stop_streaming = em28xx_stop_streaming,
1223 	.wait_prepare   = vb2_ops_wait_prepare,
1224 	.wait_finish    = vb2_ops_wait_finish,
1225 };
1226 
1227 static int em28xx_vb2_setup(struct em28xx *dev)
1228 {
1229 	int rc;
1230 	struct vb2_queue *q;
1231 	struct em28xx_v4l2 *v4l2 = dev->v4l2;
1232 
1233 	/* Setup Videobuf2 for Video capture */
1234 	q = &v4l2->vb_vidq;
1235 	q->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1236 	q->io_modes = VB2_READ | VB2_MMAP | VB2_USERPTR | VB2_DMABUF;
1237 	q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1238 	q->drv_priv = dev;
1239 	q->buf_struct_size = sizeof(struct em28xx_buffer);
1240 	q->ops = &em28xx_video_qops;
1241 	q->mem_ops = &vb2_vmalloc_memops;
1242 
1243 	rc = vb2_queue_init(q);
1244 	if (rc < 0)
1245 		return rc;
1246 
1247 	/* Setup Videobuf2 for VBI capture */
1248 	q = &v4l2->vb_vbiq;
1249 	q->type = V4L2_BUF_TYPE_VBI_CAPTURE;
1250 	q->io_modes = VB2_READ | VB2_MMAP | VB2_USERPTR;
1251 	q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1252 	q->drv_priv = dev;
1253 	q->buf_struct_size = sizeof(struct em28xx_buffer);
1254 	q->ops = &em28xx_vbi_qops;
1255 	q->mem_ops = &vb2_vmalloc_memops;
1256 
1257 	rc = vb2_queue_init(q);
1258 	if (rc < 0)
1259 		return rc;
1260 
1261 	return 0;
1262 }
1263 
1264 /*********************  v4l2 interface  **************************************/
1265 
1266 static void video_mux(struct em28xx *dev, int index)
1267 {
1268 	struct v4l2_device *v4l2_dev = &dev->v4l2->v4l2_dev;
1269 
1270 	dev->ctl_input = index;
1271 	dev->ctl_ainput = INPUT(index)->amux;
1272 	dev->ctl_aoutput = INPUT(index)->aout;
1273 
1274 	if (!dev->ctl_aoutput)
1275 		dev->ctl_aoutput = EM28XX_AOUT_MASTER;
1276 
1277 	v4l2_device_call_all(v4l2_dev, 0, video, s_routing,
1278 			     INPUT(index)->vmux, 0, 0);
1279 
1280 	if (dev->board.has_msp34xx) {
1281 		if (dev->i2s_speed) {
1282 			v4l2_device_call_all(v4l2_dev, 0, audio,
1283 					     s_i2s_clock_freq, dev->i2s_speed);
1284 		}
1285 		/* Note: this is msp3400 specific */
1286 		v4l2_device_call_all(v4l2_dev, 0, audio, s_routing,
1287 				     dev->ctl_ainput,
1288 				     MSP_OUTPUT(MSP_SC_IN_DSP_SCART1), 0);
1289 	}
1290 
1291 	if (dev->board.adecoder != EM28XX_NOADECODER) {
1292 		v4l2_device_call_all(v4l2_dev, 0, audio, s_routing,
1293 				     dev->ctl_ainput, dev->ctl_aoutput, 0);
1294 	}
1295 
1296 	em28xx_audio_analog_set(dev);
1297 }
1298 
1299 static void em28xx_ctrl_notify(struct v4l2_ctrl *ctrl, void *priv)
1300 {
1301 	struct em28xx *dev = priv;
1302 
1303 	/*
1304 	 * In the case of non-AC97 volume controls, we still need
1305 	 * to do some setups at em28xx, in order to mute/unmute
1306 	 * and to adjust audio volume. However, the value ranges
1307 	 * should be checked by the corresponding V4L subdriver.
1308 	 */
1309 	switch (ctrl->id) {
1310 	case V4L2_CID_AUDIO_MUTE:
1311 		dev->mute = ctrl->val;
1312 		em28xx_audio_analog_set(dev);
1313 		break;
1314 	case V4L2_CID_AUDIO_VOLUME:
1315 		dev->volume = ctrl->val;
1316 		em28xx_audio_analog_set(dev);
1317 		break;
1318 	}
1319 }
1320 
1321 static int em28xx_s_ctrl(struct v4l2_ctrl *ctrl)
1322 {
1323 	struct em28xx_v4l2 *v4l2 =
1324 		  container_of(ctrl->handler, struct em28xx_v4l2, ctrl_handler);
1325 	struct em28xx *dev = v4l2->dev;
1326 	int ret = -EINVAL;
1327 
1328 	switch (ctrl->id) {
1329 	case V4L2_CID_AUDIO_MUTE:
1330 		dev->mute = ctrl->val;
1331 		ret = em28xx_audio_analog_set(dev);
1332 		break;
1333 	case V4L2_CID_AUDIO_VOLUME:
1334 		dev->volume = ctrl->val;
1335 		ret = em28xx_audio_analog_set(dev);
1336 		break;
1337 	case V4L2_CID_CONTRAST:
1338 		ret = em28xx_write_reg(dev, EM28XX_R20_YGAIN, ctrl->val);
1339 		break;
1340 	case V4L2_CID_BRIGHTNESS:
1341 		ret = em28xx_write_reg(dev, EM28XX_R21_YOFFSET, ctrl->val);
1342 		break;
1343 	case V4L2_CID_SATURATION:
1344 		ret = em28xx_write_reg(dev, EM28XX_R22_UVGAIN, ctrl->val);
1345 		break;
1346 	case V4L2_CID_BLUE_BALANCE:
1347 		ret = em28xx_write_reg(dev, EM28XX_R23_UOFFSET, ctrl->val);
1348 		break;
1349 	case V4L2_CID_RED_BALANCE:
1350 		ret = em28xx_write_reg(dev, EM28XX_R24_VOFFSET, ctrl->val);
1351 		break;
1352 	case V4L2_CID_SHARPNESS:
1353 		ret = em28xx_write_reg(dev, EM28XX_R25_SHARPNESS, ctrl->val);
1354 		break;
1355 	}
1356 
1357 	return (ret < 0) ? ret : 0;
1358 }
1359 
1360 static const struct v4l2_ctrl_ops em28xx_ctrl_ops = {
1361 	.s_ctrl = em28xx_s_ctrl,
1362 };
1363 
1364 static void size_to_scale(struct em28xx *dev,
1365 			  unsigned int width, unsigned int height,
1366 			unsigned int *hscale, unsigned int *vscale)
1367 {
1368 	unsigned int          maxw = norm_maxw(dev);
1369 	unsigned int          maxh = norm_maxh(dev);
1370 
1371 	*hscale = (((unsigned long)maxw) << 12) / width - 4096L;
1372 	if (*hscale > EM28XX_HVSCALE_MAX)
1373 		*hscale = EM28XX_HVSCALE_MAX;
1374 
1375 	*vscale = (((unsigned long)maxh) << 12) / height - 4096L;
1376 	if (*vscale > EM28XX_HVSCALE_MAX)
1377 		*vscale = EM28XX_HVSCALE_MAX;
1378 }
1379 
1380 static void scale_to_size(struct em28xx *dev,
1381 			  unsigned int hscale, unsigned int vscale,
1382 			  unsigned int *width, unsigned int *height)
1383 {
1384 	unsigned int          maxw = norm_maxw(dev);
1385 	unsigned int          maxh = norm_maxh(dev);
1386 
1387 	*width = (((unsigned long)maxw) << 12) / (hscale + 4096L);
1388 	*height = (((unsigned long)maxh) << 12) / (vscale + 4096L);
1389 
1390 	/* Don't let width or height to be zero */
1391 	if (*width < 1)
1392 		*width = 1;
1393 	if (*height < 1)
1394 		*height = 1;
1395 }
1396 
1397 /* ------------------------------------------------------------------
1398 	IOCTL vidioc handling
1399    ------------------------------------------------------------------*/
1400 
1401 static int vidioc_g_fmt_vid_cap(struct file *file, void *priv,
1402 				struct v4l2_format *f)
1403 {
1404 	struct em28xx         *dev = video_drvdata(file);
1405 	struct em28xx_v4l2    *v4l2 = dev->v4l2;
1406 
1407 	f->fmt.pix.width = v4l2->width;
1408 	f->fmt.pix.height = v4l2->height;
1409 	f->fmt.pix.pixelformat = v4l2->format->fourcc;
1410 	f->fmt.pix.bytesperline = (v4l2->width * v4l2->format->depth + 7) >> 3;
1411 	f->fmt.pix.sizeimage = f->fmt.pix.bytesperline * v4l2->height;
1412 	f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
1413 
1414 	/* FIXME: TOP? NONE? BOTTOM? ALTENATE? */
1415 	if (v4l2->progressive)
1416 		f->fmt.pix.field = V4L2_FIELD_NONE;
1417 	else
1418 		f->fmt.pix.field = v4l2->interlaced_fieldmode ?
1419 			   V4L2_FIELD_INTERLACED : V4L2_FIELD_TOP;
1420 	return 0;
1421 }
1422 
1423 static struct em28xx_fmt *format_by_fourcc(unsigned int fourcc)
1424 {
1425 	unsigned int i;
1426 
1427 	for (i = 0; i < ARRAY_SIZE(format); i++)
1428 		if (format[i].fourcc == fourcc)
1429 			return &format[i];
1430 
1431 	return NULL;
1432 }
1433 
1434 static int vidioc_try_fmt_vid_cap(struct file *file, void *priv,
1435 				  struct v4l2_format *f)
1436 {
1437 	struct em28xx         *dev   = video_drvdata(file);
1438 	struct em28xx_v4l2    *v4l2  = dev->v4l2;
1439 	unsigned int          width  = f->fmt.pix.width;
1440 	unsigned int          height = f->fmt.pix.height;
1441 	unsigned int          maxw   = norm_maxw(dev);
1442 	unsigned int          maxh   = norm_maxh(dev);
1443 	unsigned int          hscale, vscale;
1444 	struct em28xx_fmt     *fmt;
1445 
1446 	fmt = format_by_fourcc(f->fmt.pix.pixelformat);
1447 	if (!fmt) {
1448 		em28xx_videodbg("Fourcc format (%08x) invalid.\n",
1449 				f->fmt.pix.pixelformat);
1450 		return -EINVAL;
1451 	}
1452 
1453 	if (dev->board.is_em2800) {
1454 		/* the em2800 can only scale down to 50% */
1455 		height = height > (3 * maxh / 4) ? maxh : maxh / 2;
1456 		width = width > (3 * maxw / 4) ? maxw : maxw / 2;
1457 		/*
1458 		 * MaxPacketSize for em2800 is too small to capture at full
1459 		 * resolution use half of maxw as the scaler can only scale
1460 		 * to 50%
1461 		 */
1462 		if (width == maxw && height == maxh)
1463 			width /= 2;
1464 	} else {
1465 		/* width must even because of the YUYV format
1466 		   height must be even because of interlacing */
1467 		v4l_bound_align_image(&width, 48, maxw, 1, &height, 32, maxh,
1468 				      1, 0);
1469 	}
1470 	/* Avoid division by zero at size_to_scale */
1471 	if (width < 1)
1472 		width = 1;
1473 	if (height < 1)
1474 		height = 1;
1475 
1476 	size_to_scale(dev, width, height, &hscale, &vscale);
1477 	scale_to_size(dev, hscale, vscale, &width, &height);
1478 
1479 	f->fmt.pix.width = width;
1480 	f->fmt.pix.height = height;
1481 	f->fmt.pix.pixelformat = fmt->fourcc;
1482 	f->fmt.pix.bytesperline = (width * fmt->depth + 7) >> 3;
1483 	f->fmt.pix.sizeimage = f->fmt.pix.bytesperline * height;
1484 	f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
1485 	if (v4l2->progressive)
1486 		f->fmt.pix.field = V4L2_FIELD_NONE;
1487 	else
1488 		f->fmt.pix.field = v4l2->interlaced_fieldmode ?
1489 			   V4L2_FIELD_INTERLACED : V4L2_FIELD_TOP;
1490 	f->fmt.pix.priv = 0;
1491 
1492 	return 0;
1493 }
1494 
1495 static int em28xx_set_video_format(struct em28xx *dev, unsigned int fourcc,
1496 				   unsigned width, unsigned height)
1497 {
1498 	struct em28xx_fmt     *fmt;
1499 	struct em28xx_v4l2    *v4l2 = dev->v4l2;
1500 
1501 	fmt = format_by_fourcc(fourcc);
1502 	if (!fmt)
1503 		return -EINVAL;
1504 
1505 	v4l2->format = fmt;
1506 	v4l2->width  = width;
1507 	v4l2->height = height;
1508 
1509 	/* set new image size */
1510 	size_to_scale(dev, v4l2->width, v4l2->height,
1511 		      &v4l2->hscale, &v4l2->vscale);
1512 
1513 	em28xx_resolution_set(dev);
1514 
1515 	return 0;
1516 }
1517 
1518 static int vidioc_s_fmt_vid_cap(struct file *file, void *priv,
1519 				struct v4l2_format *f)
1520 {
1521 	struct em28xx *dev = video_drvdata(file);
1522 	struct em28xx_v4l2 *v4l2 = dev->v4l2;
1523 
1524 	if (vb2_is_busy(&v4l2->vb_vidq))
1525 		return -EBUSY;
1526 
1527 	vidioc_try_fmt_vid_cap(file, priv, f);
1528 
1529 	return em28xx_set_video_format(dev, f->fmt.pix.pixelformat,
1530 				f->fmt.pix.width, f->fmt.pix.height);
1531 }
1532 
1533 static int vidioc_g_std(struct file *file, void *priv, v4l2_std_id *norm)
1534 {
1535 	struct em28xx *dev = video_drvdata(file);
1536 
1537 	*norm = dev->v4l2->norm;
1538 
1539 	return 0;
1540 }
1541 
1542 static int vidioc_querystd(struct file *file, void *priv, v4l2_std_id *norm)
1543 {
1544 	struct em28xx *dev = video_drvdata(file);
1545 
1546 	v4l2_device_call_all(&dev->v4l2->v4l2_dev, 0, video, querystd, norm);
1547 
1548 	return 0;
1549 }
1550 
1551 static int vidioc_s_std(struct file *file, void *priv, v4l2_std_id norm)
1552 {
1553 	struct em28xx      *dev  = video_drvdata(file);
1554 	struct em28xx_v4l2 *v4l2 = dev->v4l2;
1555 	struct v4l2_format f;
1556 
1557 	if (norm == v4l2->norm)
1558 		return 0;
1559 
1560 	if (v4l2->streaming_users > 0)
1561 		return -EBUSY;
1562 
1563 	v4l2->norm = norm;
1564 
1565 	/* Adjusts width/height, if needed */
1566 	f.fmt.pix.width = 720;
1567 	f.fmt.pix.height = (norm & V4L2_STD_525_60) ? 480 : 576;
1568 	vidioc_try_fmt_vid_cap(file, priv, &f);
1569 
1570 	/* set new image size */
1571 	v4l2->width = f.fmt.pix.width;
1572 	v4l2->height = f.fmt.pix.height;
1573 	size_to_scale(dev, v4l2->width, v4l2->height,
1574 		      &v4l2->hscale, &v4l2->vscale);
1575 
1576 	em28xx_resolution_set(dev);
1577 	v4l2_device_call_all(&v4l2->v4l2_dev, 0, video, s_std, v4l2->norm);
1578 
1579 	return 0;
1580 }
1581 
1582 static int vidioc_g_parm(struct file *file, void *priv,
1583 			 struct v4l2_streamparm *p)
1584 {
1585 	struct em28xx      *dev  = video_drvdata(file);
1586 	struct em28xx_v4l2 *v4l2 = dev->v4l2;
1587 	int rc = 0;
1588 
1589 	p->parm.capture.readbuffers = EM28XX_MIN_BUF;
1590 	if (dev->board.is_webcam)
1591 		rc = v4l2_device_call_until_err(&v4l2->v4l2_dev, 0,
1592 						video, g_parm, p);
1593 	else
1594 		v4l2_video_std_frame_period(v4l2->norm,
1595 					    &p->parm.capture.timeperframe);
1596 
1597 	return rc;
1598 }
1599 
1600 static int vidioc_s_parm(struct file *file, void *priv,
1601 			 struct v4l2_streamparm *p)
1602 {
1603 	struct em28xx *dev = video_drvdata(file);
1604 
1605 	p->parm.capture.readbuffers = EM28XX_MIN_BUF;
1606 	return v4l2_device_call_until_err(&dev->v4l2->v4l2_dev,
1607 					  0, video, s_parm, p);
1608 }
1609 
1610 static int vidioc_enum_input(struct file *file, void *priv,
1611 			     struct v4l2_input *i)
1612 {
1613 	struct em28xx *dev = video_drvdata(file);
1614 	unsigned int       n;
1615 
1616 	n = i->index;
1617 	if (n >= MAX_EM28XX_INPUT)
1618 		return -EINVAL;
1619 	if (0 == INPUT(n)->type)
1620 		return -EINVAL;
1621 
1622 	i->index = n;
1623 	i->type = V4L2_INPUT_TYPE_CAMERA;
1624 
1625 	strcpy(i->name, iname[INPUT(n)->type]);
1626 
1627 	if ((EM28XX_VMUX_TELEVISION == INPUT(n)->type))
1628 		i->type = V4L2_INPUT_TYPE_TUNER;
1629 
1630 	i->std = dev->v4l2->vdev.tvnorms;
1631 	/* webcams do not have the STD API */
1632 	if (dev->board.is_webcam)
1633 		i->capabilities = 0;
1634 
1635 	return 0;
1636 }
1637 
1638 static int vidioc_g_input(struct file *file, void *priv, unsigned int *i)
1639 {
1640 	struct em28xx *dev = video_drvdata(file);
1641 
1642 	*i = dev->ctl_input;
1643 
1644 	return 0;
1645 }
1646 
1647 static int vidioc_s_input(struct file *file, void *priv, unsigned int i)
1648 {
1649 	struct em28xx *dev = video_drvdata(file);
1650 
1651 	if (i >= MAX_EM28XX_INPUT)
1652 		return -EINVAL;
1653 	if (0 == INPUT(i)->type)
1654 		return -EINVAL;
1655 
1656 	video_mux(dev, i);
1657 	return 0;
1658 }
1659 
1660 static int vidioc_g_audio(struct file *file, void *priv, struct v4l2_audio *a)
1661 {
1662 	struct em28xx *dev = video_drvdata(file);
1663 
1664 	switch (a->index) {
1665 	case EM28XX_AMUX_VIDEO:
1666 		strcpy(a->name, "Television");
1667 		break;
1668 	case EM28XX_AMUX_LINE_IN:
1669 		strcpy(a->name, "Line In");
1670 		break;
1671 	case EM28XX_AMUX_VIDEO2:
1672 		strcpy(a->name, "Television alt");
1673 		break;
1674 	case EM28XX_AMUX_PHONE:
1675 		strcpy(a->name, "Phone");
1676 		break;
1677 	case EM28XX_AMUX_MIC:
1678 		strcpy(a->name, "Mic");
1679 		break;
1680 	case EM28XX_AMUX_CD:
1681 		strcpy(a->name, "CD");
1682 		break;
1683 	case EM28XX_AMUX_AUX:
1684 		strcpy(a->name, "Aux");
1685 		break;
1686 	case EM28XX_AMUX_PCM_OUT:
1687 		strcpy(a->name, "PCM");
1688 		break;
1689 	default:
1690 		return -EINVAL;
1691 	}
1692 
1693 	a->index = dev->ctl_ainput;
1694 	a->capability = V4L2_AUDCAP_STEREO;
1695 
1696 	return 0;
1697 }
1698 
1699 static int vidioc_s_audio(struct file *file, void *priv, const struct v4l2_audio *a)
1700 {
1701 	struct em28xx *dev = video_drvdata(file);
1702 
1703 	if (a->index >= MAX_EM28XX_INPUT)
1704 		return -EINVAL;
1705 	if (0 == INPUT(a->index)->type)
1706 		return -EINVAL;
1707 
1708 	dev->ctl_ainput = INPUT(a->index)->amux;
1709 	dev->ctl_aoutput = INPUT(a->index)->aout;
1710 
1711 	if (!dev->ctl_aoutput)
1712 		dev->ctl_aoutput = EM28XX_AOUT_MASTER;
1713 
1714 	return 0;
1715 }
1716 
1717 static int vidioc_g_tuner(struct file *file, void *priv,
1718 			  struct v4l2_tuner *t)
1719 {
1720 	struct em28xx *dev = video_drvdata(file);
1721 
1722 	if (0 != t->index)
1723 		return -EINVAL;
1724 
1725 	strcpy(t->name, "Tuner");
1726 
1727 	v4l2_device_call_all(&dev->v4l2->v4l2_dev, 0, tuner, g_tuner, t);
1728 	return 0;
1729 }
1730 
1731 static int vidioc_s_tuner(struct file *file, void *priv,
1732 			  const struct v4l2_tuner *t)
1733 {
1734 	struct em28xx *dev = video_drvdata(file);
1735 
1736 	if (0 != t->index)
1737 		return -EINVAL;
1738 
1739 	v4l2_device_call_all(&dev->v4l2->v4l2_dev, 0, tuner, s_tuner, t);
1740 	return 0;
1741 }
1742 
1743 static int vidioc_g_frequency(struct file *file, void *priv,
1744 			      struct v4l2_frequency *f)
1745 {
1746 	struct em28xx         *dev = video_drvdata(file);
1747 	struct em28xx_v4l2    *v4l2 = dev->v4l2;
1748 
1749 	if (0 != f->tuner)
1750 		return -EINVAL;
1751 
1752 	f->frequency = v4l2->frequency;
1753 	return 0;
1754 }
1755 
1756 static int vidioc_s_frequency(struct file *file, void *priv,
1757 			      const struct v4l2_frequency *f)
1758 {
1759 	struct v4l2_frequency  new_freq = *f;
1760 	struct em28xx             *dev  = video_drvdata(file);
1761 	struct em28xx_v4l2        *v4l2 = dev->v4l2;
1762 
1763 	if (0 != f->tuner)
1764 		return -EINVAL;
1765 
1766 	v4l2_device_call_all(&v4l2->v4l2_dev, 0, tuner, s_frequency, f);
1767 	v4l2_device_call_all(&v4l2->v4l2_dev, 0, tuner, g_frequency, &new_freq);
1768 	v4l2->frequency = new_freq.frequency;
1769 
1770 	return 0;
1771 }
1772 
1773 #ifdef CONFIG_VIDEO_ADV_DEBUG
1774 static int vidioc_g_chip_info(struct file *file, void *priv,
1775 			      struct v4l2_dbg_chip_info *chip)
1776 {
1777 	struct em28xx *dev = video_drvdata(file);
1778 
1779 	if (chip->match.addr > 1)
1780 		return -EINVAL;
1781 	if (chip->match.addr == 1)
1782 		strlcpy(chip->name, "ac97", sizeof(chip->name));
1783 	else
1784 		strlcpy(chip->name,
1785 			dev->v4l2->v4l2_dev.name, sizeof(chip->name));
1786 	return 0;
1787 }
1788 
1789 static int em28xx_reg_len(int reg)
1790 {
1791 	switch (reg) {
1792 	case EM28XX_R40_AC97LSB:
1793 	case EM28XX_R30_HSCALELOW:
1794 	case EM28XX_R32_VSCALELOW:
1795 		return 2;
1796 	default:
1797 		return 1;
1798 	}
1799 }
1800 
1801 static int vidioc_g_register(struct file *file, void *priv,
1802 			     struct v4l2_dbg_register *reg)
1803 {
1804 	struct em28xx *dev = video_drvdata(file);
1805 	int ret;
1806 
1807 	if (reg->match.addr > 1)
1808 		return -EINVAL;
1809 	if (reg->match.addr) {
1810 		ret = em28xx_read_ac97(dev, reg->reg);
1811 		if (ret < 0)
1812 			return ret;
1813 
1814 		reg->val = ret;
1815 		reg->size = 1;
1816 		return 0;
1817 	}
1818 
1819 	/* Match host */
1820 	reg->size = em28xx_reg_len(reg->reg);
1821 	if (reg->size == 1) {
1822 		ret = em28xx_read_reg(dev, reg->reg);
1823 
1824 		if (ret < 0)
1825 			return ret;
1826 
1827 		reg->val = ret;
1828 	} else {
1829 		__le16 val = 0;
1830 
1831 		ret = dev->em28xx_read_reg_req_len(dev, USB_REQ_GET_STATUS,
1832 						   reg->reg, (char *)&val, 2);
1833 		if (ret < 0)
1834 			return ret;
1835 
1836 		reg->val = le16_to_cpu(val);
1837 	}
1838 
1839 	return 0;
1840 }
1841 
1842 static int vidioc_s_register(struct file *file, void *priv,
1843 			     const struct v4l2_dbg_register *reg)
1844 {
1845 	struct em28xx *dev = video_drvdata(file);
1846 	__le16 buf;
1847 
1848 	if (reg->match.addr > 1)
1849 		return -EINVAL;
1850 	if (reg->match.addr)
1851 		return em28xx_write_ac97(dev, reg->reg, reg->val);
1852 
1853 	/* Match host */
1854 	buf = cpu_to_le16(reg->val);
1855 
1856 	return em28xx_write_regs(dev, reg->reg, (char *)&buf,
1857 			       em28xx_reg_len(reg->reg));
1858 }
1859 #endif
1860 
1861 static int vidioc_querycap(struct file *file, void  *priv,
1862 			   struct v4l2_capability *cap)
1863 {
1864 	struct video_device   *vdev = video_devdata(file);
1865 	struct em28xx         *dev  = video_drvdata(file);
1866 	struct em28xx_v4l2    *v4l2 = dev->v4l2;
1867 	struct usb_device *udev = interface_to_usbdev(dev->intf);
1868 
1869 	strlcpy(cap->driver, "em28xx", sizeof(cap->driver));
1870 	strlcpy(cap->card, em28xx_boards[dev->model].name, sizeof(cap->card));
1871 	usb_make_path(udev, cap->bus_info, sizeof(cap->bus_info));
1872 
1873 	if (vdev->vfl_type == VFL_TYPE_GRABBER)
1874 		cap->device_caps = V4L2_CAP_READWRITE |
1875 			V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING;
1876 	else if (vdev->vfl_type == VFL_TYPE_RADIO)
1877 		cap->device_caps = V4L2_CAP_RADIO;
1878 	else
1879 		cap->device_caps = V4L2_CAP_READWRITE | V4L2_CAP_VBI_CAPTURE;
1880 
1881 	if (dev->int_audio_type != EM28XX_INT_AUDIO_NONE)
1882 		cap->device_caps |= V4L2_CAP_AUDIO;
1883 
1884 	if (dev->tuner_type != TUNER_ABSENT)
1885 		cap->device_caps |= V4L2_CAP_TUNER;
1886 
1887 	cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS |
1888 		V4L2_CAP_READWRITE | V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING;
1889 	if (video_is_registered(&v4l2->vbi_dev))
1890 		cap->capabilities |= V4L2_CAP_VBI_CAPTURE;
1891 	if (video_is_registered(&v4l2->radio_dev))
1892 		cap->capabilities |= V4L2_CAP_RADIO;
1893 	return 0;
1894 }
1895 
1896 static int vidioc_enum_fmt_vid_cap(struct file *file, void  *priv,
1897 				   struct v4l2_fmtdesc *f)
1898 {
1899 	if (unlikely(f->index >= ARRAY_SIZE(format)))
1900 		return -EINVAL;
1901 
1902 	strlcpy(f->description, format[f->index].name, sizeof(f->description));
1903 	f->pixelformat = format[f->index].fourcc;
1904 
1905 	return 0;
1906 }
1907 
1908 static int vidioc_enum_framesizes(struct file *file, void *priv,
1909 				  struct v4l2_frmsizeenum *fsize)
1910 {
1911 	struct em28xx         *dev = video_drvdata(file);
1912 	struct em28xx_fmt     *fmt;
1913 	unsigned int	      maxw = norm_maxw(dev);
1914 	unsigned int	      maxh = norm_maxh(dev);
1915 
1916 	fmt = format_by_fourcc(fsize->pixel_format);
1917 	if (!fmt) {
1918 		em28xx_videodbg("Fourcc format (%08x) invalid.\n",
1919 				fsize->pixel_format);
1920 		return -EINVAL;
1921 	}
1922 
1923 	if (dev->board.is_em2800) {
1924 		if (fsize->index > 1)
1925 			return -EINVAL;
1926 		fsize->type = V4L2_FRMSIZE_TYPE_DISCRETE;
1927 		fsize->discrete.width = maxw / (1 + fsize->index);
1928 		fsize->discrete.height = maxh / (1 + fsize->index);
1929 		return 0;
1930 	}
1931 
1932 	if (fsize->index != 0)
1933 		return -EINVAL;
1934 
1935 	/* Report a continuous range */
1936 	fsize->type = V4L2_FRMSIZE_TYPE_STEPWISE;
1937 	scale_to_size(dev, EM28XX_HVSCALE_MAX, EM28XX_HVSCALE_MAX,
1938 		      &fsize->stepwise.min_width, &fsize->stepwise.min_height);
1939 	if (fsize->stepwise.min_width < 48)
1940 		fsize->stepwise.min_width = 48;
1941 	if (fsize->stepwise.min_height < 38)
1942 		fsize->stepwise.min_height = 38;
1943 	fsize->stepwise.max_width = maxw;
1944 	fsize->stepwise.max_height = maxh;
1945 	fsize->stepwise.step_width = 1;
1946 	fsize->stepwise.step_height = 1;
1947 	return 0;
1948 }
1949 
1950 /* RAW VBI ioctls */
1951 
1952 static int vidioc_g_fmt_vbi_cap(struct file *file, void *priv,
1953 				struct v4l2_format *format)
1954 {
1955 	struct em28xx         *dev  = video_drvdata(file);
1956 	struct em28xx_v4l2    *v4l2 = dev->v4l2;
1957 
1958 	format->fmt.vbi.samples_per_line = v4l2->vbi_width;
1959 	format->fmt.vbi.sample_format = V4L2_PIX_FMT_GREY;
1960 	format->fmt.vbi.offset = 0;
1961 	format->fmt.vbi.flags = 0;
1962 	format->fmt.vbi.sampling_rate = 6750000 * 4 / 2;
1963 	format->fmt.vbi.count[0] = v4l2->vbi_height;
1964 	format->fmt.vbi.count[1] = v4l2->vbi_height;
1965 	memset(format->fmt.vbi.reserved, 0, sizeof(format->fmt.vbi.reserved));
1966 
1967 	/* Varies by video standard (NTSC, PAL, etc.) */
1968 	if (v4l2->norm & V4L2_STD_525_60) {
1969 		/* NTSC */
1970 		format->fmt.vbi.start[0] = 10;
1971 		format->fmt.vbi.start[1] = 273;
1972 	} else if (v4l2->norm & V4L2_STD_625_50) {
1973 		/* PAL */
1974 		format->fmt.vbi.start[0] = 6;
1975 		format->fmt.vbi.start[1] = 318;
1976 	}
1977 
1978 	return 0;
1979 }
1980 
1981 /* ----------------------------------------------------------- */
1982 /* RADIO ESPECIFIC IOCTLS                                      */
1983 /* ----------------------------------------------------------- */
1984 
1985 static int radio_g_tuner(struct file *file, void *priv,
1986 			 struct v4l2_tuner *t)
1987 {
1988 	struct em28xx *dev = video_drvdata(file);
1989 
1990 	if (unlikely(t->index > 0))
1991 		return -EINVAL;
1992 
1993 	strcpy(t->name, "Radio");
1994 
1995 	v4l2_device_call_all(&dev->v4l2->v4l2_dev, 0, tuner, g_tuner, t);
1996 
1997 	return 0;
1998 }
1999 
2000 static int radio_s_tuner(struct file *file, void *priv,
2001 			 const struct v4l2_tuner *t)
2002 {
2003 	struct em28xx *dev = video_drvdata(file);
2004 
2005 	if (0 != t->index)
2006 		return -EINVAL;
2007 
2008 	v4l2_device_call_all(&dev->v4l2->v4l2_dev, 0, tuner, s_tuner, t);
2009 
2010 	return 0;
2011 }
2012 
2013 /*
2014  * em28xx_free_v4l2() - Free struct em28xx_v4l2
2015  *
2016  * @ref: struct kref for struct em28xx_v4l2
2017  *
2018  * Called when all users of struct em28xx_v4l2 are gone
2019  */
2020 static void em28xx_free_v4l2(struct kref *ref)
2021 {
2022 	struct em28xx_v4l2 *v4l2 = container_of(ref, struct em28xx_v4l2, ref);
2023 
2024 	v4l2->dev->v4l2 = NULL;
2025 	kfree(v4l2);
2026 }
2027 
2028 /*
2029  * em28xx_v4l2_open()
2030  * inits the device and starts isoc transfer
2031  */
2032 static int em28xx_v4l2_open(struct file *filp)
2033 {
2034 	struct video_device *vdev = video_devdata(filp);
2035 	struct em28xx *dev = video_drvdata(filp);
2036 	struct em28xx_v4l2 *v4l2 = dev->v4l2;
2037 	enum v4l2_buf_type fh_type = 0;
2038 	int ret;
2039 
2040 	switch (vdev->vfl_type) {
2041 	case VFL_TYPE_GRABBER:
2042 		fh_type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
2043 		break;
2044 	case VFL_TYPE_VBI:
2045 		fh_type = V4L2_BUF_TYPE_VBI_CAPTURE;
2046 		break;
2047 	case VFL_TYPE_RADIO:
2048 		break;
2049 	default:
2050 		return -EINVAL;
2051 	}
2052 
2053 	em28xx_videodbg("open dev=%s type=%s users=%d\n",
2054 			video_device_node_name(vdev), v4l2_type_names[fh_type],
2055 			v4l2->users);
2056 
2057 	if (mutex_lock_interruptible(&dev->lock))
2058 		return -ERESTARTSYS;
2059 
2060 	ret = v4l2_fh_open(filp);
2061 	if (ret) {
2062 		dev_err(&dev->intf->dev,
2063 			"%s: v4l2_fh_open() returned error %d\n",
2064 		       __func__, ret);
2065 		mutex_unlock(&dev->lock);
2066 		return ret;
2067 	}
2068 
2069 	if (v4l2->users == 0) {
2070 		em28xx_set_mode(dev, EM28XX_ANALOG_MODE);
2071 
2072 		if (vdev->vfl_type != VFL_TYPE_RADIO)
2073 			em28xx_resolution_set(dev);
2074 
2075 		/*
2076 		 * Needed, since GPIO might have disabled power
2077 		 * of some i2c devices
2078 		 */
2079 		em28xx_wake_i2c(dev);
2080 	}
2081 
2082 	if (vdev->vfl_type == VFL_TYPE_RADIO) {
2083 		em28xx_videodbg("video_open: setting radio device\n");
2084 		v4l2_device_call_all(&v4l2->v4l2_dev, 0, tuner, s_radio);
2085 	}
2086 
2087 	kref_get(&dev->ref);
2088 	kref_get(&v4l2->ref);
2089 	v4l2->users++;
2090 
2091 	mutex_unlock(&dev->lock);
2092 
2093 	return 0;
2094 }
2095 
2096 /*
2097  * em28xx_v4l2_fini()
2098  * unregisters the v4l2,i2c and usb devices
2099  * called when the device gets disconected or at module unload
2100 */
2101 static int em28xx_v4l2_fini(struct em28xx *dev)
2102 {
2103 	struct em28xx_v4l2 *v4l2 = dev->v4l2;
2104 
2105 	if (dev->is_audio_only) {
2106 		/* Shouldn't initialize IR for this interface */
2107 		return 0;
2108 	}
2109 
2110 	if (!dev->has_video) {
2111 		/* This device does not support the v4l2 extension */
2112 		return 0;
2113 	}
2114 
2115 	if (v4l2 == NULL)
2116 		return 0;
2117 
2118 	dev_info(&dev->intf->dev, "Closing video extension\n");
2119 
2120 	mutex_lock(&dev->lock);
2121 
2122 	v4l2_device_disconnect(&v4l2->v4l2_dev);
2123 
2124 	em28xx_uninit_usb_xfer(dev, EM28XX_ANALOG_MODE);
2125 
2126 	em28xx_v4l2_media_release(dev);
2127 
2128 	if (video_is_registered(&v4l2->radio_dev)) {
2129 		dev_info(&dev->intf->dev, "V4L2 device %s deregistered\n",
2130 			video_device_node_name(&v4l2->radio_dev));
2131 		video_unregister_device(&v4l2->radio_dev);
2132 	}
2133 	if (video_is_registered(&v4l2->vbi_dev)) {
2134 		dev_info(&dev->intf->dev, "V4L2 device %s deregistered\n",
2135 			video_device_node_name(&v4l2->vbi_dev));
2136 		video_unregister_device(&v4l2->vbi_dev);
2137 	}
2138 	if (video_is_registered(&v4l2->vdev)) {
2139 		dev_info(&dev->intf->dev, "V4L2 device %s deregistered\n",
2140 			video_device_node_name(&v4l2->vdev));
2141 		video_unregister_device(&v4l2->vdev);
2142 	}
2143 
2144 	v4l2_ctrl_handler_free(&v4l2->ctrl_handler);
2145 	v4l2_device_unregister(&v4l2->v4l2_dev);
2146 
2147 	kref_put(&v4l2->ref, em28xx_free_v4l2);
2148 
2149 	mutex_unlock(&dev->lock);
2150 
2151 	kref_put(&dev->ref, em28xx_free_device);
2152 
2153 	return 0;
2154 }
2155 
2156 static int em28xx_v4l2_suspend(struct em28xx *dev)
2157 {
2158 	if (dev->is_audio_only)
2159 		return 0;
2160 
2161 	if (!dev->has_video)
2162 		return 0;
2163 
2164 	dev_info(&dev->intf->dev, "Suspending video extension\n");
2165 	em28xx_stop_urbs(dev);
2166 	return 0;
2167 }
2168 
2169 static int em28xx_v4l2_resume(struct em28xx *dev)
2170 {
2171 	if (dev->is_audio_only)
2172 		return 0;
2173 
2174 	if (!dev->has_video)
2175 		return 0;
2176 
2177 	dev_info(&dev->intf->dev, "Resuming video extension\n");
2178 	/* what do we do here */
2179 	return 0;
2180 }
2181 
2182 /*
2183  * em28xx_v4l2_close()
2184  * stops streaming and deallocates all resources allocated by the v4l2
2185  * calls and ioctls
2186  */
2187 static int em28xx_v4l2_close(struct file *filp)
2188 {
2189 	struct em28xx         *dev  = video_drvdata(filp);
2190 	struct em28xx_v4l2    *v4l2 = dev->v4l2;
2191 	struct usb_device *udev = interface_to_usbdev(dev->intf);
2192 	int              errCode;
2193 
2194 	em28xx_videodbg("users=%d\n", v4l2->users);
2195 
2196 	vb2_fop_release(filp);
2197 	mutex_lock(&dev->lock);
2198 
2199 	if (v4l2->users == 1) {
2200 		/* No sense to try to write to the device */
2201 		if (dev->disconnected)
2202 			goto exit;
2203 
2204 		/* Save some power by putting tuner to sleep */
2205 		v4l2_device_call_all(&v4l2->v4l2_dev, 0, core, s_power, 0);
2206 
2207 		/* do this before setting alternate! */
2208 		em28xx_set_mode(dev, EM28XX_SUSPEND);
2209 
2210 		/* set alternate 0 */
2211 		dev->alt = 0;
2212 		em28xx_videodbg("setting alternate 0\n");
2213 		errCode = usb_set_interface(udev, 0, 0);
2214 		if (errCode < 0) {
2215 			dev_err(&dev->intf->dev,
2216 				"cannot change alternate number to 0 (error=%i)\n",
2217 				errCode);
2218 		}
2219 	}
2220 
2221 exit:
2222 	v4l2->users--;
2223 	kref_put(&v4l2->ref, em28xx_free_v4l2);
2224 	mutex_unlock(&dev->lock);
2225 	kref_put(&dev->ref, em28xx_free_device);
2226 
2227 	return 0;
2228 }
2229 
2230 static const struct v4l2_file_operations em28xx_v4l_fops = {
2231 	.owner         = THIS_MODULE,
2232 	.open          = em28xx_v4l2_open,
2233 	.release       = em28xx_v4l2_close,
2234 	.read          = vb2_fop_read,
2235 	.poll          = vb2_fop_poll,
2236 	.mmap          = vb2_fop_mmap,
2237 	.unlocked_ioctl = video_ioctl2,
2238 };
2239 
2240 static const struct v4l2_ioctl_ops video_ioctl_ops = {
2241 	.vidioc_querycap            = vidioc_querycap,
2242 	.vidioc_enum_fmt_vid_cap    = vidioc_enum_fmt_vid_cap,
2243 	.vidioc_g_fmt_vid_cap       = vidioc_g_fmt_vid_cap,
2244 	.vidioc_try_fmt_vid_cap     = vidioc_try_fmt_vid_cap,
2245 	.vidioc_s_fmt_vid_cap       = vidioc_s_fmt_vid_cap,
2246 	.vidioc_g_fmt_vbi_cap       = vidioc_g_fmt_vbi_cap,
2247 	.vidioc_try_fmt_vbi_cap     = vidioc_g_fmt_vbi_cap,
2248 	.vidioc_s_fmt_vbi_cap       = vidioc_g_fmt_vbi_cap,
2249 	.vidioc_enum_framesizes     = vidioc_enum_framesizes,
2250 	.vidioc_g_audio             = vidioc_g_audio,
2251 	.vidioc_s_audio             = vidioc_s_audio,
2252 
2253 	.vidioc_reqbufs             = vb2_ioctl_reqbufs,
2254 	.vidioc_create_bufs         = vb2_ioctl_create_bufs,
2255 	.vidioc_prepare_buf         = vb2_ioctl_prepare_buf,
2256 	.vidioc_querybuf            = vb2_ioctl_querybuf,
2257 	.vidioc_qbuf                = vb2_ioctl_qbuf,
2258 	.vidioc_dqbuf               = vb2_ioctl_dqbuf,
2259 
2260 	.vidioc_g_std               = vidioc_g_std,
2261 	.vidioc_querystd            = vidioc_querystd,
2262 	.vidioc_s_std               = vidioc_s_std,
2263 	.vidioc_g_parm		    = vidioc_g_parm,
2264 	.vidioc_s_parm		    = vidioc_s_parm,
2265 	.vidioc_enum_input          = vidioc_enum_input,
2266 	.vidioc_g_input             = vidioc_g_input,
2267 	.vidioc_s_input             = vidioc_s_input,
2268 	.vidioc_streamon            = vb2_ioctl_streamon,
2269 	.vidioc_streamoff           = vb2_ioctl_streamoff,
2270 	.vidioc_g_tuner             = vidioc_g_tuner,
2271 	.vidioc_s_tuner             = vidioc_s_tuner,
2272 	.vidioc_g_frequency         = vidioc_g_frequency,
2273 	.vidioc_s_frequency         = vidioc_s_frequency,
2274 	.vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
2275 	.vidioc_unsubscribe_event = v4l2_event_unsubscribe,
2276 #ifdef CONFIG_VIDEO_ADV_DEBUG
2277 	.vidioc_g_chip_info         = vidioc_g_chip_info,
2278 	.vidioc_g_register          = vidioc_g_register,
2279 	.vidioc_s_register          = vidioc_s_register,
2280 #endif
2281 };
2282 
2283 static const struct video_device em28xx_video_template = {
2284 	.fops		= &em28xx_v4l_fops,
2285 	.ioctl_ops	= &video_ioctl_ops,
2286 	.release	= video_device_release_empty,
2287 	.tvnorms	= V4L2_STD_ALL,
2288 };
2289 
2290 static const struct v4l2_file_operations radio_fops = {
2291 	.owner         = THIS_MODULE,
2292 	.open          = em28xx_v4l2_open,
2293 	.release       = em28xx_v4l2_close,
2294 	.unlocked_ioctl = video_ioctl2,
2295 };
2296 
2297 static const struct v4l2_ioctl_ops radio_ioctl_ops = {
2298 	.vidioc_querycap      = vidioc_querycap,
2299 	.vidioc_g_tuner       = radio_g_tuner,
2300 	.vidioc_s_tuner       = radio_s_tuner,
2301 	.vidioc_g_frequency   = vidioc_g_frequency,
2302 	.vidioc_s_frequency   = vidioc_s_frequency,
2303 	.vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
2304 	.vidioc_unsubscribe_event = v4l2_event_unsubscribe,
2305 #ifdef CONFIG_VIDEO_ADV_DEBUG
2306 	.vidioc_g_chip_info   = vidioc_g_chip_info,
2307 	.vidioc_g_register    = vidioc_g_register,
2308 	.vidioc_s_register    = vidioc_s_register,
2309 #endif
2310 };
2311 
2312 static struct video_device em28xx_radio_template = {
2313 	.fops		= &radio_fops,
2314 	.ioctl_ops	= &radio_ioctl_ops,
2315 	.release	= video_device_release_empty,
2316 };
2317 
2318 /* I2C possible address to saa7115, tvp5150, msp3400, tvaudio */
2319 static unsigned short saa711x_addrs[] = {
2320 	0x4a >> 1, 0x48 >> 1,   /* SAA7111, SAA7111A and SAA7113 */
2321 	0x42 >> 1, 0x40 >> 1,   /* SAA7114, SAA7115 and SAA7118 */
2322 	I2C_CLIENT_END };
2323 
2324 static unsigned short tvp5150_addrs[] = {
2325 	0xb8 >> 1,
2326 	0xba >> 1,
2327 	I2C_CLIENT_END
2328 };
2329 
2330 static unsigned short msp3400_addrs[] = {
2331 	0x80 >> 1,
2332 	0x88 >> 1,
2333 	I2C_CLIENT_END
2334 };
2335 
2336 /******************************** usb interface ******************************/
2337 
2338 static void em28xx_vdev_init(struct em28xx *dev,
2339 			     struct video_device *vfd,
2340 			     const struct video_device *template,
2341 			     const char *type_name)
2342 {
2343 	*vfd		= *template;
2344 	vfd->v4l2_dev	= &dev->v4l2->v4l2_dev;
2345 	vfd->lock	= &dev->lock;
2346 	if (dev->board.is_webcam)
2347 		vfd->tvnorms = 0;
2348 
2349 	snprintf(vfd->name, sizeof(vfd->name), "%s %s",
2350 		 dev_name(&dev->intf->dev), type_name);
2351 
2352 	video_set_drvdata(vfd, dev);
2353 }
2354 
2355 static void em28xx_tuner_setup(struct em28xx *dev, unsigned short tuner_addr)
2356 {
2357 	struct em28xx_v4l2      *v4l2 = dev->v4l2;
2358 	struct v4l2_device      *v4l2_dev = &v4l2->v4l2_dev;
2359 	struct tuner_setup      tun_setup;
2360 	struct v4l2_frequency   f;
2361 
2362 	memset(&tun_setup, 0, sizeof(tun_setup));
2363 
2364 	tun_setup.mode_mask = T_ANALOG_TV | T_RADIO;
2365 	tun_setup.tuner_callback = em28xx_tuner_callback;
2366 
2367 	if (dev->board.radio.type) {
2368 		tun_setup.type = dev->board.radio.type;
2369 		tun_setup.addr = dev->board.radio_addr;
2370 
2371 		v4l2_device_call_all(v4l2_dev,
2372 				     0, tuner, s_type_addr, &tun_setup);
2373 	}
2374 
2375 	if ((dev->tuner_type != TUNER_ABSENT) && (dev->tuner_type)) {
2376 		tun_setup.type   = dev->tuner_type;
2377 		tun_setup.addr   = tuner_addr;
2378 
2379 		v4l2_device_call_all(v4l2_dev,
2380 				     0, tuner, s_type_addr, &tun_setup);
2381 	}
2382 
2383 	if (dev->board.tda9887_conf) {
2384 		struct v4l2_priv_tun_config tda9887_cfg;
2385 
2386 		tda9887_cfg.tuner = TUNER_TDA9887;
2387 		tda9887_cfg.priv = &dev->board.tda9887_conf;
2388 
2389 		v4l2_device_call_all(v4l2_dev,
2390 				     0, tuner, s_config, &tda9887_cfg);
2391 	}
2392 
2393 	if (dev->tuner_type == TUNER_XC2028) {
2394 		struct v4l2_priv_tun_config  xc2028_cfg;
2395 		struct xc2028_ctrl           ctl;
2396 
2397 		memset(&xc2028_cfg, 0, sizeof(xc2028_cfg));
2398 		memset(&ctl, 0, sizeof(ctl));
2399 
2400 		em28xx_setup_xc3028(dev, &ctl);
2401 
2402 		xc2028_cfg.tuner = TUNER_XC2028;
2403 		xc2028_cfg.priv  = &ctl;
2404 
2405 		v4l2_device_call_all(v4l2_dev, 0, tuner, s_config, &xc2028_cfg);
2406 	}
2407 
2408 	/* configure tuner */
2409 	f.tuner = 0;
2410 	f.type = V4L2_TUNER_ANALOG_TV;
2411 	f.frequency = 9076;     /* just a magic number */
2412 	v4l2->frequency = f.frequency;
2413 	v4l2_device_call_all(v4l2_dev, 0, tuner, s_frequency, &f);
2414 }
2415 
2416 static int em28xx_v4l2_init(struct em28xx *dev)
2417 {
2418 	u8 val;
2419 	int ret;
2420 	unsigned int maxw;
2421 	struct v4l2_ctrl_handler *hdl;
2422 	struct em28xx_v4l2 *v4l2;
2423 
2424 	if (dev->is_audio_only) {
2425 		/* Shouldn't initialize IR for this interface */
2426 		return 0;
2427 	}
2428 
2429 	if (!dev->has_video) {
2430 		/* This device does not support the v4l2 extension */
2431 		return 0;
2432 	}
2433 
2434 	dev_info(&dev->intf->dev, "Registering V4L2 extension\n");
2435 
2436 	mutex_lock(&dev->lock);
2437 
2438 	v4l2 = kzalloc(sizeof(struct em28xx_v4l2), GFP_KERNEL);
2439 	if (!v4l2) {
2440 		mutex_unlock(&dev->lock);
2441 		return -ENOMEM;
2442 	}
2443 	kref_init(&v4l2->ref);
2444 	v4l2->dev = dev;
2445 	dev->v4l2 = v4l2;
2446 
2447 #ifdef CONFIG_MEDIA_CONTROLLER
2448 	v4l2->v4l2_dev.mdev = dev->media_dev;
2449 #endif
2450 	ret = v4l2_device_register(&dev->intf->dev, &v4l2->v4l2_dev);
2451 	if (ret < 0) {
2452 		dev_err(&dev->intf->dev,
2453 			"Call to v4l2_device_register() failed!\n");
2454 		goto err;
2455 	}
2456 
2457 	hdl = &v4l2->ctrl_handler;
2458 	v4l2_ctrl_handler_init(hdl, 8);
2459 	v4l2->v4l2_dev.ctrl_handler = hdl;
2460 
2461 	if (dev->board.is_webcam)
2462 		v4l2->progressive = true;
2463 
2464 	/*
2465 	 * Default format, used for tvp5150 or saa711x output formats
2466 	 */
2467 	v4l2->vinmode = EM28XX_VINMODE_YUV422_CbYCrY;
2468 	v4l2->vinctl  = EM28XX_VINCTRL_INTERLACED |
2469 			EM28XX_VINCTRL_CCIR656_ENABLE;
2470 
2471 	/* request some modules */
2472 
2473 	if (dev->board.has_msp34xx)
2474 		v4l2_i2c_new_subdev(&v4l2->v4l2_dev,
2475 				    &dev->i2c_adap[dev->def_i2c_bus],
2476 				    "msp3400", 0, msp3400_addrs);
2477 
2478 	if (dev->board.decoder == EM28XX_SAA711X)
2479 		v4l2_i2c_new_subdev(&v4l2->v4l2_dev,
2480 				    &dev->i2c_adap[dev->def_i2c_bus],
2481 				    "saa7115_auto", 0, saa711x_addrs);
2482 
2483 	if (dev->board.decoder == EM28XX_TVP5150)
2484 		v4l2_i2c_new_subdev(&v4l2->v4l2_dev,
2485 				    &dev->i2c_adap[dev->def_i2c_bus],
2486 				    "tvp5150", 0, tvp5150_addrs);
2487 
2488 	if (dev->board.adecoder == EM28XX_TVAUDIO)
2489 		v4l2_i2c_new_subdev(&v4l2->v4l2_dev,
2490 				    &dev->i2c_adap[dev->def_i2c_bus],
2491 				    "tvaudio", dev->board.tvaudio_addr, NULL);
2492 
2493 	/* Initialize tuner and camera */
2494 
2495 	if (dev->board.tuner_type != TUNER_ABSENT) {
2496 		unsigned short tuner_addr = dev->board.tuner_addr;
2497 		int has_demod = (dev->board.tda9887_conf & TDA9887_PRESENT);
2498 
2499 		if (dev->board.radio.type)
2500 			v4l2_i2c_new_subdev(&v4l2->v4l2_dev,
2501 					    &dev->i2c_adap[dev->def_i2c_bus],
2502 					    "tuner", dev->board.radio_addr,
2503 					    NULL);
2504 
2505 		if (has_demod)
2506 			v4l2_i2c_new_subdev(&v4l2->v4l2_dev,
2507 					    &dev->i2c_adap[dev->def_i2c_bus],
2508 					    "tuner", 0,
2509 					    v4l2_i2c_tuner_addrs(ADDRS_DEMOD));
2510 		if (tuner_addr == 0) {
2511 			enum v4l2_i2c_tuner_type type =
2512 				has_demod ? ADDRS_TV_WITH_DEMOD : ADDRS_TV;
2513 			struct v4l2_subdev *sd;
2514 
2515 			sd = v4l2_i2c_new_subdev(&v4l2->v4l2_dev,
2516 						 &dev->i2c_adap[dev->def_i2c_bus],
2517 						 "tuner", 0,
2518 						 v4l2_i2c_tuner_addrs(type));
2519 
2520 			if (sd)
2521 				tuner_addr = v4l2_i2c_subdev_addr(sd);
2522 		} else {
2523 			v4l2_i2c_new_subdev(&v4l2->v4l2_dev,
2524 					    &dev->i2c_adap[dev->def_i2c_bus],
2525 					    "tuner", tuner_addr, NULL);
2526 		}
2527 
2528 		em28xx_tuner_setup(dev, tuner_addr);
2529 	}
2530 
2531 	if (dev->em28xx_sensor != EM28XX_NOSENSOR)
2532 		em28xx_init_camera(dev);
2533 
2534 	/* Configure audio */
2535 	ret = em28xx_audio_setup(dev);
2536 	if (ret < 0) {
2537 		dev_err(&dev->intf->dev,
2538 			"%s: Error while setting audio - error [%d]!\n",
2539 			__func__, ret);
2540 		goto unregister_dev;
2541 	}
2542 	if (dev->audio_mode.ac97 != EM28XX_NO_AC97) {
2543 		v4l2_ctrl_new_std(hdl, &em28xx_ctrl_ops,
2544 				  V4L2_CID_AUDIO_MUTE, 0, 1, 1, 1);
2545 		v4l2_ctrl_new_std(hdl, &em28xx_ctrl_ops,
2546 				  V4L2_CID_AUDIO_VOLUME, 0, 0x1f, 1, 0x1f);
2547 	} else {
2548 		/* install the em28xx notify callback */
2549 		v4l2_ctrl_notify(v4l2_ctrl_find(hdl, V4L2_CID_AUDIO_MUTE),
2550 				 em28xx_ctrl_notify, dev);
2551 		v4l2_ctrl_notify(v4l2_ctrl_find(hdl, V4L2_CID_AUDIO_VOLUME),
2552 				 em28xx_ctrl_notify, dev);
2553 	}
2554 
2555 	/* wake i2c devices */
2556 	em28xx_wake_i2c(dev);
2557 
2558 	/* init video dma queues */
2559 	INIT_LIST_HEAD(&dev->vidq.active);
2560 	INIT_LIST_HEAD(&dev->vbiq.active);
2561 
2562 	if (dev->board.has_msp34xx) {
2563 		/* Send a reset to other chips via gpio */
2564 		ret = em28xx_write_reg(dev, EM2820_R08_GPIO_CTRL, 0xf7);
2565 		if (ret < 0) {
2566 			dev_err(&dev->intf->dev,
2567 				"%s: em28xx_write_reg - msp34xx(1) failed! error [%d]\n",
2568 				__func__, ret);
2569 			goto unregister_dev;
2570 		}
2571 		msleep(3);
2572 
2573 		ret = em28xx_write_reg(dev, EM2820_R08_GPIO_CTRL, 0xff);
2574 		if (ret < 0) {
2575 			dev_err(&dev->intf->dev,
2576 				"%s: em28xx_write_reg - msp34xx(2) failed! error [%d]\n",
2577 				__func__, ret);
2578 			goto unregister_dev;
2579 		}
2580 		msleep(3);
2581 	}
2582 
2583 	/* set default norm */
2584 	v4l2->norm = V4L2_STD_PAL;
2585 	v4l2_device_call_all(&v4l2->v4l2_dev, 0, video, s_std, v4l2->norm);
2586 	v4l2->interlaced_fieldmode = EM28XX_INTERLACED_DEFAULT;
2587 
2588 	/* Analog specific initialization */
2589 	v4l2->format = &format[0];
2590 
2591 	maxw = norm_maxw(dev);
2592 	/* MaxPacketSize for em2800 is too small to capture at full resolution
2593 	 * use half of maxw as the scaler can only scale to 50% */
2594 	if (dev->board.is_em2800)
2595 		maxw /= 2;
2596 
2597 	em28xx_set_video_format(dev, format[0].fourcc,
2598 				maxw, norm_maxh(dev));
2599 
2600 	video_mux(dev, 0);
2601 
2602 	/* Audio defaults */
2603 	dev->mute = 1;
2604 	dev->volume = 0x1f;
2605 
2606 /*	em28xx_write_reg(dev, EM28XX_R0E_AUDIOSRC, 0xc0); audio register */
2607 	val = (u8)em28xx_read_reg(dev, EM28XX_R0F_XCLK);
2608 	em28xx_write_reg(dev, EM28XX_R0F_XCLK,
2609 			 (EM28XX_XCLK_AUDIO_UNMUTE | val));
2610 
2611 	em28xx_set_outfmt(dev);
2612 
2613 	/* Add image controls */
2614 	/* NOTE: at this point, the subdevices are already registered, so bridge
2615 	 * controls are only added/enabled when no subdevice provides them */
2616 	if (NULL == v4l2_ctrl_find(hdl, V4L2_CID_CONTRAST))
2617 		v4l2_ctrl_new_std(hdl, &em28xx_ctrl_ops,
2618 				  V4L2_CID_CONTRAST,
2619 				  0, 0x1f, 1, CONTRAST_DEFAULT);
2620 	if (NULL == v4l2_ctrl_find(hdl, V4L2_CID_BRIGHTNESS))
2621 		v4l2_ctrl_new_std(hdl, &em28xx_ctrl_ops,
2622 				  V4L2_CID_BRIGHTNESS,
2623 				  -0x80, 0x7f, 1, BRIGHTNESS_DEFAULT);
2624 	if (NULL == v4l2_ctrl_find(hdl, V4L2_CID_SATURATION))
2625 		v4l2_ctrl_new_std(hdl, &em28xx_ctrl_ops,
2626 				  V4L2_CID_SATURATION,
2627 				  0, 0x1f, 1, SATURATION_DEFAULT);
2628 	if (NULL == v4l2_ctrl_find(hdl, V4L2_CID_BLUE_BALANCE))
2629 		v4l2_ctrl_new_std(hdl, &em28xx_ctrl_ops,
2630 				  V4L2_CID_BLUE_BALANCE,
2631 				  -0x30, 0x30, 1, BLUE_BALANCE_DEFAULT);
2632 	if (NULL == v4l2_ctrl_find(hdl, V4L2_CID_RED_BALANCE))
2633 		v4l2_ctrl_new_std(hdl, &em28xx_ctrl_ops,
2634 				  V4L2_CID_RED_BALANCE,
2635 				  -0x30, 0x30, 1, RED_BALANCE_DEFAULT);
2636 	if (NULL == v4l2_ctrl_find(hdl, V4L2_CID_SHARPNESS))
2637 		v4l2_ctrl_new_std(hdl, &em28xx_ctrl_ops,
2638 				  V4L2_CID_SHARPNESS,
2639 				  0, 0x0f, 1, SHARPNESS_DEFAULT);
2640 
2641 	/* Reset image controls */
2642 	em28xx_colorlevels_set_default(dev);
2643 	v4l2_ctrl_handler_setup(hdl);
2644 	ret = hdl->error;
2645 	if (ret)
2646 		goto unregister_dev;
2647 
2648 	/* allocate and fill video video_device struct */
2649 	em28xx_vdev_init(dev, &v4l2->vdev, &em28xx_video_template, "video");
2650 	mutex_init(&v4l2->vb_queue_lock);
2651 	mutex_init(&v4l2->vb_vbi_queue_lock);
2652 	v4l2->vdev.queue = &v4l2->vb_vidq;
2653 	v4l2->vdev.queue->lock = &v4l2->vb_queue_lock;
2654 
2655 	/* disable inapplicable ioctls */
2656 	if (dev->board.is_webcam) {
2657 		v4l2_disable_ioctl(&v4l2->vdev, VIDIOC_QUERYSTD);
2658 		v4l2_disable_ioctl(&v4l2->vdev, VIDIOC_G_STD);
2659 		v4l2_disable_ioctl(&v4l2->vdev, VIDIOC_S_STD);
2660 	} else {
2661 		v4l2_disable_ioctl(&v4l2->vdev, VIDIOC_S_PARM);
2662 	}
2663 	if (dev->tuner_type == TUNER_ABSENT) {
2664 		v4l2_disable_ioctl(&v4l2->vdev, VIDIOC_G_TUNER);
2665 		v4l2_disable_ioctl(&v4l2->vdev, VIDIOC_S_TUNER);
2666 		v4l2_disable_ioctl(&v4l2->vdev, VIDIOC_G_FREQUENCY);
2667 		v4l2_disable_ioctl(&v4l2->vdev, VIDIOC_S_FREQUENCY);
2668 	}
2669 	if (dev->int_audio_type == EM28XX_INT_AUDIO_NONE) {
2670 		v4l2_disable_ioctl(&v4l2->vdev, VIDIOC_G_AUDIO);
2671 		v4l2_disable_ioctl(&v4l2->vdev, VIDIOC_S_AUDIO);
2672 	}
2673 
2674 	/* register v4l2 video video_device */
2675 	ret = video_register_device(&v4l2->vdev, VFL_TYPE_GRABBER,
2676 				    video_nr[dev->devno]);
2677 	if (ret) {
2678 		dev_err(&dev->intf->dev,
2679 			"unable to register video device (error=%i).\n", ret);
2680 		goto unregister_dev;
2681 	}
2682 
2683 	/* Allocate and fill vbi video_device struct */
2684 	if (em28xx_vbi_supported(dev) == 1) {
2685 		em28xx_vdev_init(dev, &v4l2->vbi_dev, &em28xx_video_template,
2686 				"vbi");
2687 
2688 		v4l2->vbi_dev.queue = &v4l2->vb_vbiq;
2689 		v4l2->vbi_dev.queue->lock = &v4l2->vb_vbi_queue_lock;
2690 
2691 		/* disable inapplicable ioctls */
2692 		v4l2_disable_ioctl(&v4l2->vbi_dev, VIDIOC_S_PARM);
2693 		if (dev->tuner_type == TUNER_ABSENT) {
2694 			v4l2_disable_ioctl(&v4l2->vbi_dev, VIDIOC_G_TUNER);
2695 			v4l2_disable_ioctl(&v4l2->vbi_dev, VIDIOC_S_TUNER);
2696 			v4l2_disable_ioctl(&v4l2->vbi_dev, VIDIOC_G_FREQUENCY);
2697 			v4l2_disable_ioctl(&v4l2->vbi_dev, VIDIOC_S_FREQUENCY);
2698 		}
2699 		if (dev->int_audio_type == EM28XX_INT_AUDIO_NONE) {
2700 			v4l2_disable_ioctl(&v4l2->vbi_dev, VIDIOC_G_AUDIO);
2701 			v4l2_disable_ioctl(&v4l2->vbi_dev, VIDIOC_S_AUDIO);
2702 		}
2703 
2704 		/* register v4l2 vbi video_device */
2705 		ret = video_register_device(&v4l2->vbi_dev, VFL_TYPE_VBI,
2706 					    vbi_nr[dev->devno]);
2707 		if (ret < 0) {
2708 			dev_err(&dev->intf->dev,
2709 				"unable to register vbi device\n");
2710 			goto unregister_dev;
2711 		}
2712 	}
2713 
2714 	if (em28xx_boards[dev->model].radio.type == EM28XX_RADIO) {
2715 		em28xx_vdev_init(dev, &v4l2->radio_dev, &em28xx_radio_template,
2716 				   "radio");
2717 		ret = video_register_device(&v4l2->radio_dev, VFL_TYPE_RADIO,
2718 					    radio_nr[dev->devno]);
2719 		if (ret < 0) {
2720 			dev_err(&dev->intf->dev,
2721 				"can't register radio device\n");
2722 			goto unregister_dev;
2723 		}
2724 		dev_info(&dev->intf->dev,
2725 			 "Registered radio device as %s\n",
2726 			 video_device_node_name(&v4l2->radio_dev));
2727 	}
2728 
2729 	/* Init entities at the Media Controller */
2730 	em28xx_v4l2_create_entities(dev);
2731 
2732 #ifdef CONFIG_MEDIA_CONTROLLER
2733 	ret = v4l2_mc_create_media_graph(dev->media_dev);
2734 	if (ret) {
2735 		dev_err(&dev->intf->dev,
2736 			"failed to create media graph\n");
2737 		em28xx_v4l2_media_release(dev);
2738 		goto unregister_dev;
2739 	}
2740 #endif
2741 
2742 	dev_info(&dev->intf->dev,
2743 		 "V4L2 video device registered as %s\n",
2744 		 video_device_node_name(&v4l2->vdev));
2745 
2746 	if (video_is_registered(&v4l2->vbi_dev))
2747 		dev_info(&dev->intf->dev,
2748 			 "V4L2 VBI device registered as %s\n",
2749 			 video_device_node_name(&v4l2->vbi_dev));
2750 
2751 	/* Save some power by putting tuner to sleep */
2752 	v4l2_device_call_all(&v4l2->v4l2_dev, 0, core, s_power, 0);
2753 
2754 	/* initialize videobuf2 stuff */
2755 	em28xx_vb2_setup(dev);
2756 
2757 	dev_info(&dev->intf->dev,
2758 		 "V4L2 extension successfully initialized\n");
2759 
2760 	kref_get(&dev->ref);
2761 
2762 	mutex_unlock(&dev->lock);
2763 	return 0;
2764 
2765 unregister_dev:
2766 	if (video_is_registered(&v4l2->radio_dev)) {
2767 		dev_info(&dev->intf->dev,
2768 			 "V4L2 device %s deregistered\n",
2769 			 video_device_node_name(&v4l2->radio_dev));
2770 		video_unregister_device(&v4l2->radio_dev);
2771 	}
2772 	if (video_is_registered(&v4l2->vbi_dev)) {
2773 		dev_info(&dev->intf->dev,
2774 			 "V4L2 device %s deregistered\n",
2775 			 video_device_node_name(&v4l2->vbi_dev));
2776 		video_unregister_device(&v4l2->vbi_dev);
2777 	}
2778 	if (video_is_registered(&v4l2->vdev)) {
2779 		dev_info(&dev->intf->dev,
2780 			 "V4L2 device %s deregistered\n",
2781 			 video_device_node_name(&v4l2->vdev));
2782 		video_unregister_device(&v4l2->vdev);
2783 	}
2784 
2785 	v4l2_ctrl_handler_free(&v4l2->ctrl_handler);
2786 	v4l2_device_unregister(&v4l2->v4l2_dev);
2787 err:
2788 	dev->v4l2 = NULL;
2789 	kref_put(&v4l2->ref, em28xx_free_v4l2);
2790 	mutex_unlock(&dev->lock);
2791 	return ret;
2792 }
2793 
2794 static struct em28xx_ops v4l2_ops = {
2795 	.id   = EM28XX_V4L2,
2796 	.name = "Em28xx v4l2 Extension",
2797 	.init = em28xx_v4l2_init,
2798 	.fini = em28xx_v4l2_fini,
2799 	.suspend = em28xx_v4l2_suspend,
2800 	.resume = em28xx_v4l2_resume,
2801 };
2802 
2803 static int __init em28xx_video_register(void)
2804 {
2805 	return em28xx_register_extension(&v4l2_ops);
2806 }
2807 
2808 static void __exit em28xx_video_unregister(void)
2809 {
2810 	em28xx_unregister_extension(&v4l2_ops);
2811 }
2812 
2813 module_init(em28xx_video_register);
2814 module_exit(em28xx_video_unregister);
2815