PRCM: 34XX: Fix wrong shift value used in dpll4_m4x2_ck enable bit
[linux-ginger.git] / drivers / media / video / em28xx / em28xx-core.c
blob5d837c16ee22ad10908cce01c0ef0d89768f14ed
1 /*
2 em28xx-core.c - driver for Empia EM2800/EM2820/2840 USB video capture devices
4 Copyright (C) 2005 Ludovico Cavedon <cavedon@sssup.it>
5 Markus Rechberger <mrechberger@gmail.com>
6 Mauro Carvalho Chehab <mchehab@infradead.org>
7 Sascha Sommer <saschasommer@freenet.de>
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
24 #include <linux/init.h>
25 #include <linux/list.h>
26 #include <linux/module.h>
27 #include <linux/usb.h>
28 #include <linux/vmalloc.h>
30 #include "em28xx.h"
32 /* #define ENABLE_DEBUG_ISOC_FRAMES */
34 static unsigned int core_debug;
35 module_param(core_debug,int,0644);
36 MODULE_PARM_DESC(core_debug,"enable debug messages [core]");
38 #define em28xx_coredbg(fmt, arg...) do {\
39 if (core_debug) \
40 printk(KERN_INFO "%s %s :"fmt, \
41 dev->name, __func__ , ##arg); } while (0)
43 static unsigned int reg_debug;
44 module_param(reg_debug,int,0644);
45 MODULE_PARM_DESC(reg_debug,"enable debug messages [URB reg]");
47 #define em28xx_regdbg(fmt, arg...) do {\
48 if (reg_debug) \
49 printk(KERN_INFO "%s %s :"fmt, \
50 dev->name, __func__ , ##arg); } while (0)
52 static int alt = EM28XX_PINOUT;
53 module_param(alt, int, 0644);
54 MODULE_PARM_DESC(alt, "alternate setting to use for video endpoint");
56 /* FIXME */
57 #define em28xx_isocdbg(fmt, arg...) do {\
58 if (core_debug) \
59 printk(KERN_INFO "%s %s :"fmt, \
60 dev->name, __func__ , ##arg); } while (0)
63 * em28xx_read_reg_req()
64 * reads data from the usb device specifying bRequest
66 int em28xx_read_reg_req_len(struct em28xx *dev, u8 req, u16 reg,
67 char *buf, int len)
69 int ret, byte;
71 if (dev->state & DEV_DISCONNECTED)
72 return(-ENODEV);
74 em28xx_regdbg("req=%02x, reg=%02x ", req, reg);
76 ret = usb_control_msg(dev->udev, usb_rcvctrlpipe(dev->udev, 0), req,
77 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
78 0x0000, reg, buf, len, HZ);
80 if (reg_debug) {
81 printk(ret < 0 ? " failed!\n" : "%02x values: ", ret);
82 for (byte = 0; byte < len; byte++)
83 printk(" %02x", (unsigned char)buf[byte]);
85 printk("\n");
88 return ret;
92 * em28xx_read_reg_req()
93 * reads data from the usb device specifying bRequest
95 int em28xx_read_reg_req(struct em28xx *dev, u8 req, u16 reg)
97 u8 val;
98 int ret;
100 if (dev->state & DEV_DISCONNECTED)
101 return(-ENODEV);
103 em28xx_regdbg("req=%02x, reg=%02x:", req, reg);
105 ret = usb_control_msg(dev->udev, usb_rcvctrlpipe(dev->udev, 0), req,
106 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
107 0x0000, reg, &val, 1, HZ);
109 if (reg_debug)
110 printk(ret < 0 ? " failed!\n" :
111 "%02x\n", (unsigned char) val);
113 if (ret < 0)
114 return ret;
116 return val;
119 int em28xx_read_reg(struct em28xx *dev, u16 reg)
121 return em28xx_read_reg_req(dev, USB_REQ_GET_STATUS, reg);
125 * em28xx_write_regs_req()
126 * sends data to the usb device, specifying bRequest
128 int em28xx_write_regs_req(struct em28xx *dev, u8 req, u16 reg, char *buf,
129 int len)
131 int ret;
133 /*usb_control_msg seems to expect a kmalloced buffer */
134 unsigned char *bufs;
136 if (dev->state & DEV_DISCONNECTED)
137 return -ENODEV;
139 if (len < 1)
140 return -EINVAL;
142 bufs = kmalloc(len, GFP_KERNEL);
144 em28xx_regdbg("req=%02x reg=%02x:", req, reg);
146 if (reg_debug) {
147 int i;
148 for (i = 0; i < len; ++i)
149 printk(" %02x", (unsigned char)buf[i]);
150 printk("\n");
153 if (!bufs)
154 return -ENOMEM;
155 memcpy(bufs, buf, len);
156 ret = usb_control_msg(dev->udev, usb_sndctrlpipe(dev->udev, 0), req,
157 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
158 0x0000, reg, bufs, len, HZ);
159 if (dev->wait_after_write)
160 msleep(dev->wait_after_write);
162 kfree(bufs);
163 return ret;
166 int em28xx_write_regs(struct em28xx *dev, u16 reg, char *buf, int len)
168 int rc;
170 rc = em28xx_write_regs_req(dev, USB_REQ_GET_STATUS, reg, buf, len);
172 /* Stores GPO/GPIO values at the cache, if changed
173 Only write values should be stored, since input on a GPIO
174 register will return the input bits.
175 Not sure what happens on reading GPO register.
177 if (rc >= 0) {
178 if (reg == EM2880_R04_GPO)
179 dev->reg_gpo = buf[0];
180 else if (reg == EM28XX_R08_GPIO)
181 dev->reg_gpio = buf[0];
184 return rc;
188 * em28xx_write_reg_bits()
189 * sets only some bits (specified by bitmask) of a register, by first reading
190 * the actual value
192 static int em28xx_write_reg_bits(struct em28xx *dev, u16 reg, u8 val,
193 u8 bitmask)
195 int oldval;
196 u8 newval;
198 /* Uses cache for gpo/gpio registers */
199 if (reg == EM2880_R04_GPO)
200 oldval = dev->reg_gpo;
201 else if (reg == EM28XX_R08_GPIO)
202 oldval = dev->reg_gpio;
203 else
204 oldval = em28xx_read_reg(dev, reg);
206 if (oldval < 0)
207 return oldval;
209 newval = (((u8) oldval) & ~bitmask) | (val & bitmask);
211 return em28xx_write_regs(dev, reg, &newval, 1);
215 * em28xx_write_ac97()
216 * write a 16 bit value to the specified AC97 address (LSB first!)
218 static int em28xx_write_ac97(struct em28xx *dev, u8 reg, u8 *val)
220 int ret, i;
221 u8 addr = reg & 0x7f;
223 ret = em28xx_write_regs(dev, EM28XX_R40_AC97LSB, val, 2);
224 if (ret < 0)
225 return ret;
227 ret = em28xx_write_regs(dev, EM28XX_R42_AC97ADDR, &addr, 1);
228 if (ret < 0)
229 return ret;
231 /* Wait up to 50 ms for AC97 command to complete */
232 for (i = 0; i < 10; i++) {
233 ret = em28xx_read_reg(dev, EM28XX_R43_AC97BUSY);
234 if (ret < 0)
235 return ret;
237 if (!(ret & 0x01))
238 return 0;
239 msleep(5);
241 em28xx_warn("AC97 command still being executed: not handled properly!\n");
242 return 0;
245 static int em28xx_set_audio_source(struct em28xx *dev)
247 static char *enable = "\x08\x08";
248 static char *disable = "\x08\x88";
249 char *video = enable, *line = disable;
250 int ret;
251 u8 input;
253 if (dev->is_em2800) {
254 if (dev->ctl_ainput)
255 input = EM2800_AUDIO_SRC_LINE;
256 else
257 input = EM2800_AUDIO_SRC_TUNER;
259 ret = em28xx_write_regs(dev, EM2800_R08_AUDIOSRC, &input, 1);
260 if (ret < 0)
261 return ret;
264 if (dev->has_msp34xx)
265 input = EM28XX_AUDIO_SRC_TUNER;
266 else {
267 switch (dev->ctl_ainput) {
268 case EM28XX_AMUX_VIDEO:
269 input = EM28XX_AUDIO_SRC_TUNER;
270 break;
271 case EM28XX_AMUX_LINE_IN:
272 input = EM28XX_AUDIO_SRC_LINE;
273 break;
274 case EM28XX_AMUX_AC97_VIDEO:
275 input = EM28XX_AUDIO_SRC_LINE;
276 break;
277 case EM28XX_AMUX_AC97_LINE_IN:
278 input = EM28XX_AUDIO_SRC_LINE;
279 video = disable;
280 line = enable;
281 break;
285 ret = em28xx_write_reg_bits(dev, EM28XX_R0E_AUDIOSRC, input, 0xc0);
286 if (ret < 0)
287 return ret;
288 msleep(5);
290 /* Sets AC97 mixer registers
291 This is seems to be needed, even for non-ac97 configs
293 ret = em28xx_write_ac97(dev, EM28XX_R14_VIDEO_AC97, video);
294 if (ret < 0)
295 return ret;
297 ret = em28xx_write_ac97(dev, EM28XX_R10_LINE_IN_AC97, line);
299 return ret;
302 int em28xx_audio_analog_set(struct em28xx *dev)
304 int ret;
305 char s[2] = { 0x00, 0x00 };
306 u8 xclk = 0x07;
308 s[0] |= 0x1f - dev->volume;
309 s[1] |= 0x1f - dev->volume;
311 /* Mute */
312 s[1] |= 0x80;
313 ret = em28xx_write_ac97(dev, EM28XX_R02_MASTER_AC97, s);
315 if (ret < 0)
316 return ret;
318 if (dev->has_12mhz_i2s)
319 xclk |= 0x20;
321 if (!dev->mute)
322 xclk |= 0x80;
324 ret = em28xx_write_reg_bits(dev, EM28XX_R0F_XCLK, xclk, 0xa7);
325 if (ret < 0)
326 return ret;
327 msleep(10);
329 /* Selects the proper audio input */
330 ret = em28xx_set_audio_source(dev);
332 /* Unmute device */
333 if (!dev->mute)
334 s[1] &= ~0x80;
335 ret = em28xx_write_ac97(dev, EM28XX_R02_MASTER_AC97, s);
337 return ret;
339 EXPORT_SYMBOL_GPL(em28xx_audio_analog_set);
341 int em28xx_colorlevels_set_default(struct em28xx *dev)
343 em28xx_write_regs(dev, EM28XX_R20_YGAIN, "\x10", 1); /* contrast */
344 em28xx_write_regs(dev, EM28XX_R21_YOFFSET, "\x00", 1); /* brightness */
345 em28xx_write_regs(dev, EM28XX_R22_UVGAIN, "\x10", 1); /* saturation */
346 em28xx_write_regs(dev, EM28XX_R23_UOFFSET, "\x00", 1);
347 em28xx_write_regs(dev, EM28XX_R24_VOFFSET, "\x00", 1);
348 em28xx_write_regs(dev, EM28XX_R25_SHARPNESS, "\x00", 1);
350 em28xx_write_regs(dev, EM28XX_R14_GAMMA, "\x20", 1);
351 em28xx_write_regs(dev, EM28XX_R15_RGAIN, "\x20", 1);
352 em28xx_write_regs(dev, EM28XX_R16_GGAIN, "\x20", 1);
353 em28xx_write_regs(dev, EM28XX_R17_BGAIN, "\x20", 1);
354 em28xx_write_regs(dev, EM28XX_R18_ROFFSET, "\x00", 1);
355 em28xx_write_regs(dev, EM28XX_R19_GOFFSET, "\x00", 1);
356 return em28xx_write_regs(dev, EM28XX_R1A_BOFFSET, "\x00", 1);
359 int em28xx_capture_start(struct em28xx *dev, int start)
361 int rc;
362 /* FIXME: which is the best order? */
363 /* video registers are sampled by VREF */
364 rc = em28xx_write_reg_bits(dev, EM28XX_R0C_USBSUSP,
365 start ? 0x10 : 0x00, 0x10);
366 if (rc < 0)
367 return rc;
369 if (!start) {
370 /* disable video capture */
371 rc = em28xx_write_regs(dev, EM28XX_R12_VINENABLE, "\x27", 1);
372 return rc;
375 /* enable video capture */
376 rc = em28xx_write_regs_req(dev, 0x00, 0x48, "\x00", 1);
378 if (dev->mode == EM28XX_ANALOG_MODE)
379 rc = em28xx_write_regs(dev, EM28XX_R12_VINENABLE, "\x67", 1);
380 else
381 rc = em28xx_write_regs(dev, EM28XX_R12_VINENABLE, "\x37", 1);
383 msleep(6);
385 return rc;
388 int em28xx_outfmt_set_yuv422(struct em28xx *dev)
390 em28xx_write_regs(dev, EM28XX_R27_OUTFMT, "\x34", 1);
391 em28xx_write_regs(dev, EM28XX_R10_VINMODE, "\x10", 1);
392 return em28xx_write_regs(dev, EM28XX_R11_VINCTRL, "\x11", 1);
395 static int em28xx_accumulator_set(struct em28xx *dev, u8 xmin, u8 xmax,
396 u8 ymin, u8 ymax)
398 em28xx_coredbg("em28xx Scale: (%d,%d)-(%d,%d)\n",
399 xmin, ymin, xmax, ymax);
401 em28xx_write_regs(dev, EM28XX_R28_XMIN, &xmin, 1);
402 em28xx_write_regs(dev, EM28XX_R29_XMAX, &xmax, 1);
403 em28xx_write_regs(dev, EM28XX_R2A_YMIN, &ymin, 1);
404 return em28xx_write_regs(dev, EM28XX_R2B_YMAX, &ymax, 1);
407 static int em28xx_capture_area_set(struct em28xx *dev, u8 hstart, u8 vstart,
408 u16 width, u16 height)
410 u8 cwidth = width;
411 u8 cheight = height;
412 u8 overflow = (height >> 7 & 0x02) | (width >> 8 & 0x01);
414 em28xx_coredbg("em28xx Area Set: (%d,%d)\n",
415 (width | (overflow & 2) << 7),
416 (height | (overflow & 1) << 8));
418 em28xx_write_regs(dev, EM28XX_R1C_HSTART, &hstart, 1);
419 em28xx_write_regs(dev, EM28XX_R1D_VSTART, &vstart, 1);
420 em28xx_write_regs(dev, EM28XX_R1E_CWIDTH, &cwidth, 1);
421 em28xx_write_regs(dev, EM28XX_R1F_CHEIGHT, &cheight, 1);
422 return em28xx_write_regs(dev, EM28XX_R1B_OFLOW, &overflow, 1);
425 static int em28xx_scaler_set(struct em28xx *dev, u16 h, u16 v)
427 u8 mode;
428 /* the em2800 scaler only supports scaling down to 50% */
429 if (dev->is_em2800)
430 mode = (v ? 0x20 : 0x00) | (h ? 0x10 : 0x00);
431 else {
432 u8 buf[2];
433 buf[0] = h;
434 buf[1] = h >> 8;
435 em28xx_write_regs(dev, EM28XX_R30_HSCALELOW, (char *)buf, 2);
436 buf[0] = v;
437 buf[1] = v >> 8;
438 em28xx_write_regs(dev, EM28XX_R32_VSCALELOW, (char *)buf, 2);
439 /* it seems that both H and V scalers must be active
440 to work correctly */
441 mode = (h || v)? 0x30: 0x00;
443 return em28xx_write_reg_bits(dev, EM28XX_R26_COMPR, mode, 0x30);
446 /* FIXME: this only function read values from dev */
447 int em28xx_resolution_set(struct em28xx *dev)
449 int width, height;
450 width = norm_maxw(dev);
451 height = norm_maxh(dev) >> 1;
453 em28xx_outfmt_set_yuv422(dev);
454 em28xx_accumulator_set(dev, 1, (width - 4) >> 2, 1, (height - 4) >> 2);
455 em28xx_capture_area_set(dev, 0, 0, width >> 2, height >> 2);
456 return em28xx_scaler_set(dev, dev->hscale, dev->vscale);
459 int em28xx_set_alternate(struct em28xx *dev)
461 int errCode, prev_alt = dev->alt;
462 int i;
463 unsigned int min_pkt_size = dev->width * 2 + 4;
465 /* When image size is bigger than a certain value,
466 the frame size should be increased, otherwise, only
467 green screen will be received.
469 if (dev->width * 2 * dev->height > 720 * 240 * 2)
470 min_pkt_size *= 2;
472 for (i = 0; i < dev->num_alt; i++) {
473 /* stop when the selected alt setting offers enough bandwidth */
474 if (dev->alt_max_pkt_size[i] >= min_pkt_size) {
475 dev->alt = i;
476 break;
477 /* otherwise make sure that we end up with the maximum bandwidth
478 because the min_pkt_size equation might be wrong...
480 } else if (dev->alt_max_pkt_size[i] >
481 dev->alt_max_pkt_size[dev->alt])
482 dev->alt = i;
485 if (dev->alt != prev_alt) {
486 em28xx_coredbg("minimum isoc packet size: %u (alt=%d)\n",
487 min_pkt_size, dev->alt);
488 dev->max_pkt_size = dev->alt_max_pkt_size[dev->alt];
489 em28xx_coredbg("setting alternate %d with wMaxPacketSize=%u\n",
490 dev->alt, dev->max_pkt_size);
491 errCode = usb_set_interface(dev->udev, 0, dev->alt);
492 if (errCode < 0) {
493 em28xx_errdev("cannot change alternate number to %d (error=%i)\n",
494 dev->alt, errCode);
495 return errCode;
498 return 0;
501 int em28xx_gpio_set(struct em28xx *dev, struct em28xx_reg_seq *gpio)
503 int rc = 0;
505 if (!gpio)
506 return rc;
508 dev->em28xx_write_regs_req(dev, 0x00, 0x48, "\x00", 1);
509 if (dev->mode == EM28XX_ANALOG_MODE)
510 dev->em28xx_write_regs_req(dev, 0x00, 0x12, "\x67", 1);
511 else
512 dev->em28xx_write_regs_req(dev, 0x00, 0x12, "\x37", 1);
513 msleep(6);
515 /* Send GPIO reset sequences specified at board entry */
516 while (gpio->sleep >= 0) {
517 if (gpio->reg >= 0) {
518 rc = em28xx_write_reg_bits(dev,
519 gpio->reg,
520 gpio->val,
521 gpio->mask);
522 if (rc < 0)
523 return rc;
525 if (gpio->sleep > 0)
526 msleep(gpio->sleep);
528 gpio++;
530 return rc;
533 int em28xx_set_mode(struct em28xx *dev, enum em28xx_mode set_mode)
535 if (dev->mode == set_mode)
536 return 0;
538 if (set_mode == EM28XX_MODE_UNDEFINED) {
539 dev->mode = set_mode;
540 return 0;
543 dev->mode = set_mode;
545 if (dev->mode == EM28XX_DIGITAL_MODE)
546 return em28xx_gpio_set(dev, dev->digital_gpio);
547 else
548 return em28xx_gpio_set(dev, dev->analog_gpio);
550 EXPORT_SYMBOL_GPL(em28xx_set_mode);
552 /* ------------------------------------------------------------------
553 URB control
554 ------------------------------------------------------------------*/
557 * IRQ callback, called by URB callback
559 static void em28xx_irq_callback(struct urb *urb)
561 struct em28xx_dmaqueue *dma_q = urb->context;
562 struct em28xx *dev = container_of(dma_q, struct em28xx, vidq);
563 int rc, i;
565 /* Copy data from URB */
566 spin_lock(&dev->slock);
567 rc = dev->isoc_ctl.isoc_copy(dev, urb);
568 spin_unlock(&dev->slock);
570 /* Reset urb buffers */
571 for (i = 0; i < urb->number_of_packets; i++) {
572 urb->iso_frame_desc[i].status = 0;
573 urb->iso_frame_desc[i].actual_length = 0;
575 urb->status = 0;
577 urb->status = usb_submit_urb(urb, GFP_ATOMIC);
578 if (urb->status) {
579 em28xx_isocdbg("urb resubmit failed (error=%i)\n",
580 urb->status);
585 * Stop and Deallocate URBs
587 void em28xx_uninit_isoc(struct em28xx *dev)
589 struct urb *urb;
590 int i;
592 em28xx_isocdbg("em28xx: called em28xx_uninit_isoc\n");
594 dev->isoc_ctl.nfields = -1;
595 for (i = 0; i < dev->isoc_ctl.num_bufs; i++) {
596 urb = dev->isoc_ctl.urb[i];
597 if (urb) {
598 usb_kill_urb(urb);
599 usb_unlink_urb(urb);
600 if (dev->isoc_ctl.transfer_buffer[i]) {
601 usb_buffer_free(dev->udev,
602 urb->transfer_buffer_length,
603 dev->isoc_ctl.transfer_buffer[i],
604 urb->transfer_dma);
606 usb_free_urb(urb);
607 dev->isoc_ctl.urb[i] = NULL;
609 dev->isoc_ctl.transfer_buffer[i] = NULL;
612 kfree(dev->isoc_ctl.urb);
613 kfree(dev->isoc_ctl.transfer_buffer);
615 dev->isoc_ctl.urb = NULL;
616 dev->isoc_ctl.transfer_buffer = NULL;
617 dev->isoc_ctl.num_bufs = 0;
619 em28xx_capture_start(dev, 0);
621 EXPORT_SYMBOL_GPL(em28xx_uninit_isoc);
624 * Allocate URBs and start IRQ
626 int em28xx_init_isoc(struct em28xx *dev, int max_packets,
627 int num_bufs, int max_pkt_size,
628 int (*isoc_copy) (struct em28xx *dev, struct urb *urb))
630 struct em28xx_dmaqueue *dma_q = &dev->vidq;
631 int i;
632 int sb_size, pipe;
633 struct urb *urb;
634 int j, k;
635 int rc;
637 em28xx_isocdbg("em28xx: called em28xx_prepare_isoc\n");
639 /* De-allocates all pending stuff */
640 em28xx_uninit_isoc(dev);
642 dev->isoc_ctl.isoc_copy = isoc_copy;
643 dev->isoc_ctl.num_bufs = num_bufs;
645 dev->isoc_ctl.urb = kzalloc(sizeof(void *)*num_bufs, GFP_KERNEL);
646 if (!dev->isoc_ctl.urb) {
647 em28xx_errdev("cannot alloc memory for usb buffers\n");
648 return -ENOMEM;
651 dev->isoc_ctl.transfer_buffer = kzalloc(sizeof(void *)*num_bufs,
652 GFP_KERNEL);
653 if (!dev->isoc_ctl.transfer_buffer) {
654 em28xx_errdev("cannot allocate memory for usbtransfer\n");
655 kfree(dev->isoc_ctl.urb);
656 return -ENOMEM;
659 dev->isoc_ctl.max_pkt_size = max_pkt_size;
660 dev->isoc_ctl.buf = NULL;
662 sb_size = max_packets * dev->isoc_ctl.max_pkt_size;
664 /* allocate urbs and transfer buffers */
665 for (i = 0; i < dev->isoc_ctl.num_bufs; i++) {
666 urb = usb_alloc_urb(max_packets, GFP_KERNEL);
667 if (!urb) {
668 em28xx_err("cannot alloc isoc_ctl.urb %i\n", i);
669 em28xx_uninit_isoc(dev);
670 return -ENOMEM;
672 dev->isoc_ctl.urb[i] = urb;
674 dev->isoc_ctl.transfer_buffer[i] = usb_buffer_alloc(dev->udev,
675 sb_size, GFP_KERNEL, &urb->transfer_dma);
676 if (!dev->isoc_ctl.transfer_buffer[i]) {
677 em28xx_err("unable to allocate %i bytes for transfer"
678 " buffer %i%s\n",
679 sb_size, i,
680 in_interrupt()?" while in int":"");
681 em28xx_uninit_isoc(dev);
682 return -ENOMEM;
684 memset(dev->isoc_ctl.transfer_buffer[i], 0, sb_size);
686 /* FIXME: this is a hack - should be
687 'desc.bEndpointAddress & USB_ENDPOINT_NUMBER_MASK'
688 should also be using 'desc.bInterval'
690 pipe = usb_rcvisocpipe(dev->udev,
691 dev->mode == EM28XX_ANALOG_MODE ? 0x82 : 0x84);
693 usb_fill_int_urb(urb, dev->udev, pipe,
694 dev->isoc_ctl.transfer_buffer[i], sb_size,
695 em28xx_irq_callback, dma_q, 1);
697 urb->number_of_packets = max_packets;
698 urb->transfer_flags = URB_ISO_ASAP;
700 k = 0;
701 for (j = 0; j < max_packets; j++) {
702 urb->iso_frame_desc[j].offset = k;
703 urb->iso_frame_desc[j].length =
704 dev->isoc_ctl.max_pkt_size;
705 k += dev->isoc_ctl.max_pkt_size;
709 init_waitqueue_head(&dma_q->wq);
711 em28xx_capture_start(dev, 1);
713 /* submit urbs and enables IRQ */
714 for (i = 0; i < dev->isoc_ctl.num_bufs; i++) {
715 rc = usb_submit_urb(dev->isoc_ctl.urb[i], GFP_ATOMIC);
716 if (rc) {
717 em28xx_err("submit of urb %i failed (error=%i)\n", i,
718 rc);
719 em28xx_uninit_isoc(dev);
720 return rc;
724 return 0;
726 EXPORT_SYMBOL_GPL(em28xx_init_isoc);