em28xx-core.c 18.8 KB
Newer Older
1
/*
2
   em28xx-core.c - driver for Empia EM2800/EM2820/2840 USB video capture devices
3

4 5
   Copyright (C) 2005 Ludovico Cavedon <cavedon@sssup.it>
		      Markus Rechberger <mrechberger@gmail.com>
6
		      Mauro Carvalho Chehab <mchehab@infradead.org>
7
		      Sascha Sommer <saschasommer@freenet.de>
8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29

   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.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

#include <linux/init.h>
#include <linux/list.h>
#include <linux/module.h>
#include <linux/usb.h>
#include <linux/vmalloc.h>

30
#include "em28xx.h"
31 32 33

/* #define ENABLE_DEBUG_ISOC_FRAMES */

34
static unsigned int core_debug;
35 36 37
module_param(core_debug,int,0644);
MODULE_PARM_DESC(core_debug,"enable debug messages [core]");

38
#define em28xx_coredbg(fmt, arg...) do {\
39 40
	if (core_debug) \
		printk(KERN_INFO "%s %s :"fmt, \
41
			 dev->name, __func__ , ##arg); } while (0)
42

43
static unsigned int reg_debug;
44 45 46
module_param(reg_debug,int,0644);
MODULE_PARM_DESC(reg_debug,"enable debug messages [URB reg]");

47
#define em28xx_regdbg(fmt, arg...) do {\
48 49
	if (reg_debug) \
		printk(KERN_INFO "%s %s :"fmt, \
50
			 dev->name, __func__ , ##arg); } while (0)
51

52
static int alt = EM28XX_PINOUT;
53 54 55
module_param(alt, int, 0644);
MODULE_PARM_DESC(alt, "alternate setting to use for video endpoint");

56 57 58 59 60 61
/* FIXME */
#define em28xx_isocdbg(fmt, arg...) do {\
	if (core_debug) \
		printk(KERN_INFO "%s %s :"fmt, \
			 dev->name, __func__ , ##arg); } while (0)

62
/*
63
 * em28xx_read_reg_req()
64 65
 * reads data from the usb device specifying bRequest
 */
66
int em28xx_read_reg_req_len(struct em28xx *dev, u8 req, u16 reg,
67 68 69 70
				   char *buf, int len)
{
	int ret, byte;

71
	if (dev->state & DEV_DISCONNECTED)
72 73 74 75
		return -ENODEV;

	if (len > URB_MAX_CTRL_SIZE)
		return -EINVAL;
76

77
	em28xx_regdbg("req=%02x, reg=%02x ", req, reg);
78

79
	mutex_lock(&dev->ctrl_urb_lock);
80 81
	ret = usb_control_msg(dev->udev, usb_rcvctrlpipe(dev->udev, 0), req,
			      USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
82 83 84 85
			      0x0000, reg, dev->urb_buf, len, HZ);
	if (ret < 0) {
		if (reg_debug)
			printk(" failed!\n");
86
		mutex_unlock(&dev->ctrl_urb_lock);
87 88 89 90 91
		return ret;
	}

	if (len)
		memcpy(buf, dev->urb_buf, len);
92

93 94
	mutex_unlock(&dev->ctrl_urb_lock);

95
	if (reg_debug) {
96
		printk("%02x values: ", ret);
97
		for (byte = 0; byte < len; byte++)
98 99
			printk(" %02x", (unsigned char)buf[byte]);
		printk("\n");
100 101 102 103 104 105
	}

	return ret;
}

/*
106
 * em28xx_read_reg_req()
107 108
 * reads data from the usb device specifying bRequest
 */
109
int em28xx_read_reg_req(struct em28xx *dev, u8 req, u16 reg)
110 111 112 113
{
	u8 val;
	int ret;

114 115 116
	if (dev->state & DEV_DISCONNECTED)
		return(-ENODEV);

117
	em28xx_regdbg("req=%02x, reg=%02x:", req, reg);
118

119
	mutex_lock(&dev->ctrl_urb_lock);
120 121
	ret = usb_control_msg(dev->udev, usb_rcvctrlpipe(dev->udev, 0), req,
			      USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
122
			      0x0000, reg, dev->urb_buf, 1, HZ);
123 124 125
	val = dev->urb_buf[0];
	mutex_unlock(&dev->ctrl_urb_lock);

126 127 128 129
	if (ret < 0) {
		printk(" failed!\n");
		return ret;
	}
130

131 132
	if (reg_debug)
		printk("%02x\n", (unsigned char) val);
133 134 135 136

	return val;
}

137
int em28xx_read_reg(struct em28xx *dev, u16 reg)
138
{
139
	return em28xx_read_reg_req(dev, USB_REQ_GET_STATUS, reg);
140 141 142
}

/*
143
 * em28xx_write_regs_req()
144 145
 * sends data to the usb device, specifying bRequest
 */
146
int em28xx_write_regs_req(struct em28xx *dev, u8 req, u16 reg, char *buf,
147 148 149 150
				 int len)
{
	int ret;

151
	if (dev->state & DEV_DISCONNECTED)
152 153
		return -ENODEV;

154
	if ((len < 1) || (len > URB_MAX_CTRL_SIZE))
155
		return -EINVAL;
156

157
	em28xx_regdbg("req=%02x reg=%02x:", req, reg);
158 159 160
	if (reg_debug) {
		int i;
		for (i = 0; i < len; ++i)
161 162
			printk(" %02x", (unsigned char)buf[i]);
		printk("\n");
163 164
	}

165
	mutex_lock(&dev->ctrl_urb_lock);
166
	memcpy(dev->urb_buf, buf, len);
167 168
	ret = usb_control_msg(dev->udev, usb_sndctrlpipe(dev->udev, 0), req,
			      USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
169
			      0x0000, reg, dev->urb_buf, len, HZ);
170
	mutex_unlock(&dev->ctrl_urb_lock);
171

172 173 174
	if (dev->wait_after_write)
		msleep(dev->wait_after_write);

175 176 177
	return ret;
}

178
int em28xx_write_regs(struct em28xx *dev, u16 reg, char *buf, int len)
179
{
180 181 182 183 184 185 186 187 188 189
	int rc;

	rc = em28xx_write_regs_req(dev, USB_REQ_GET_STATUS, reg, buf, len);

	/* Stores GPO/GPIO values at the cache, if changed
	   Only write values should be stored, since input on a GPIO
	   register will return the input bits.
	   Not sure what happens on reading GPO register.
	 */
	if (rc >= 0) {
190
		if (reg == dev->reg_gpo_num)
191
			dev->reg_gpo = buf[0];
192
		else if (reg == dev->reg_gpio_num)
193 194 195 196
			dev->reg_gpio = buf[0];
	}

	return rc;
197 198 199
}

/*
200
 * em28xx_write_reg_bits()
201 202 203
 * sets only some bits (specified by bitmask) of a register, by first reading
 * the actual value
 */
204
static int em28xx_write_reg_bits(struct em28xx *dev, u16 reg, u8 val,
205 206 207 208
				 u8 bitmask)
{
	int oldval;
	u8 newval;
209

210
	/* Uses cache for gpo/gpio registers */
211
	if (reg == dev->reg_gpo_num)
212
		oldval = dev->reg_gpo;
213
	else if (reg == dev->reg_gpio_num)
214 215 216
		oldval = dev->reg_gpio;
	else
		oldval = em28xx_read_reg(dev, reg);
217 218

	if (oldval < 0)
219
		return oldval;
220

221
	newval = (((u8) oldval) & ~bitmask) | (val & bitmask);
222

223
	return em28xx_write_regs(dev, reg, &newval, 1);
224 225 226
}

/*
227
 * em28xx_write_ac97()
228 229
 * write a 16 bit value to the specified AC97 address (LSB first!)
 */
230
static int em28xx_write_ac97(struct em28xx *dev, u8 reg, u8 *val)
231
{
232
	int ret, i;
233
	u8 addr = reg & 0x7f;
234

235
	ret = em28xx_write_regs(dev, EM28XX_R40_AC97LSB, val, 2);
236
	if (ret < 0)
237
		return ret;
238

239
	ret = em28xx_write_regs(dev, EM28XX_R42_AC97ADDR, &addr, 1);
240
	if (ret < 0)
241
		return ret;
242 243 244

	/* Wait up to 50 ms for AC97 command to complete */
	for (i = 0; i < 10; i++) {
245
		ret = em28xx_read_reg(dev, EM28XX_R43_AC97BUSY);
246
		if (ret < 0)
247
			return ret;
248

249
		if (!(ret & 0x01))
250 251
			return 0;
		msleep(5);
252
	}
253
	em28xx_warn("AC97 command still being executed: not handled properly!\n");
254 255 256
	return 0;
}

257
static int em28xx_set_audio_source(struct em28xx *dev)
258 259 260 261
{
	static char *enable  = "\x08\x08";
	static char *disable = "\x08\x88";
	char *video = enable, *line = disable;
262
	int ret;
263 264 265 266 267 268 269 270
	u8 input;

	if (dev->is_em2800) {
		if (dev->ctl_ainput)
			input = EM2800_AUDIO_SRC_LINE;
		else
			input = EM2800_AUDIO_SRC_TUNER;

271
		ret = em28xx_write_regs(dev, EM2800_R08_AUDIOSRC, &input, 1);
272 273 274 275 276 277 278 279 280 281 282 283 284
		if (ret < 0)
			return ret;
	}

	if (dev->has_msp34xx)
		input = EM28XX_AUDIO_SRC_TUNER;
	else {
		switch (dev->ctl_ainput) {
		case EM28XX_AMUX_VIDEO:
			input = EM28XX_AUDIO_SRC_TUNER;
			break;
		case EM28XX_AMUX_LINE_IN:
			input = EM28XX_AUDIO_SRC_LINE;
285 286
			video = disable;
			line  = enable;
287 288 289 290 291 292 293 294 295 296 297 298
			break;
		case EM28XX_AMUX_AC97_VIDEO:
			input = EM28XX_AUDIO_SRC_LINE;
			break;
		case EM28XX_AMUX_AC97_LINE_IN:
			input = EM28XX_AUDIO_SRC_LINE;
			video = disable;
			line  = enable;
			break;
		}
	}

299
	ret = em28xx_write_reg_bits(dev, EM28XX_R0E_AUDIOSRC, input, 0xc0);
300 301
	if (ret < 0)
		return ret;
302
	msleep(5);
303

304 305 306
	/* Sets AC97 mixer registers
	   This is seems to be needed, even for non-ac97 configs
	 */
307
	ret = em28xx_write_ac97(dev, AC97_VIDEO_VOL, video);
308 309 310
	if (ret < 0)
		return ret;

311
	ret = em28xx_write_ac97(dev, AC97_LINEIN_VOL, line);
312 313 314 315

	return ret;
}

316
int em28xx_audio_analog_set(struct em28xx *dev)
317
{
318
	int ret;
319
	char s[2] = { 0x00, 0x00 };
320
	u8 xclk = 0x07;
321

322 323
	s[0] |= 0x1f - dev->volume;
	s[1] |= 0x1f - dev->volume;
324

325 326
	/* Mute */
	s[1] |= 0x80;
327
	ret = em28xx_write_ac97(dev, AC97_MASTER_VOL, s);
328

329 330 331
	if (ret < 0)
		return ret;

332 333 334 335 336 337
	if (dev->has_12mhz_i2s)
		xclk |= 0x20;

	if (!dev->mute)
		xclk |= 0x80;

338
	ret = em28xx_write_reg_bits(dev, EM28XX_R0F_XCLK, xclk, 0xa7);
339 340
	if (ret < 0)
		return ret;
341
	msleep(10);
342 343 344

	/* Selects the proper audio input */
	ret = em28xx_set_audio_source(dev);
345

346 347 348
	/* Unmute device */
	if (!dev->mute)
		s[1] &= ~0x80;
349
	ret = em28xx_write_ac97(dev, AC97_MASTER_VOL, s);
350

351 352 353
	return ret;
}
EXPORT_SYMBOL_GPL(em28xx_audio_analog_set);
354

355
int em28xx_colorlevels_set_default(struct em28xx *dev)
356
{
357 358 359 360 361 362 363 364 365 366 367 368 369 370
	em28xx_write_regs(dev, EM28XX_R20_YGAIN, "\x10", 1);	/* contrast */
	em28xx_write_regs(dev, EM28XX_R21_YOFFSET, "\x00", 1);	/* brightness */
	em28xx_write_regs(dev, EM28XX_R22_UVGAIN, "\x10", 1);	/* saturation */
	em28xx_write_regs(dev, EM28XX_R23_UOFFSET, "\x00", 1);
	em28xx_write_regs(dev, EM28XX_R24_VOFFSET, "\x00", 1);
	em28xx_write_regs(dev, EM28XX_R25_SHARPNESS, "\x00", 1);

	em28xx_write_regs(dev, EM28XX_R14_GAMMA, "\x20", 1);
	em28xx_write_regs(dev, EM28XX_R15_RGAIN, "\x20", 1);
	em28xx_write_regs(dev, EM28XX_R16_GGAIN, "\x20", 1);
	em28xx_write_regs(dev, EM28XX_R17_BGAIN, "\x20", 1);
	em28xx_write_regs(dev, EM28XX_R18_ROFFSET, "\x00", 1);
	em28xx_write_regs(dev, EM28XX_R19_GOFFSET, "\x00", 1);
	return em28xx_write_regs(dev, EM28XX_R1A_BOFFSET, "\x00", 1);
371 372
}

373
int em28xx_capture_start(struct em28xx *dev, int start)
374
{
375
	int rc;
376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393

	if (dev->chip_id == CHIP_ID_EM2874) {
		/* The Transport Stream Enable Register moved in em2874 */
		if (!start) {
			rc = em28xx_write_reg_bits(dev, EM2874_R5F_TS_ENABLE,
						   0x00,
						   EM2874_TS1_CAPTURE_ENABLE);
			return rc;
		}

		/* Enable Transport Stream */
		rc = em28xx_write_reg_bits(dev, EM2874_R5F_TS_ENABLE,
					   EM2874_TS1_CAPTURE_ENABLE,
					   EM2874_TS1_CAPTURE_ENABLE);
		return rc;
	}


394 395
	/* FIXME: which is the best order? */
	/* video registers are sampled by VREF */
396
	rc = em28xx_write_reg_bits(dev, EM28XX_R0C_USBSUSP,
397 398 399 400 401 402
				   start ? 0x10 : 0x00, 0x10);
	if (rc < 0)
		return rc;

	if (!start) {
		/* disable video capture */
403
		rc = em28xx_write_regs(dev, EM28XX_R12_VINENABLE, "\x27", 1);
404
		return rc;
405 406
	}

407
	/* enable video capture */
408
	rc = em28xx_write_regs_req(dev, 0x00, 0x48, "\x00", 1);
409

410
	if (dev->mode == EM28XX_ANALOG_MODE)
411
		rc = em28xx_write_regs(dev, EM28XX_R12_VINENABLE, "\x67", 1);
412
	else
413
		rc = em28xx_write_regs(dev, EM28XX_R12_VINENABLE, "\x37", 1);
414

415
	msleep(6);
416 417

	return rc;
418 419
}

420
int em28xx_outfmt_set_yuv422(struct em28xx *dev)
421
{
422 423 424
	em28xx_write_regs(dev, EM28XX_R27_OUTFMT, "\x34", 1);
	em28xx_write_regs(dev, EM28XX_R10_VINMODE, "\x10", 1);
	return em28xx_write_regs(dev, EM28XX_R11_VINCTRL, "\x11", 1);
425 426
}

427 428
static int em28xx_accumulator_set(struct em28xx *dev, u8 xmin, u8 xmax,
				  u8 ymin, u8 ymax)
429
{
430 431
	em28xx_coredbg("em28xx Scale: (%d,%d)-(%d,%d)\n",
			xmin, ymin, xmax, ymax);
432

433 434 435 436
	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);
437 438
}

439
static int em28xx_capture_area_set(struct em28xx *dev, u8 hstart, u8 vstart,
440 441 442 443 444 445
				   u16 width, u16 height)
{
	u8 cwidth = width;
	u8 cheight = height;
	u8 overflow = (height >> 7 & 0x02) | (width >> 8 & 0x01);

446 447
	em28xx_coredbg("em28xx Area Set: (%d,%d)\n",
			(width | (overflow & 2) << 7),
448 449
			(height | (overflow & 1) << 8));

450 451 452 453 454
	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);
	return em28xx_write_regs(dev, EM28XX_R1B_OFLOW, &overflow, 1);
455 456
}

457
static int em28xx_scaler_set(struct em28xx *dev, u16 h, u16 v)
458
{
459 460
	u8 mode;
	/* the em2800 scaler only supports scaling down to 50% */
461
	if (dev->is_em2800)
462 463 464 465 466
		mode = (v ? 0x20 : 0x00) | (h ? 0x10 : 0x00);
	else {
		u8 buf[2];
		buf[0] = h;
		buf[1] = h >> 8;
467
		em28xx_write_regs(dev, EM28XX_R30_HSCALELOW, (char *)buf, 2);
468 469
		buf[0] = v;
		buf[1] = v >> 8;
470
		em28xx_write_regs(dev, EM28XX_R32_VSCALELOW, (char *)buf, 2);
471 472
		/* it seems that both H and V scalers must be active
		   to work correctly */
473
		mode = (h || v)? 0x30: 0x00;
474
	}
475
	return em28xx_write_reg_bits(dev, EM28XX_R26_COMPR, mode, 0x30);
476 477 478
}

/* FIXME: this only function read values from dev */
479
int em28xx_resolution_set(struct em28xx *dev)
480 481 482 483 484
{
	int width, height;
	width = norm_maxw(dev);
	height = norm_maxh(dev) >> 1;

485 486 487 488
	em28xx_outfmt_set_yuv422(dev);
	em28xx_accumulator_set(dev, 1, (width - 4) >> 2, 1, (height - 4) >> 2);
	em28xx_capture_area_set(dev, 0, 0, width >> 2, height >> 2);
	return em28xx_scaler_set(dev, dev->hscale, dev->vscale);
489 490
}

491
int em28xx_set_alternate(struct em28xx *dev)
492 493
{
	int errCode, prev_alt = dev->alt;
494
	int i;
495
	unsigned int min_pkt_size = dev->width * 2 + 4;
496

497
	/* When image size is bigger than a certain value,
498 499 500
	   the frame size should be increased, otherwise, only
	   green screen will be received.
	 */
501
	if (dev->width * 2 * dev->height > 720 * 240 * 2)
502 503
		min_pkt_size *= 2;

504 505 506 507
	for (i = 0; i < dev->num_alt; i++) {
		/* stop when the selected alt setting offers enough bandwidth */
		if (dev->alt_max_pkt_size[i] >= min_pkt_size) {
			dev->alt = i;
508
			break;
509 510 511 512 513 514 515
		/* otherwise make sure that we end up with the maximum bandwidth
		   because the min_pkt_size equation might be wrong...
		*/
		} else if (dev->alt_max_pkt_size[i] >
			   dev->alt_max_pkt_size[dev->alt])
			dev->alt = i;
	}
516 517

	if (dev->alt != prev_alt) {
518 519
		em28xx_coredbg("minimum isoc packet size: %u (alt=%d)\n",
				min_pkt_size, dev->alt);
520
		dev->max_pkt_size = dev->alt_max_pkt_size[dev->alt];
521 522
		em28xx_coredbg("setting alternate %d with wMaxPacketSize=%u\n",
			       dev->alt, dev->max_pkt_size);
523 524
		errCode = usb_set_interface(dev->udev, 0, dev->alt);
		if (errCode < 0) {
525
			em28xx_errdev("cannot change alternate number to %d (error=%i)\n",
526
					dev->alt, errCode);
527 528 529 530 531
			return errCode;
		}
	}
	return 0;
}
532

533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583
int em28xx_gpio_set(struct em28xx *dev, struct em28xx_reg_seq *gpio)
{
	int rc = 0;

	if (!gpio)
		return rc;

	dev->em28xx_write_regs_req(dev, 0x00, 0x48, "\x00", 1);
	if (dev->mode == EM28XX_ANALOG_MODE)
		dev->em28xx_write_regs_req(dev, 0x00, 0x12, "\x67", 1);
	else
		dev->em28xx_write_regs_req(dev, 0x00, 0x12, "\x37", 1);
	msleep(6);

	/* Send GPIO reset sequences specified at board entry */
	while (gpio->sleep >= 0) {
		if (gpio->reg >= 0) {
			rc = em28xx_write_reg_bits(dev,
						   gpio->reg,
						   gpio->val,
						   gpio->mask);
			if (rc < 0)
				return rc;
		}
		if (gpio->sleep > 0)
			msleep(gpio->sleep);

		gpio++;
	}
	return rc;
}

int em28xx_set_mode(struct em28xx *dev, enum em28xx_mode set_mode)
{
	if (dev->mode == set_mode)
		return 0;

	if (set_mode == EM28XX_MODE_UNDEFINED) {
		dev->mode = set_mode;
		return 0;
	}

	dev->mode = set_mode;

	if (dev->mode == EM28XX_DIGITAL_MODE)
		return em28xx_gpio_set(dev, dev->digital_gpio);
	else
		return em28xx_gpio_set(dev, dev->analog_gpio);
}
EXPORT_SYMBOL_GPL(em28xx_set_mode);

584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610
/* ------------------------------------------------------------------
	URB control
   ------------------------------------------------------------------*/

/*
 * IRQ callback, called by URB callback
 */
static void em28xx_irq_callback(struct urb *urb)
{
	struct em28xx_dmaqueue  *dma_q = urb->context;
	struct em28xx *dev = container_of(dma_q, struct em28xx, vidq);
	int rc, i;

	/* Copy data from URB */
	spin_lock(&dev->slock);
	rc = dev->isoc_ctl.isoc_copy(dev, urb);
	spin_unlock(&dev->slock);

	/* Reset urb buffers */
	for (i = 0; i < urb->number_of_packets; i++) {
		urb->iso_frame_desc[i].status = 0;
		urb->iso_frame_desc[i].actual_length = 0;
	}
	urb->status = 0;

	urb->status = usb_submit_urb(urb, GFP_ATOMIC);
	if (urb->status) {
611 612
		em28xx_isocdbg("urb resubmit failed (error=%i)\n",
			       urb->status);
613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633
	}
}

/*
 * Stop and Deallocate URBs
 */
void em28xx_uninit_isoc(struct em28xx *dev)
{
	struct urb *urb;
	int i;

	em28xx_isocdbg("em28xx: called em28xx_uninit_isoc\n");

	dev->isoc_ctl.nfields = -1;
	for (i = 0; i < dev->isoc_ctl.num_bufs; i++) {
		urb = dev->isoc_ctl.urb[i];
		if (urb) {
			usb_kill_urb(urb);
			usb_unlink_urb(urb);
			if (dev->isoc_ctl.transfer_buffer[i]) {
				usb_buffer_free(dev->udev,
634 635 636
					urb->transfer_buffer_length,
					dev->isoc_ctl.transfer_buffer[i],
					urb->transfer_dma);
637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659
			}
			usb_free_urb(urb);
			dev->isoc_ctl.urb[i] = NULL;
		}
		dev->isoc_ctl.transfer_buffer[i] = NULL;
	}

	kfree(dev->isoc_ctl.urb);
	kfree(dev->isoc_ctl.transfer_buffer);

	dev->isoc_ctl.urb = NULL;
	dev->isoc_ctl.transfer_buffer = NULL;
	dev->isoc_ctl.num_bufs = 0;

	em28xx_capture_start(dev, 0);
}
EXPORT_SYMBOL_GPL(em28xx_uninit_isoc);

/*
 * Allocate URBs and start IRQ
 */
int em28xx_init_isoc(struct em28xx *dev, int max_packets,
		     int num_bufs, int max_pkt_size,
660
		     int (*isoc_copy) (struct em28xx *dev, struct urb *urb))
661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684
{
	struct em28xx_dmaqueue *dma_q = &dev->vidq;
	int i;
	int sb_size, pipe;
	struct urb *urb;
	int j, k;
	int rc;

	em28xx_isocdbg("em28xx: called em28xx_prepare_isoc\n");

	/* De-allocates all pending stuff */
	em28xx_uninit_isoc(dev);

	dev->isoc_ctl.isoc_copy = isoc_copy;
	dev->isoc_ctl.num_bufs = num_bufs;

	dev->isoc_ctl.urb = kzalloc(sizeof(void *)*num_bufs,  GFP_KERNEL);
	if (!dev->isoc_ctl.urb) {
		em28xx_errdev("cannot alloc memory for usb buffers\n");
		return -ENOMEM;
	}

	dev->isoc_ctl.transfer_buffer = kzalloc(sizeof(void *)*num_bufs,
					      GFP_KERNEL);
685
	if (!dev->isoc_ctl.transfer_buffer) {
686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721
		em28xx_errdev("cannot allocate memory for usbtransfer\n");
		kfree(dev->isoc_ctl.urb);
		return -ENOMEM;
	}

	dev->isoc_ctl.max_pkt_size = max_pkt_size;
	dev->isoc_ctl.buf = NULL;

	sb_size = max_packets * dev->isoc_ctl.max_pkt_size;

	/* allocate urbs and transfer buffers */
	for (i = 0; i < dev->isoc_ctl.num_bufs; i++) {
		urb = usb_alloc_urb(max_packets, GFP_KERNEL);
		if (!urb) {
			em28xx_err("cannot alloc isoc_ctl.urb %i\n", i);
			em28xx_uninit_isoc(dev);
			return -ENOMEM;
		}
		dev->isoc_ctl.urb[i] = urb;

		dev->isoc_ctl.transfer_buffer[i] = usb_buffer_alloc(dev->udev,
			sb_size, GFP_KERNEL, &urb->transfer_dma);
		if (!dev->isoc_ctl.transfer_buffer[i]) {
			em28xx_err("unable to allocate %i bytes for transfer"
					" buffer %i%s\n",
					sb_size, i,
					in_interrupt()?" while in int":"");
			em28xx_uninit_isoc(dev);
			return -ENOMEM;
		}
		memset(dev->isoc_ctl.transfer_buffer[i], 0, sb_size);

		/* FIXME: this is a hack - should be
			'desc.bEndpointAddress & USB_ENDPOINT_NUMBER_MASK'
			should also be using 'desc.bInterval'
		 */
722
		pipe = usb_rcvisocpipe(dev->udev,
723
			dev->mode == EM28XX_ANALOG_MODE ? 0x82 : 0x84);
724

725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742
		usb_fill_int_urb(urb, dev->udev, pipe,
				 dev->isoc_ctl.transfer_buffer[i], sb_size,
				 em28xx_irq_callback, dma_q, 1);

		urb->number_of_packets = max_packets;
		urb->transfer_flags = URB_ISO_ASAP;

		k = 0;
		for (j = 0; j < max_packets; j++) {
			urb->iso_frame_desc[j].offset = k;
			urb->iso_frame_desc[j].length =
						dev->isoc_ctl.max_pkt_size;
			k += dev->isoc_ctl.max_pkt_size;
		}
	}

	init_waitqueue_head(&dma_q->wq);

743
	em28xx_capture_start(dev, 1);
744 745 746 747 748 749 750 751 752 753 754 755 756 757 758

	/* submit urbs and enables IRQ */
	for (i = 0; i < dev->isoc_ctl.num_bufs; i++) {
		rc = usb_submit_urb(dev->isoc_ctl.urb[i], GFP_ATOMIC);
		if (rc) {
			em28xx_err("submit of urb %i failed (error=%i)\n", i,
				   rc);
			em28xx_uninit_isoc(dev);
			return rc;
		}
	}

	return 0;
}
EXPORT_SYMBOL_GPL(em28xx_init_isoc);