em28xx-video.c 74.3 KB
Newer Older
1 2 3 4 5 6 7
// SPDX-License-Identifier: GPL-2.0+
//
// em28xx-video.c - driver for Empia EM2800/EM2820/2840 USB
//		    video capture devices
//
// Copyright (C) 2005 Ludovico Cavedon <cavedon@sssup.it>
//		      Markus Rechberger <mrechberger@gmail.com>
8
//		      Mauro Carvalho Chehab <mchehab@kernel.org>
9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
//		      Sascha Sommer <saschasommer@freenet.de>
// Copyright (C) 2012 Frank Schäfer <fschaefer.oss@googlemail.com>
//
//	Some parts based on SN9C10x PC Camera Controllers GPL driver made
//		by Luca Risolia <luca.risolia@studio.unibo.it>
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
24

25 26
#include "em28xx.h"

27 28 29 30
#include <linux/init.h>
#include <linux/list.h>
#include <linux/module.h>
#include <linux/kernel.h>
31
#include <linux/bitmap.h>
32 33
#include <linux/usb.h>
#include <linux/i2c.h>
34
#include <linux/mm.h>
35
#include <linux/mutex.h>
36
#include <linux/slab.h>
37

38
#include "em28xx-v4l.h"
39
#include <media/v4l2-common.h>
40
#include <media/v4l2-ioctl.h>
41
#include <media/v4l2-event.h>
42
#include <media/drv-intf/msp3400.h>
43
#include <media/tuner.h>
44

45 46
#define DRIVER_AUTHOR "Ludovico Cavedon <cavedon@sssup.it>, " \
		      "Markus Rechberger <mrechberger@gmail.com>, " \
47
		      "Mauro Carvalho Chehab <mchehab@kernel.org>, " \
48
		      "Sascha Sommer <saschasommer@freenet.de>"
49

50 51 52 53 54 55 56 57 58 59 60 61
static unsigned int isoc_debug;
module_param(isoc_debug, int, 0644);
MODULE_PARM_DESC(isoc_debug, "enable debug messages [isoc transfers]");

static unsigned int disable_vbi;
module_param(disable_vbi, int, 0644);
MODULE_PARM_DESC(disable_vbi, "disable vbi support");

static int alt;
module_param(alt, int, 0644);
MODULE_PARM_DESC(alt, "alternate setting to use for video endpoint");

62 63
#define em28xx_videodbg(fmt, arg...) do {				\
	if (video_debug)						\
64
		dev_printk(KERN_DEBUG, &dev->intf->dev,			\
65 66
			   "video: %s: " fmt, __func__, ## arg);	\
} while (0)
67

68 69
#define em28xx_isocdbg(fmt, arg...) do {\
	if (isoc_debug) \
70
		dev_printk(KERN_DEBUG, &dev->intf->dev,			\
71 72
			   "isoc: %s: " fmt, __func__, ## arg);		\
} while (0)
73

74
MODULE_AUTHOR(DRIVER_AUTHOR);
75
MODULE_DESCRIPTION(DRIVER_DESC " - v4l2 interface");
76
MODULE_LICENSE("GPL v2");
77
MODULE_VERSION(EM28XX_VERSION);
78

79 80 81 82 83 84 85 86
#define EM25XX_FRMDATAHDR_BYTE1			0x02
#define EM25XX_FRMDATAHDR_BYTE2_STILL_IMAGE	0x20
#define EM25XX_FRMDATAHDR_BYTE2_FRAME_END	0x02
#define EM25XX_FRMDATAHDR_BYTE2_FRAME_ID	0x01
#define EM25XX_FRMDATAHDR_BYTE2_MASK	(EM25XX_FRMDATAHDR_BYTE2_STILL_IMAGE | \
					 EM25XX_FRMDATAHDR_BYTE2_FRAME_END |   \
					 EM25XX_FRMDATAHDR_BYTE2_FRAME_ID)

87 88 89
static unsigned int video_nr[] = {[0 ... (EM28XX_MAXBOARDS - 1)] = -1U };
static unsigned int vbi_nr[]   = {[0 ... (EM28XX_MAXBOARDS - 1)] = -1U };
static unsigned int radio_nr[] = {[0 ... (EM28XX_MAXBOARDS - 1)] = -1U };
90

91 92
module_param_array(video_nr, int, NULL, 0444);
module_param_array(vbi_nr, int, NULL, 0444);
93 94 95 96
module_param_array(radio_nr, int, NULL, 0444);
MODULE_PARM_DESC(video_nr, "video device numbers");
MODULE_PARM_DESC(vbi_nr,   "vbi device numbers");
MODULE_PARM_DESC(radio_nr, "radio device numbers");
97

98
static unsigned int video_debug;
99 100
module_param(video_debug, int, 0644);
MODULE_PARM_DESC(video_debug, "enable debug messages [video]");
101

102 103 104
/* supported video standards */
static struct em28xx_fmt format[] = {
	{
105
		.name     = "16 bpp YUY2, 4:2:2, packed",
106 107
		.fourcc   = V4L2_PIX_FMT_YUYV,
		.depth    = 16,
108
		.reg	  = EM28XX_OUTFMT_YUV422_Y0UY1V,
109
	}, {
110
		.name     = "16 bpp RGB 565, LE",
111 112
		.fourcc   = V4L2_PIX_FMT_RGB565,
		.depth    = 16,
113
		.reg      = EM28XX_OUTFMT_RGB_16_656,
114 115 116 117 118
	}, {
		.name     = "8 bpp Bayer RGRG..GBGB",
		.fourcc   = V4L2_PIX_FMT_SRGGB8,
		.depth    = 8,
		.reg      = EM28XX_OUTFMT_RGB_8_RGRG,
119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138
	}, {
		.name     = "8 bpp Bayer BGBG..GRGR",
		.fourcc   = V4L2_PIX_FMT_SBGGR8,
		.depth    = 8,
		.reg      = EM28XX_OUTFMT_RGB_8_BGBG,
	}, {
		.name     = "8 bpp Bayer GRGR..BGBG",
		.fourcc   = V4L2_PIX_FMT_SGRBG8,
		.depth    = 8,
		.reg      = EM28XX_OUTFMT_RGB_8_GRGR,
	}, {
		.name     = "8 bpp Bayer GBGB..RGRG",
		.fourcc   = V4L2_PIX_FMT_SGBRG8,
		.depth    = 8,
		.reg      = EM28XX_OUTFMT_RGB_8_GBGB,
	}, {
		.name     = "12 bpp YUV411",
		.fourcc   = V4L2_PIX_FMT_YUV411P,
		.depth    = 12,
		.reg      = EM28XX_OUTFMT_YUV411,
139 140 141
	},
};

142 143 144
/*FIXME: maxw should be dependent of alt mode */
static inline unsigned int norm_maxw(struct em28xx *dev)
{
145 146
	struct em28xx_v4l2 *v4l2 = dev->v4l2;

147
	if (dev->is_webcam)
148
		return v4l2->sensor_xres;
149 150 151 152 153 154 155 156 157

	if (dev->board.max_range_640_480)
		return 640;

	return 720;
}

static inline unsigned int norm_maxh(struct em28xx *dev)
{
158 159
	struct em28xx_v4l2 *v4l2 = dev->v4l2;

160
	if (dev->is_webcam)
161
		return v4l2->sensor_yres;
162 163 164 165

	if (dev->board.max_range_640_480)
		return 480;

166
	return (v4l2->norm & V4L2_STD_625_50) ? 576 : 480;
167 168
}

169
static int em28xx_vbi_supported(struct em28xx *dev)
170 171 172 173 174
{
	/* Modprobe option to manually disable */
	if (disable_vbi == 1)
		return 0;

175
	if (dev->is_webcam)
176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191
		return 0;

	/* FIXME: check subdevices for VBI support */

	if (dev->chip_id == CHIP_ID_EM2860 ||
	    dev->chip_id == CHIP_ID_EM2883)
		return 1;

	/* Version of em28xx that does not support VBI */
	return 0;
}

/*
 * em28xx_wake_i2c()
 * configure i2c attached devices
 */
192
static void em28xx_wake_i2c(struct em28xx *dev)
193
{
194
	struct v4l2_device *v4l2_dev = &dev->v4l2->v4l2_dev;
195

196 197
	v4l2_device_call_all(v4l2_dev, 0, core,  reset, 0);
	v4l2_device_call_all(v4l2_dev, 0, video, s_routing,
198
			     INPUT(dev->ctl_input)->vmux, 0, 0);
199 200
}

201
static int em28xx_colorlevels_set_default(struct em28xx *dev)
202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218
{
	em28xx_write_reg(dev, EM28XX_R20_YGAIN, CONTRAST_DEFAULT);
	em28xx_write_reg(dev, EM28XX_R21_YOFFSET, BRIGHTNESS_DEFAULT);
	em28xx_write_reg(dev, EM28XX_R22_UVGAIN, SATURATION_DEFAULT);
	em28xx_write_reg(dev, EM28XX_R23_UOFFSET, BLUE_BALANCE_DEFAULT);
	em28xx_write_reg(dev, EM28XX_R24_VOFFSET, RED_BALANCE_DEFAULT);
	em28xx_write_reg(dev, EM28XX_R25_SHARPNESS, SHARPNESS_DEFAULT);

	em28xx_write_reg(dev, EM28XX_R14_GAMMA, 0x20);
	em28xx_write_reg(dev, EM28XX_R15_RGAIN, 0x20);
	em28xx_write_reg(dev, EM28XX_R16_GGAIN, 0x20);
	em28xx_write_reg(dev, EM28XX_R17_BGAIN, 0x20);
	em28xx_write_reg(dev, EM28XX_R18_ROFFSET, 0x00);
	em28xx_write_reg(dev, EM28XX_R19_GOFFSET, 0x00);
	return em28xx_write_reg(dev, EM28XX_R1A_BOFFSET, 0x00);
}

219
static int em28xx_set_outfmt(struct em28xx *dev)
220 221 222
{
	int ret;
	u8 fmt, vinctrl;
223
	struct em28xx_v4l2 *v4l2 = dev->v4l2;
224

225
	fmt = v4l2->format->reg;
226 227 228 229 230 231 232 233 234 235 236 237 238 239 240
	if (!dev->is_em25xx)
		fmt |= 0x20;
	/*
	 * NOTE: it's not clear if this is really needed !
	 * The datasheets say bit 5 is a reserved bit and devices seem to work
	 * fine without it. But the Windows driver sets it for em2710/50+em28xx
	 * devices and we've always been setting it, too.
	 *
	 * em2765 (em25xx, em276x/7x/8x) devices do NOT work with this bit set,
	 * it's likely used for an additional (compressed ?) format there.
	 */
	ret = em28xx_write_reg(dev, EM28XX_R27_OUTFMT, fmt);
	if (ret < 0)
		return ret;

241
	ret = em28xx_write_reg(dev, EM28XX_R10_VINMODE, v4l2->vinmode);
242 243 244
	if (ret < 0)
		return ret;

245
	vinctrl = v4l2->vinctl;
246 247 248
	if (em28xx_vbi_supported(dev) == 1) {
		vinctrl |= EM28XX_VINCTRL_VBI_RAW;
		em28xx_write_reg(dev, EM28XX_R34_VBI_START_H, 0x00);
249 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 254
			/* NTSC */
			em28xx_write_reg(dev, EM28XX_R35_VBI_START_V, 0x09);
255
		} else if (v4l2->norm & V4L2_STD_625_50) {
256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276
			/* PAL */
			em28xx_write_reg(dev, EM28XX_R35_VBI_START_V, 0x07);
		}
	}

	return em28xx_write_reg(dev, EM28XX_R11_VINCTRL, vinctrl);
}

static int em28xx_accumulator_set(struct em28xx *dev, u8 xmin, u8 xmax,
				  u8 ymin, u8 ymax)
{
	em28xx_videodbg("em28xx Scale: (%d,%d)-(%d,%d)\n",
			xmin, ymin, xmax, ymax);

	em28xx_write_regs(dev, EM28XX_R28_XMIN, &xmin, 1);
	em28xx_write_regs(dev, EM28XX_R29_XMAX, &xmax, 1);
	em28xx_write_regs(dev, EM28XX_R2A_YMIN, &ymin, 1);
	return em28xx_write_regs(dev, EM28XX_R2B_YMAX, &ymax, 1);
}

static void em28xx_capture_area_set(struct em28xx *dev, u8 hstart, u8 vstart,
277
				    u16 width, u16 height)
278 279 280 281 282 283 284
{
	u8 cwidth = width >> 2;
	u8 cheight = height >> 2;
	u8 overflow = (height >> 9 & 0x02) | (width >> 10 & 0x01);
	/* NOTE: size limit: 2047x1023 = 2MPix */

	em28xx_videodbg("capture area set to (%d,%d): %dx%d\n",
285
			hstart, vstart,
286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304
		       ((overflow & 2) << 9 | cwidth << 2),
		       ((overflow & 1) << 10 | cheight << 2));

	em28xx_write_regs(dev, EM28XX_R1C_HSTART, &hstart, 1);
	em28xx_write_regs(dev, EM28XX_R1D_VSTART, &vstart, 1);
	em28xx_write_regs(dev, EM28XX_R1E_CWIDTH, &cwidth, 1);
	em28xx_write_regs(dev, EM28XX_R1F_CHEIGHT, &cheight, 1);
	em28xx_write_regs(dev, EM28XX_R1B_OFLOW, &overflow, 1);

	/* FIXME: function/meaning of these registers ? */
	/* FIXME: align width+height to multiples of 4 ?! */
	if (dev->is_em25xx) {
		em28xx_write_reg(dev, 0x34, width >> 4);
		em28xx_write_reg(dev, 0x35, height >> 4);
	}
}

static int em28xx_scaler_set(struct em28xx *dev, u16 h, u16 v)
{
305
	u8 mode = 0x00;
306 307 308 309 310 311 312 313 314 315 316 317 318 319
	/* the em2800 scaler only supports scaling down to 50% */

	if (dev->board.is_em2800) {
		mode = (v ? 0x20 : 0x00) | (h ? 0x10 : 0x00);
	} else {
		u8 buf[2];

		buf[0] = h;
		buf[1] = h >> 8;
		em28xx_write_regs(dev, EM28XX_R30_HSCALELOW, (char *)buf, 2);

		buf[0] = v;
		buf[1] = v >> 8;
		em28xx_write_regs(dev, EM28XX_R32_VSCALELOW, (char *)buf, 2);
320 321 322 323
		/*
		 * it seems that both H and V scalers must be active
		 * to work correctly
		 */
324 325
		mode = (h || v) ? 0x30 : 0x00;
	}
326
	return em28xx_write_reg(dev, EM28XX_R26_COMPR, mode);
327 328 329
}

/* FIXME: this only function read values from dev */
330
static int em28xx_resolution_set(struct em28xx *dev)
331
{
332 333 334
	struct em28xx_v4l2 *v4l2 = dev->v4l2;
	int width = norm_maxw(dev);
	int height = norm_maxh(dev);
335 336

	/* Properly setup VBI */
337
	v4l2->vbi_width = 720;
338
	if (v4l2->norm & V4L2_STD_525_60)
339
		v4l2->vbi_height = 12;
340
	else
341
		v4l2->vbi_height = 18;
342 343 344 345 346

	em28xx_set_outfmt(dev);

	em28xx_accumulator_set(dev, 1, (width - 4) >> 2, 1, (height - 4) >> 2);

347 348 349 350 351 352 353 354 355
	/*
	 * If we don't set the start position to 2 in VBI mode, we end up
	 * with line 20/21 being YUYV encoded instead of being in 8-bit
	 * greyscale.  The core of the issue is that line 21 (and line 23 for
	 * PAL WSS) are inside of active video region, and as a result they
	 * get the pixelformatting associated with that area.  So by cropping
	 * it out, we end up with the same format as the rest of the VBI
	 * region
	 */
356 357 358 359 360
	if (em28xx_vbi_supported(dev) == 1)
		em28xx_capture_area_set(dev, 0, 2, width, height);
	else
		em28xx_capture_area_set(dev, 0, 0, width, height);

361
	return em28xx_scaler_set(dev, v4l2->hscale, v4l2->vscale);
362 363 364
}

/* Set USB alternate setting for analog video */
365
static int em28xx_set_alternate(struct em28xx *dev)
366
{
367
	struct em28xx_v4l2 *v4l2 = dev->v4l2;
368
	struct usb_device *udev = interface_to_usbdev(dev->intf);
369
	int err;
370
	int i;
371
	unsigned int min_pkt_size = v4l2->width * 2 + 4;
372

373 374 375 376
	/*
	 * NOTE: for isoc transfers, only alt settings > 0 are allowed
	 * bulk transfers seem to work only with alt=0 !
	 */
377
	dev->alt = 0;
378
	if (alt > 0 && alt < dev->num_alt) {
379 380 381 382 383 384 385
		em28xx_videodbg("alternate forced to %d\n", dev->alt);
		dev->alt = alt;
		goto set_alt;
	}
	if (dev->analog_xfer_bulk)
		goto set_alt;

386 387 388 389
	/*
	 * When image size is bigger than a certain value,
	 * the frame size should be increased, otherwise, only
	 * green screen will be received.
390
	 */
391
	if (v4l2->width * 2 * v4l2->height > 720 * 240 * 2)
392 393 394 395 396 397 398
		min_pkt_size *= 2;

	for (i = 0; i < dev->num_alt; i++) {
		/* stop when the selected alt setting offers enough bandwidth */
		if (dev->alt_max_pkt_size_isoc[i] >= min_pkt_size) {
			dev->alt = i;
			break;
399 400 401 402 403
		/*
		 * otherwise make sure that we end up with the maximum
		 * bandwidth because the min_pkt_size equation might be wrong.
		 *
		 */
404 405 406 407 408 409
		} else if (dev->alt_max_pkt_size_isoc[i] >
			   dev->alt_max_pkt_size_isoc[dev->alt])
			dev->alt = i;
	}

set_alt:
410 411
	/*
	 * NOTE: for bulk transfers, we need to call usb_set_interface()
412
	 * even if the previous settings were the same. Otherwise streaming
413 414
	 * fails with all urbs having status = -EOVERFLOW !
	 */
415 416 417 418 419
	if (dev->analog_xfer_bulk) {
		dev->max_pkt_size = 512; /* USB 2.0 spec */
		dev->packet_multiplier = EM28XX_BULK_PACKET_MULTIPLIER;
	} else { /* isoc */
		em28xx_videodbg("minimum isoc packet size: %u (alt=%d)\n",
420
				min_pkt_size, dev->alt);
421 422 423 424 425
		dev->max_pkt_size =
				  dev->alt_max_pkt_size_isoc[dev->alt];
		dev->packet_multiplier = EM28XX_NUM_ISOC_PACKETS;
	}
	em28xx_videodbg("setting alternate %d with wMaxPacketSize=%u\n",
426
			dev->alt, dev->max_pkt_size);
427 428
	err = usb_set_interface(udev, dev->ifnum, dev->alt);
	if (err < 0) {
429
		dev_err(&dev->intf->dev,
430
			"cannot change alternate number to %d (error=%i)\n",
431 432
			dev->alt, err);
		return err;
433 434 435 436
	}
	return 0;
}

437 438 439
/*
 * DMA and thread functions
 */
440 441

/*
442
 * Finish the current buffer
443
 */
444 445
static inline void finish_buffer(struct em28xx *dev,
				 struct em28xx_buffer *buf)
446
{
447 448
	em28xx_isocdbg("[%p/%d] wakeup\n", buf, buf->top_field);

449
	buf->vb.sequence = dev->v4l2->field_count++;
450
	if (dev->v4l2->progressive)
451
		buf->vb.field = V4L2_FIELD_NONE;
452
	else
453
		buf->vb.field = V4L2_FIELD_INTERLACED;
454
	buf->vb.vb2_buf.timestamp = ktime_get_ns();
455

456
	vb2_buffer_done(&buf->vb.vb2_buf, VB2_BUF_STATE_DONE);
457 458 459
}

/*
460
 * Copy picture data from USB buffer to videobuf buffer
461 462 463
 */
static void em28xx_copy_video(struct em28xx *dev,
			      struct em28xx_buffer *buf,
464
			      unsigned char *usb_buf,
465
			      unsigned long len)
466
{
467
	struct em28xx_v4l2 *v4l2 = dev->v4l2;
468
	void *fieldstart, *startwrite, *startread;
469
	int  linesdone, currlinedone, offset, lencopy, remain;
470
	int bytesperline = v4l2->width << 1;
471

472 473
	if (buf->pos + len > buf->length)
		len = buf->length - buf->pos;
474

475
	startread = usb_buf;
476 477
	remain = len;

478
	if (v4l2->progressive || buf->top_field)
479
		fieldstart = buf->vb_buf;
480
	else /* interlaced mode, even nr. of lines */
481
		fieldstart = buf->vb_buf + bytesperline;
482

483 484
	linesdone = buf->pos / bytesperline;
	currlinedone = buf->pos % bytesperline;
485

486
	if (v4l2->progressive)
487 488 489 490
		offset = linesdone * bytesperline + currlinedone;
	else
		offset = linesdone * bytesperline * 2 + currlinedone;

491
	startwrite = fieldstart + offset;
492
	lencopy = bytesperline - currlinedone;
493 494
	lencopy = lencopy > remain ? remain : lencopy;

495
	if ((char *)startwrite + lencopy > (char *)buf->vb_buf + buf->length) {
496
		em28xx_isocdbg("Overflow of %zu bytes past buffer end (1)\n",
497
			       ((char *)startwrite + lencopy) -
498 499
			      ((char *)buf->vb_buf + buf->length));
		remain = (char *)buf->vb_buf + buf->length -
500
			 (char *)startwrite;
501
		lencopy = remain;
502
	}
503 504
	if (lencopy <= 0)
		return;
505
	memcpy(startwrite, startread, lencopy);
506 507 508 509

	remain -= lencopy;

	while (remain > 0) {
510
		if (v4l2->progressive)
511 512 513
			startwrite += lencopy;
		else
			startwrite += lencopy + bytesperline;
514
		startread += lencopy;
515
		if (bytesperline > remain)
516 517
			lencopy = remain;
		else
518
			lencopy = bytesperline;
519

520
		if ((char *)startwrite + lencopy > (char *)buf->vb_buf +
521
		    buf->length) {
522
			em28xx_isocdbg("Overflow of %zu bytes past buffer end(2)\n",
523
				       ((char *)startwrite + lencopy) -
524
				       ((char *)buf->vb_buf + buf->length));
525 526 527
			remain = (char *)buf->vb_buf + buf->length -
				 (char *)startwrite;
			lencopy = remain;
528
		}
529 530
		if (lencopy <= 0)
			break;
531 532

		memcpy(startwrite, startread, lencopy);
533 534 535 536

		remain -= lencopy;
	}

537
	buf->pos += len;
538 539
}

540 541 542
/*
 * Copy VBI data from USB buffer to videobuf buffer
 */
543
static void em28xx_copy_vbi(struct em28xx *dev,
544
			    struct em28xx_buffer *buf,
545
			    unsigned char *usb_buf,
546
			    unsigned long len)
547
{
548
	unsigned int offset;
549

550 551
	if (buf->pos + len > buf->length)
		len = buf->length - buf->pos;
552

553
	offset = buf->pos;
554
	/* Make sure the bottom field populates the second half of the frame */
555
	if (buf->top_field == 0)
556
		offset += dev->v4l2->vbi_width * dev->v4l2->vbi_height;
557

558
	memcpy(buf->vb_buf + offset, usb_buf, len);
559
	buf->pos += len;
560 561
}

562
static inline void print_err_status(struct em28xx *dev,
563
				    int packet, int status)
564 565 566
{
	char *errmsg = "Unknown";

567
	switch (status) {
568
	case -ENOENT:
569
		errmsg = "unlinked synchronously";
570 571
		break;
	case -ECONNRESET:
572
		errmsg = "unlinked asynchronously";
573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592
		break;
	case -ENOSR:
		errmsg = "Buffer error (overrun)";
		break;
	case -EPIPE:
		errmsg = "Stalled (device not responding)";
		break;
	case -EOVERFLOW:
		errmsg = "Babble (bad cable?)";
		break;
	case -EPROTO:
		errmsg = "Bit-stuff error (bad cable?)";
		break;
	case -EILSEQ:
		errmsg = "CRC/Timeout (could be anything)";
		break;
	case -ETIME:
		errmsg = "Device does not respond";
		break;
	}
593
	if (packet < 0) {
594 595 596 597 598 599 600 601
		em28xx_isocdbg("URB status %d [%s].\n",	status, errmsg);
	} else {
		em28xx_isocdbg("URB packet %d, status %d [%s].\n",
			       packet, status, errmsg);
	}
}

/*
602
 * get the next available buffer from dma queue
603
 */
604 605
static inline struct em28xx_buffer *get_next_buf(struct em28xx *dev,
						 struct em28xx_dmaqueue *dma_q)
606
{
607
	struct em28xx_buffer *buf;
608

609 610
	if (list_empty(&dma_q->active)) {
		em28xx_isocdbg("No active queue to serve\n");
611
		return NULL;
612 613 614
	}

	/* Get the next buffer */
615
	buf = list_entry(dma_q->active.next, struct em28xx_buffer, list);
616
	/* Cleans up buffer - Useful for testing for frame/URB loss */
617
	list_del(&buf->list);
618
	buf->pos = 0;
619
	buf->vb_buf = buf->mem;
620

621
	return buf;
622 623
}

624 625 626 627 628 629 630 631
/*
 * Finish the current buffer if completed and prepare for the next field
 */
static struct em28xx_buffer *
finish_field_prepare_next(struct em28xx *dev,
			  struct em28xx_buffer *buf,
			  struct em28xx_dmaqueue *dma_q)
{
632 633
	struct em28xx_v4l2 *v4l2 = dev->v4l2;

634
	if (v4l2->progressive || v4l2->top_field) { /* Brand new frame */
635
		if (buf)
636 637 638
			finish_buffer(dev, buf);
		buf = get_next_buf(dev, dma_q);
	}
639
	if (buf) {
640
		buf->top_field = v4l2->top_field;
641 642 643 644 645 646
		buf->pos = 0;
	}

	return buf;
}

647 648 649 650 651 652
/*
 * Process data packet according to the em2710/em2750/em28xx frame data format
 */
static inline void process_frame_data_em28xx(struct em28xx *dev,
					     unsigned char *data_pkt,
					     unsigned int  data_len)
653
{
654
	struct em28xx_v4l2      *v4l2 = dev->v4l2;
655 656
	struct em28xx_buffer    *buf = dev->usb_ctl.vid_buf;
	struct em28xx_buffer    *vbi_buf = dev->usb_ctl.vbi_buf;
657
	struct em28xx_dmaqueue  *dma_q = &dev->vidq;
658
	struct em28xx_dmaqueue  *vbi_dma_q = &dev->vbiq;
659

660 661 662 663 664 665
	/*
	 * capture type 0 = vbi start
	 * capture type 1 = vbi in progress
	 * capture type 2 = video start
	 * capture type 3 = video in progress
	 */
666
	if (data_len >= 4) {
667 668 669 670
		/*
		 * NOTE: Headers are always 4 bytes and
		 * never split across packets
		 */
671 672 673 674 675 676 677
		if (data_pkt[0] == 0x88 && data_pkt[1] == 0x88 &&
		    data_pkt[2] == 0x88 && data_pkt[3] == 0x88) {
			/* Continuation */
			data_pkt += 4;
			data_len -= 4;
		} else if (data_pkt[0] == 0x33 && data_pkt[1] == 0x95) {
			/* Field start (VBI mode) */
678 679
			v4l2->capture_type = 0;
			v4l2->vbi_read = 0;
680
			em28xx_isocdbg("VBI START HEADER !!!\n");
681
			v4l2->top_field = !(data_pkt[2] & 1);
682 683 684 685
			data_pkt += 4;
			data_len -= 4;
		} else if (data_pkt[0] == 0x22 && data_pkt[1] == 0x5a) {
			/* Field start (VBI disabled) */
686
			v4l2->capture_type = 2;
687
			em28xx_isocdbg("VIDEO START HEADER !!!\n");
688
			v4l2->top_field = !(data_pkt[2] & 1);
689 690 691 692
			data_pkt += 4;
			data_len -= 4;
		}
	}
693 694 695 696
	/*
	 * NOTE: With bulk transfers, intermediate data packets
	 * have no continuation header
	 */
697

698
	if (v4l2->capture_type == 0) {
699 700
		vbi_buf = finish_field_prepare_next(dev, vbi_buf, vbi_dma_q);
		dev->usb_ctl.vbi_buf = vbi_buf;
701
		v4l2->capture_type = 1;
702 703
	}

704
	if (v4l2->capture_type == 1) {
705
		int vbi_size = v4l2->vbi_width * v4l2->vbi_height;
706 707
		int vbi_data_len = ((v4l2->vbi_read + data_len) > vbi_size) ?
				   (vbi_size - v4l2->vbi_read) : data_len;
708 709

		/* Copy VBI data */
710
		if (vbi_buf)
711
			em28xx_copy_vbi(dev, vbi_buf, data_pkt, vbi_data_len);
712
		v4l2->vbi_read += vbi_data_len;
713 714 715

		if (vbi_data_len < data_len) {
			/* Continue with copying video data */
716
			v4l2->capture_type = 2;
717 718 719 720 721
			data_pkt += vbi_data_len;
			data_len -= vbi_data_len;
		}
	}

722
	if (v4l2->capture_type == 2) {
723 724
		buf = finish_field_prepare_next(dev, buf, dma_q);
		dev->usb_ctl.vid_buf = buf;
725
		v4l2->capture_type = 3;
726 727
	}

728
	if (v4l2->capture_type == 3 && buf && data_len > 0)
729 730 731
		em28xx_copy_video(dev, buf, data_pkt, data_len);
}

732 733 734 735 736 737 738 739 740
/*
 * Process data packet according to the em25xx/em276x/7x/8x frame data format
 */
static inline void process_frame_data_em25xx(struct em28xx *dev,
					     unsigned char *data_pkt,
					     unsigned int  data_len)
{
	struct em28xx_buffer    *buf = dev->usb_ctl.vid_buf;
	struct em28xx_dmaqueue  *dmaq = &dev->vidq;
741
	struct em28xx_v4l2      *v4l2 = dev->v4l2;
742
	bool frame_end = false;
743 744

	/* Check for header */
745 746 747 748
	/*
	 * NOTE: at least with bulk transfers, only the first packet
	 * has a header and has always set the FRAME_END bit
	 */
749 750 751
	if (data_len >= 2) {	/* em25xx header is only 2 bytes long */
		if ((data_pkt[0] == EM25XX_FRMDATAHDR_BYTE1) &&
		    ((data_pkt[1] & ~EM25XX_FRMDATAHDR_BYTE2_MASK) == 0x00)) {
752
			v4l2->top_field = !(data_pkt[1] &
753 754 755 756 757 758 759 760 761 762 763 764
					   EM25XX_FRMDATAHDR_BYTE2_FRAME_ID);
			frame_end = data_pkt[1] &
				    EM25XX_FRMDATAHDR_BYTE2_FRAME_END;
			data_pkt += 2;
			data_len -= 2;
		}

		/* Finish field and prepare next (BULK only) */
		if (dev->analog_xfer_bulk && frame_end) {
			buf = finish_field_prepare_next(dev, buf, dmaq);
			dev->usb_ctl.vid_buf = buf;
		}
765 766
		/*
		 * NOTE: in ISOC mode when a new frame starts and buf==NULL,
767 768 769 770 771 772
		 * we COULD already prepare a buffer here to avoid skipping the
		 * first frame.
		 */
	}

	/* Copy data */
773
	if (buf && data_len > 0)
774 775 776 777 778 779 780 781
		em28xx_copy_video(dev, buf, data_pkt, data_len);

	/* Finish frame (ISOC only) => avoids lag of 1 frame */
	if (!dev->analog_xfer_bulk && frame_end) {
		buf = finish_field_prepare_next(dev, buf, dmaq);
		dev->usb_ctl.vid_buf = buf;
	}

782 783 784 785
	/*
	 * NOTES:
	 *
	 * 1) Tested with USB bulk transfers only !
786 787 788
	 * The wording in the datasheet suggests that isoc might work different.
	 * The current code assumes that with isoc transfers each packet has a
	 * header like with the other em28xx devices.
789 790 791
	 *
	 * 2) Support for interlaced mode is pure theory. It has not been
	 * tested and it is unknown if these devices actually support it.
792 793 794
	 */
}

795 796 797 798 799 800
/* Processes and copies the URB data content (video and VBI data) */
static inline int em28xx_urb_data_copy(struct em28xx *dev, struct urb *urb)
{
	int xfer_bulk, num_packets, i;
	unsigned char *usb_data_pkt;
	unsigned int usb_data_len;
801 802 803 804

	if (!dev)
		return 0;

805
	if (dev->disconnected)
806 807
		return 0;

808
	if (urb->status < 0)
809 810
		print_err_status(dev, -1, urb->status);

811 812 813 814 815 816
	xfer_bulk = usb_pipebulk(urb->pipe);

	if (xfer_bulk) /* bulk */
		num_packets = 1;
	else /* isoc */
		num_packets = urb->number_of_packets;
817

818 819
	for (i = 0; i < num_packets; i++) {
		if (xfer_bulk) { /* bulk */
820
			usb_data_len = urb->actual_length;
821

822
			usb_data_pkt = urb->transfer_buffer;
823 824 825 826 827 828 829 830
		} else { /* isoc */
			if (urb->iso_frame_desc[i].status < 0) {
				print_err_status(dev, i,
						 urb->iso_frame_desc[i].status);
				if (urb->iso_frame_desc[i].status != -EPROTO)
					continue;
			}

831 832
			usb_data_len = urb->iso_frame_desc[i].actual_length;
			if (usb_data_len > dev->max_pkt_size) {
833
				em28xx_isocdbg("packet bigger than packet size");
834
				continue;
835
			}
836

837 838
			usb_data_pkt = urb->transfer_buffer +
				       urb->iso_frame_desc[i].offset;
839
		}
840

841
		if (usb_data_len == 0) {
842 843
			/* NOTE: happens very often with isoc transfers */
			/* em28xx_usbdbg("packet %d is empty",i); - spammy */
844 845 846
			continue;
		}

847 848 849 850 851 852
		if (dev->is_em25xx)
			process_frame_data_em25xx(dev,
						  usb_data_pkt, usb_data_len);
		else
			process_frame_data_em28xx(dev,
						  usb_data_pkt, usb_data_len);
853
	}
854
	return 1;
855 856
}

857
static int get_resource(enum v4l2_buf_type f_type)
858 859 860 861 862 863 864
{
	switch (f_type) {
	case V4L2_BUF_TYPE_VIDEO_CAPTURE:
		return EM28XX_RESOURCE_VIDEO;
	case V4L2_BUF_TYPE_VBI_CAPTURE:
		return EM28XX_RESOURCE_VBI;
	default:
865 866
		WARN_ON(1);
		return -1; /* Indicate that device is busy */
867 868 869 870 871 872
	}
}

/* Usage lock check functions */
static int res_get(struct em28xx *dev, enum v4l2_buf_type f_type)
{
873
	int res_type = get_resource(f_type);
874 875 876 877 878 879 880 881 882 883 884 885 886 887 888

	/* is it free? */
	if (dev->resources & res_type) {
		/* no, someone else uses it */
		return -EBUSY;
	}

	/* it's free, grab it */
	dev->resources |= res_type;
	em28xx_videodbg("res: get %d\n", res_type);
	return 0;
}

static void res_free(struct em28xx *dev, enum v4l2_buf_type f_type)
{
889
	int res_type = get_resource(f_type);
890 891 892 893 894

	dev->resources &= ~res_type;
	em28xx_videodbg("res: put %d\n", res_type);
}

895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954
static void em28xx_v4l2_media_release(struct em28xx *dev)
{
#ifdef CONFIG_MEDIA_CONTROLLER
	int i;

	for (i = 0; i < MAX_EM28XX_INPUT; i++) {
		if (!INPUT(i)->type)
			return;
		media_device_unregister_entity(&dev->input_ent[i]);
	}
#endif
}

/*
 * Media Controller helper functions
 */

static int em28xx_enable_analog_tuner(struct em28xx *dev)
{
#ifdef CONFIG_MEDIA_CONTROLLER
	struct media_device *mdev = dev->media_dev;
	struct em28xx_v4l2 *v4l2 = dev->v4l2;
	struct media_entity *source;
	struct media_link *link, *found_link = NULL;
	int ret, active_links = 0;

	if (!mdev || !v4l2->decoder)
		return 0;

	/*
	 * This will find the tuner that is connected into the decoder.
	 * Technically, this is not 100% correct, as the device may be
	 * using an analog input instead of the tuner. However, as we can't
	 * do DVB streaming while the DMA engine is being used for V4L2,
	 * this should be enough for the actual needs.
	 */
	list_for_each_entry(link, &v4l2->decoder->links, list) {
		if (link->sink->entity == v4l2->decoder) {
			found_link = link;
			if (link->flags & MEDIA_LNK_FL_ENABLED)
				active_links++;
			break;
		}
	}

	if (active_links == 1 || !found_link)
		return 0;

	source = found_link->source->entity;
	list_for_each_entry(link, &source->links, list) {
		struct media_entity *sink;
		int flags = 0;

		sink = link->sink->entity;

		if (sink == v4l2->decoder)
			flags = MEDIA_LNK_FL_ENABLED;

		ret = media_entity_setup_link(link, flags);
		if (ret) {
955
			dev_err(&dev->intf->dev,
956 957 958 959
				"Couldn't change link %s->%s to %s. Error %d\n",
				source->name, sink->name,
				flags ? "enabled" : "disabled",
				ret);
960
			return ret;
961 962 963 964 965
		}

		em28xx_videodbg("link %s->%s was %s\n",
				source->name, sink->name,
				flags ? "ENABLED" : "disabled");
966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987
	}
#endif
	return 0;
}

static const char * const iname[] = {
	[EM28XX_VMUX_COMPOSITE]  = "Composite",
	[EM28XX_VMUX_SVIDEO]     = "S-Video",
	[EM28XX_VMUX_TELEVISION] = "Television",
	[EM28XX_RADIO]           = "Radio",
};

static void em28xx_v4l2_create_entities(struct em28xx *dev)
{
#if defined(CONFIG_MEDIA_CONTROLLER)
	struct em28xx_v4l2 *v4l2 = dev->v4l2;
	int ret, i;

	/* Initialize Video, VBI and Radio pads */
	v4l2->video_pad.flags = MEDIA_PAD_FL_SINK;
	ret = media_entity_pads_init(&v4l2->vdev.entity, 1, &v4l2->video_pad);
	if (ret < 0)
988
		dev_err(&dev->intf->dev,
989
			"failed to initialize video media entity!\n");
990 991 992 993 994 995

	if (em28xx_vbi_supported(dev)) {
		v4l2->vbi_pad.flags = MEDIA_PAD_FL_SINK;
		ret = media_entity_pads_init(&v4l2->vbi_dev.entity, 1,
					     &v4l2->vbi_pad);
		if (ret < 0)
996
			dev_err(&dev->intf->dev,
997
				"failed to initialize vbi media entity!\n");
998 999 1000
	}

	/* Webcams don't have input connectors */
1001
	if (dev->is_webcam)
1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022
		return;

	/* Create entities for each input connector */
	for (i = 0; i < MAX_EM28XX_INPUT; i++) {
		struct media_entity *ent = &dev->input_ent[i];

		if (!INPUT(i)->type)
			break;

		ent->name = iname[INPUT(i)->type];
		ent->flags = MEDIA_ENT_FL_CONNECTOR;
		dev->input_pad[i].flags = MEDIA_PAD_FL_SOURCE;

		switch (INPUT(i)->type) {
		case EM28XX_VMUX_COMPOSITE:
			ent->function = MEDIA_ENT_F_CONN_COMPOSITE;
			break;
		case EM28XX_VMUX_SVIDEO:
			ent->function = MEDIA_ENT_F_CONN_SVIDEO;
			break;
		default: /* EM28XX_VMUX_TELEVISION or EM28XX_RADIO */
1023 1024
			if (dev->tuner_type != TUNER_ABSENT)
				ent->function = MEDIA_ENT_F_CONN_RF;
1025 1026 1027 1028 1029
			break;
		}

		ret = media_entity_pads_init(ent, 1, &dev->input_pad[i]);
		if (ret < 0)
1030
			dev_err(&dev->intf->dev,
1031
				"failed to initialize input pad[%d]!\n", i);
1032 1033 1034

		ret = media_device_register_entity(dev->media_dev, ent);
		if (ret < 0)
1035
			dev_err(&dev->intf->dev,
1036
				"failed to register input entity %d!\n", i);
1037 1038 1039 1040
	}
#endif
}

1041 1042 1043
/*
 * Videobuf2 operations
 */
1044

1045
static int queue_setup(struct vb2_queue *vq,
1046
		       unsigned int *nbuffers, unsigned int *nplanes,
1047
		       unsigned int sizes[], struct device *alloc_devs[])
1048
{
1049
	struct em28xx *dev = vb2_get_drv_priv(vq);
1050
	struct em28xx_v4l2 *v4l2 = dev->v4l2;
1051
	unsigned long size =
1052
		    (v4l2->width * v4l2->height * v4l2->format->depth + 7) >> 3;
1053

1054 1055
	if (*nplanes)
		return sizes[0] < size ? -EINVAL : 0;
1056 1057
	*nplanes = 1;
	sizes[0] = size;
1058 1059 1060

	em28xx_enable_analog_tuner(dev);

1061 1062 1063
	return 0;
}

1064 1065
static int
buffer_prepare(struct vb2_buffer *vb)
1066
{
1067
	struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
1068
	struct em28xx        *dev = vb2_get_drv_priv(vb->vb2_queue);
1069
	struct em28xx_v4l2   *v4l2 = dev->v4l2;
1070
	unsigned long size;
1071

1072
	em28xx_videodbg("%s, field=%d\n", __func__, vbuf->field);
1073

1074
	size = (v4l2->width * v4l2->height * v4l2->format->depth + 7) >> 3;
1075

1076 1077 1078 1079 1080
	if (vb2_plane_size(vb, 0) < size) {
		em28xx_videodbg("%s data will not fit into plane (%lu < %lu)\n",
				__func__, vb2_plane_size(vb, 0), size);
		return -EINVAL;
	}
1081
	vb2_set_plane_payload(vb, 0, size);
1082 1083

	return 0;
1084 1085
}

1086
int em28xx_start_analog_streaming(struct vb2_queue *vq, unsigned int count)
1087
{
1088
	struct em28xx *dev = vb2_get_drv_priv(vq);
1089
	struct em28xx_v4l2 *v4l2 = dev->v4l2;
1090
	struct v4l2_frequency f;
1091
	struct v4l2_fh *owner;
1092
	int rc = 0;
1093

1094
	em28xx_videodbg("%s\n", __func__);
1095

1096 1097 1098 1099
	/*
	 * Make sure streaming is not already in progress for this type
	 * of filehandle (e.g. video, vbi)
	 */
1100 1101 1102
	rc = res_get(dev, vq->type);
	if (rc)
		return rc;
1103

1104
	if (v4l2->streaming_users == 0) {
1105
		/* First active streaming user, so allocate all the URBs */
1106

1107 1108
		/* Allocate the USB bandwidth */
		em28xx_set_alternate(dev);
1109

1110 1111 1112 1113
		/*
		 * Needed, since GPIO might have disabled power of
		 * some i2c device
		 */
1114
		em28xx_wake_i2c(dev);
1115

1116
		v4l2->capture_type = -1;
1117 1118 1119 1120 1121 1122
		rc = em28xx_init_usb_xfer(dev, EM28XX_ANALOG_MODE,
					  dev->analog_xfer_bulk,
					  EM28XX_NUM_BUFS,
					  dev->max_pkt_size,
					  dev->packet_multiplier,
					  em28xx_urb_data_copy);
1123
		if (rc < 0)
1124
			return rc;
1125

1126 1127 1128 1129 1130 1131 1132 1133
		/*
		 * djh: it's not clear whether this code is still needed.  I'm
		 * leaving it in here for now entirely out of concern for
		 * backward compatibility (the old code did it)
		 */

		/* Ask tuner to go to analog or radio mode */
		memset(&f, 0, sizeof(f));
1134
		f.frequency = v4l2->frequency;
1135 1136
		owner = (struct v4l2_fh *)vq->owner;
		if (owner && owner->vdev->vfl_type == VFL_TYPE_RADIO)
1137 1138 1139
			f.type = V4L2_TUNER_RADIO;
		else
			f.type = V4L2_TUNER_ANALOG_TV;
1140
		v4l2_device_call_all(&v4l2->v4l2_dev,
1141
				     0, tuner, s_frequency, &f);
1142 1143 1144

		/* Enable video stream at TV decoder */
		v4l2_device_call_all(&v4l2->v4l2_dev, 0, video, s_stream, 1);
1145
	}
1146

1147
	v4l2->streaming_users++;
1148

1149 1150 1151
	return rc;
}

1152
static void em28xx_stop_streaming(struct vb2_queue *vq)
1153 1154
{
	struct em28xx *dev = vb2_get_drv_priv(vq);
1155
	struct em28xx_v4l2 *v4l2 = dev->v4l2;
1156 1157 1158 1159 1160 1161 1162
	struct em28xx_dmaqueue *vidq = &dev->vidq;
	unsigned long flags = 0;

	em28xx_videodbg("%s\n", __func__);

	res_free(dev, vq->type);

1163
	if (v4l2->streaming_users-- == 1) {
1164 1165 1166
		/* Disable video stream at TV decoder */
		v4l2_device_call_all(&v4l2->v4l2_dev, 0, video, s_stream, 0);

1167 1168 1169 1170 1171
		/* Last active user, so shutdown all the URBS */
		em28xx_uninit_usb_xfer(dev, EM28XX_ANALOG_MODE);
	}

	spin_lock_irqsave(&dev->slock, flags);
1172
	if (dev->usb_ctl.vid_buf) {
1173 1174
		vb2_buffer_done(&dev->usb_ctl.vid_buf->vb.vb2_buf,
				VB2_BUF_STATE_ERROR);
1175 1176
		dev->usb_ctl.vid_buf = NULL;
	}
1177 1178
	while (!list_empty(&vidq->active)) {
		struct em28xx_buffer *buf;
1179

1180 1181
		buf = list_entry(vidq->active.next, struct em28xx_buffer, list);
		list_del(&buf->list);
1182
		vb2_buffer_done(&buf->vb.vb2_buf, VB2_BUF_STATE_ERROR);
1183 1184 1185 1186
	}
	spin_unlock_irqrestore(&dev->slock, flags);
}

1187
void em28xx_stop_vbi_streaming(struct vb2_queue *vq)
1188
{
1189
	struct em28xx *dev = vb2_get_drv_priv(vq);
1190
	struct em28xx_v4l2 *v4l2 = dev->v4l2;
1191 1192 1193 1194 1195 1196
	struct em28xx_dmaqueue *vbiq = &dev->vbiq;
	unsigned long flags = 0;

	em28xx_videodbg("%s\n", __func__);

	res_free(dev, vq->type);
1197

1198
	if (v4l2->streaming_users-- == 1) {
1199 1200 1201
		/* Disable video stream at TV decoder */
		v4l2_device_call_all(&v4l2->v4l2_dev, 0, video, s_stream, 0);

1202 1203 1204 1205 1206
		/* Last active user, so shutdown all the URBS */
		em28xx_uninit_usb_xfer(dev, EM28XX_ANALOG_MODE);
	}

	spin_lock_irqsave(&dev->slock, flags);
1207
	if (dev->usb_ctl.vbi_buf) {
1208 1209
		vb2_buffer_done(&dev->usb_ctl.vbi_buf->vb.vb2_buf,
				VB2_BUF_STATE_ERROR);
1210 1211
		dev->usb_ctl.vbi_buf = NULL;
	}
1212 1213
	while (!list_empty(&vbiq->active)) {
		struct em28xx_buffer *buf;
1214

1215 1216
		buf = list_entry(vbiq->active.next, struct em28xx_buffer, list);
		list_del(&buf->list);
1217
		vb2_buffer_done(&buf->vb.vb2_buf, VB2_BUF_STATE_ERROR);
1218 1219
	}
	spin_unlock_irqrestore(&dev->slock, flags);
1220 1221
}

1222 1223
static void
buffer_queue(struct vb2_buffer *vb)
1224
{
1225
	struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
1226
	struct em28xx *dev = vb2_get_drv_priv(vb->vb2_queue);
1227 1228
	struct em28xx_buffer *buf =
		container_of(vbuf, struct em28xx_buffer, vb);
1229 1230
	struct em28xx_dmaqueue *vidq = &dev->vidq;
	unsigned long flags = 0;
1231

1232 1233 1234
	em28xx_videodbg("%s\n", __func__);
	buf->mem = vb2_plane_vaddr(vb, 0);
	buf->length = vb2_plane_size(vb, 0);
1235

1236 1237 1238
	spin_lock_irqsave(&dev->slock, flags);
	list_add_tail(&buf->list, &vidq->active);
	spin_unlock_irqrestore(&dev->slock, flags);