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