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>
32 /* #define ENABLE_DEBUG_ISOC_FRAMES */
34 static unsigned int core_debug
= 0;
35 module_param(core_debug
,int,0644);
36 MODULE_PARM_DESC(core_debug
,"enable debug messages [core]");
38 #define em28xx_coredbg(fmt, arg...) do {\
40 printk(KERN_INFO "%s %s :"fmt, \
41 dev->name, __FUNCTION__ , ##arg); } while (0)
43 static unsigned int reg_debug
= 0;
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 {\
49 printk(KERN_INFO "%s %s :"fmt, \
50 dev->name, __FUNCTION__ , ##arg); } while (0)
52 static unsigned int isoc_debug
= 0;
53 module_param(isoc_debug
,int,0644);
54 MODULE_PARM_DESC(isoc_debug
,"enable debug messages [isoc transfers]");
56 #define em28xx_isocdbg(fmt, arg...) do {\
58 printk(KERN_INFO "%s %s :"fmt, \
59 dev->name, __FUNCTION__ , ##arg); } while (0)
61 static int alt
= EM28XX_PINOUT
;
62 module_param(alt
, int, 0644);
63 MODULE_PARM_DESC(alt
, "alternate setting to use for video endpoint");
67 * em28xx_request_buffers()
68 * allocate a number of buffers
70 u32
em28xx_request_buffers(struct em28xx
*dev
, u32 count
)
72 const size_t imagesize
= PAGE_ALIGN(dev
->frame_size
); /*needs to be page aligned cause the buffers can be mapped individually! */
75 em28xx_coredbg("requested %i buffers with size %zi", count
, imagesize
);
76 if (count
> EM28XX_NUM_FRAMES
)
77 count
= EM28XX_NUM_FRAMES
;
79 dev
->num_frames
= count
;
80 while (dev
->num_frames
> 0) {
81 if ((buff
= vmalloc_32(dev
->num_frames
* imagesize
))) {
82 memset(buff
, 0, dev
->num_frames
* imagesize
);
88 for (i
= 0; i
< dev
->num_frames
; i
++) {
89 dev
->frame
[i
].bufmem
= buff
+ i
* imagesize
;
90 dev
->frame
[i
].buf
.index
= i
;
91 dev
->frame
[i
].buf
.m
.offset
= i
* imagesize
;
92 dev
->frame
[i
].buf
.length
= dev
->frame_size
;
93 dev
->frame
[i
].buf
.type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
94 dev
->frame
[i
].buf
.sequence
= 0;
95 dev
->frame
[i
].buf
.field
= V4L2_FIELD_NONE
;
96 dev
->frame
[i
].buf
.memory
= V4L2_MEMORY_MMAP
;
97 dev
->frame
[i
].buf
.flags
= 0;
99 return dev
->num_frames
;
103 * em28xx_queue_unusedframes()
104 * add all frames that are not currently in use to the inbuffer queue
106 void em28xx_queue_unusedframes(struct em28xx
*dev
)
108 unsigned long lock_flags
;
111 for (i
= 0; i
< dev
->num_frames
; i
++)
112 if (dev
->frame
[i
].state
== F_UNUSED
) {
113 dev
->frame
[i
].state
= F_QUEUED
;
114 spin_lock_irqsave(&dev
->queue_lock
, lock_flags
);
115 list_add_tail(&dev
->frame
[i
].frame
, &dev
->inqueue
);
116 spin_unlock_irqrestore(&dev
->queue_lock
, lock_flags
);
121 * em28xx_release_buffers()
124 void em28xx_release_buffers(struct em28xx
*dev
)
126 if (dev
->num_frames
) {
127 vfree(dev
->frame
[0].bufmem
);
133 * em28xx_read_reg_req()
134 * reads data from the usb device specifying bRequest
136 int em28xx_read_reg_req_len(struct em28xx
*dev
, u8 req
, u16 reg
,
141 if (dev
->state
& DEV_DISCONNECTED
)
144 em28xx_regdbg("req=%02x, reg=%02x ", req
, reg
);
146 ret
= usb_control_msg(dev
->udev
, usb_rcvctrlpipe(dev
->udev
, 0), req
,
147 USB_DIR_IN
| USB_TYPE_VENDOR
| USB_RECIP_DEVICE
,
148 0x0000, reg
, buf
, len
, HZ
);
151 printk(ret
< 0 ? " failed!\n" : "%02x values: ", ret
);
152 for (byte
= 0; byte
< len
; byte
++) {
153 printk(" %02x", (unsigned char)buf
[byte
]);
162 * em28xx_read_reg_req()
163 * reads data from the usb device specifying bRequest
165 int em28xx_read_reg_req(struct em28xx
*dev
, u8 req
, u16 reg
)
170 if (dev
->state
& DEV_DISCONNECTED
)
173 em28xx_regdbg("req=%02x, reg=%02x:", req
, reg
);
175 ret
= usb_control_msg(dev
->udev
, usb_rcvctrlpipe(dev
->udev
, 0), req
,
176 USB_DIR_IN
| USB_TYPE_VENDOR
| USB_RECIP_DEVICE
,
177 0x0000, reg
, &val
, 1, HZ
);
180 printk(ret
< 0 ? " failed!\n" :
181 "%02x\n", (unsigned char) val
);
189 int em28xx_read_reg(struct em28xx
*dev
, u16 reg
)
191 return em28xx_read_reg_req(dev
, USB_REQ_GET_STATUS
, reg
);
195 * em28xx_write_regs_req()
196 * sends data to the usb device, specifying bRequest
198 int em28xx_write_regs_req(struct em28xx
*dev
, u8 req
, u16 reg
, char *buf
,
203 /*usb_control_msg seems to expect a kmalloced buffer */
206 if (dev
->state
& DEV_DISCONNECTED
)
209 bufs
= kmalloc(len
, GFP_KERNEL
);
211 em28xx_regdbg("req=%02x reg=%02x:", req
, reg
);
215 for (i
= 0; i
< len
; ++i
)
216 printk (" %02x", (unsigned char)buf
[i
]);
222 memcpy(bufs
, buf
, len
);
223 ret
= usb_control_msg(dev
->udev
, usb_sndctrlpipe(dev
->udev
, 0), req
,
224 USB_DIR_OUT
| USB_TYPE_VENDOR
| USB_RECIP_DEVICE
,
225 0x0000, reg
, bufs
, len
, HZ
);
226 msleep(5); /* FIXME: magic number */
231 int em28xx_write_regs(struct em28xx
*dev
, u16 reg
, char *buf
, int len
)
233 return em28xx_write_regs_req(dev
, USB_REQ_GET_STATUS
, reg
, buf
, len
);
237 * em28xx_write_reg_bits()
238 * sets only some bits (specified by bitmask) of a register, by first reading
241 static int em28xx_write_reg_bits(struct em28xx
*dev
, u16 reg
, u8 val
,
246 if ((oldval
= em28xx_read_reg(dev
, reg
)) < 0)
248 newval
= (((u8
) oldval
) & ~bitmask
) | (val
& bitmask
);
249 return em28xx_write_regs(dev
, reg
, &newval
, 1);
253 * em28xx_write_ac97()
254 * write a 16 bit value to the specified AC97 address (LSB first!)
256 static int em28xx_write_ac97(struct em28xx
*dev
, u8 reg
, u8
*val
)
259 u8 addr
= reg
& 0x7f;
260 if ((ret
= em28xx_write_regs(dev
, AC97LSB_REG
, val
, 2)) < 0)
262 if ((ret
= em28xx_write_regs(dev
, AC97ADDR_REG
, &addr
, 1)) < 0)
264 if ((ret
= em28xx_read_reg(dev
, AC97BUSY_REG
)) < 0)
266 else if (((u8
) ret
) & 0x01) {
267 em28xx_warn ("AC97 command still being executed: not handled properly!\n");
272 int em28xx_set_audio_source(struct em28xx
*dev
)
274 static char *enable
= "\x08\x08";
275 static char *disable
= "\x08\x88";
276 char *video
= enable
, *line
= disable
;
280 if (dev
->is_em2800
) {
282 input
= EM2800_AUDIO_SRC_LINE
;
284 input
= EM2800_AUDIO_SRC_TUNER
;
286 ret
= em28xx_write_regs(dev
, EM2800_AUDIOSRC_REG
, &input
, 1);
291 if (dev
->has_msp34xx
)
292 input
= EM28XX_AUDIO_SRC_TUNER
;
294 switch (dev
->ctl_ainput
) {
295 case EM28XX_AMUX_VIDEO
:
296 input
= EM28XX_AUDIO_SRC_TUNER
;
298 case EM28XX_AMUX_LINE_IN
:
299 input
= EM28XX_AUDIO_SRC_LINE
;
301 case EM28XX_AMUX_AC97_VIDEO
:
302 input
= EM28XX_AUDIO_SRC_LINE
;
304 case EM28XX_AMUX_AC97_LINE_IN
:
305 input
= EM28XX_AUDIO_SRC_LINE
;
312 ret
= em28xx_write_reg_bits(dev
, AUDIOSRC_REG
, input
, 0xc0);
316 /* Sets AC97 mixer registers
317 This is seems to be needed, even for non-ac97 configs
319 ret
= em28xx_write_ac97(dev
, VIDEO_AC97
, video
);
323 ret
= em28xx_write_ac97(dev
, LINE_IN_AC97
, line
);
328 int em28xx_audio_analog_set(struct em28xx
*dev
)
331 char s
[2] = { 0x00, 0x00 };
334 s
[0] |= 0x1f - dev
->volume
;
335 s
[1] |= 0x1f - dev
->volume
;
339 ret
= em28xx_write_ac97(dev
, MASTER_AC97
, s
);
343 if (dev
->has_12mhz_i2s
)
349 ret
= em28xx_write_reg_bits(dev
, XCLK_REG
, xclk
, 0xa7);
354 /* Selects the proper audio input */
355 ret
= em28xx_set_audio_source(dev
);
359 EXPORT_SYMBOL_GPL(em28xx_audio_analog_set
);
361 int em28xx_colorlevels_set_default(struct em28xx
*dev
)
363 em28xx_write_regs(dev
, YGAIN_REG
, "\x10", 1); /* contrast */
364 em28xx_write_regs(dev
, YOFFSET_REG
, "\x00", 1); /* brightness */
365 em28xx_write_regs(dev
, UVGAIN_REG
, "\x10", 1); /* saturation */
366 em28xx_write_regs(dev
, UOFFSET_REG
, "\x00", 1);
367 em28xx_write_regs(dev
, VOFFSET_REG
, "\x00", 1);
368 em28xx_write_regs(dev
, SHARPNESS_REG
, "\x00", 1);
370 em28xx_write_regs(dev
, GAMMA_REG
, "\x20", 1);
371 em28xx_write_regs(dev
, RGAIN_REG
, "\x20", 1);
372 em28xx_write_regs(dev
, GGAIN_REG
, "\x20", 1);
373 em28xx_write_regs(dev
, BGAIN_REG
, "\x20", 1);
374 em28xx_write_regs(dev
, ROFFSET_REG
, "\x00", 1);
375 em28xx_write_regs(dev
, GOFFSET_REG
, "\x00", 1);
376 return em28xx_write_regs(dev
, BOFFSET_REG
, "\x00", 1);
379 int em28xx_capture_start(struct em28xx
*dev
, int start
)
382 /* FIXME: which is the best order? */
383 /* video registers are sampled by VREF */
384 if ((ret
= em28xx_write_reg_bits(dev
, USBSUSP_REG
, start
? 0x10 : 0x00,
387 /* enable video capture */
388 return em28xx_write_regs(dev
, VINENABLE_REG
, start
? "\x67" : "\x27", 1);
391 int em28xx_outfmt_set_yuv422(struct em28xx
*dev
)
393 em28xx_write_regs(dev
, OUTFMT_REG
, "\x34", 1);
394 em28xx_write_regs(dev
, VINMODE_REG
, "\x10", 1);
395 return em28xx_write_regs(dev
, VINCTRL_REG
, "\x11", 1);
398 static int em28xx_accumulator_set(struct em28xx
*dev
, u8 xmin
, u8 xmax
,
401 em28xx_coredbg("em28xx Scale: (%d,%d)-(%d,%d)\n", xmin
, ymin
, xmax
, ymax
);
403 em28xx_write_regs(dev
, XMIN_REG
, &xmin
, 1);
404 em28xx_write_regs(dev
, XMAX_REG
, &xmax
, 1);
405 em28xx_write_regs(dev
, YMIN_REG
, &ymin
, 1);
406 return em28xx_write_regs(dev
, YMAX_REG
, &ymax
, 1);
409 static int em28xx_capture_area_set(struct em28xx
*dev
, u8 hstart
, u8 vstart
,
410 u16 width
, u16 height
)
414 u8 overflow
= (height
>> 7 & 0x02) | (width
>> 8 & 0x01);
416 em28xx_coredbg("em28xx Area Set: (%d,%d)\n", (width
| (overflow
& 2) << 7),
417 (height
| (overflow
& 1) << 8));
419 em28xx_write_regs(dev
, HSTART_REG
, &hstart
, 1);
420 em28xx_write_regs(dev
, VSTART_REG
, &vstart
, 1);
421 em28xx_write_regs(dev
, CWIDTH_REG
, &cwidth
, 1);
422 em28xx_write_regs(dev
, CHEIGHT_REG
, &cheight
, 1);
423 return em28xx_write_regs(dev
, OFLOW_REG
, &overflow
, 1);
426 static int em28xx_scaler_set(struct em28xx
*dev
, u16 h
, u16 v
)
429 /* the em2800 scaler only supports scaling down to 50% */
431 mode
= (v
? 0x20 : 0x00) | (h
? 0x10 : 0x00);
436 em28xx_write_regs(dev
, HSCALELOW_REG
, (char *)buf
, 2);
439 em28xx_write_regs(dev
, VSCALELOW_REG
, (char *)buf
, 2);
440 /* it seems that both H and V scalers must be active to work correctly */
441 mode
= (h
|| v
)? 0x30: 0x00;
443 return em28xx_write_reg_bits(dev
, COMPR_REG
, mode
, 0x30);
446 /* FIXME: this only function read values from dev */
447 int em28xx_resolution_set(struct em28xx
*dev
)
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
);
460 /******************* isoc transfer handling ****************************/
462 #ifdef ENABLE_DEBUG_ISOC_FRAMES
463 static void em28xx_isoc_dump(struct urb
*urb
)
469 printk(KERN_DEBUG
"isocIrq: sf=%d np=%d ec=%x\n",
470 urb
->start_frame
, urb
->number_of_packets
,
472 for (i
= 0; i
< urb
->number_of_packets
; i
++) {
474 urb
->transfer_buffer
+
475 urb
->iso_frame_desc
[i
].offset
;
476 int alen
= urb
->iso_frame_desc
[i
].actual_length
;
478 if (buf
[0] == 0x88) {
481 } else if (buf
[0] == 0x22) {
483 "= l=%d nt=%d bpp=%d\n",
484 len
- 4 * ntrans
, ntrans
,
485 ntrans
== 0 ? 0 : len
/ ntrans
);
489 printk(KERN_DEBUG
"!\n");
491 printk(KERN_DEBUG
" n=%d s=%d al=%d %x\n", i
,
492 urb
->iso_frame_desc
[i
].status
,
493 urb
->iso_frame_desc
[i
].actual_length
,
495 *((unsigned char *)(urb
->transfer_buffer
+
496 urb
->iso_frame_desc
[i
].
502 static inline int em28xx_isoc_video(struct em28xx
*dev
,struct em28xx_frame_t
**f
,
503 unsigned long *lock_flags
, unsigned char buf
)
506 if ((*f
)->state
== F_GRABBING
) {
507 /*previous frame is incomplete */
508 if ((*f
)->fieldbytesused
< dev
->field_size
) {
509 (*f
)->state
= F_ERROR
;
510 em28xx_isocdbg ("dropping incomplete bottom field (%i missing bytes)",
511 dev
->field_size
-(*f
)->fieldbytesused
);
513 (*f
)->state
= F_DONE
;
514 (*f
)->buf
.bytesused
= dev
->frame_size
;
517 if ((*f
)->state
== F_DONE
|| (*f
)->state
== F_ERROR
) {
518 /* move current frame to outqueue and get next free buffer from inqueue */
519 spin_lock_irqsave(&dev
-> queue_lock
, *lock_flags
);
520 list_move_tail(&(*f
)->frame
, &dev
->outqueue
);
521 if (!list_empty(&dev
->inqueue
))
522 (*f
) = list_entry(dev
-> inqueue
.next
,
523 struct em28xx_frame_t
,frame
);
526 spin_unlock_irqrestore(&dev
->queue_lock
,*lock_flags
);
529 em28xx_isocdbg ("new frame but no buffer is free");
532 do_gettimeofday(&(*f
)->buf
.timestamp
);
533 (*f
)->buf
.sequence
= ++dev
->frame_count
;
534 (*f
)->buf
.field
= V4L2_FIELD_INTERLACED
;
535 (*f
)->state
= F_GRABBING
;
536 (*f
)->buf
.bytesused
= 0;
538 (*f
)->fieldbytesused
= 0;
540 /* acquiring bottom field */
541 if ((*f
)->state
== F_GRABBING
) {
542 if (!(*f
)->top_field
) {
543 (*f
)->state
= F_ERROR
;
544 em28xx_isocdbg ("unexpected begin of bottom field; discarding it");
545 } else if ((*f
)-> fieldbytesused
< dev
->field_size
- 172) {
546 (*f
)->state
= F_ERROR
;
547 em28xx_isocdbg ("dropping incomplete top field (%i missing bytes)",
548 dev
->field_size
-(*f
)->fieldbytesused
);
551 (*f
)->fieldbytesused
= 0;
558 static inline void em28xx_isoc_video_copy(struct em28xx
*dev
,
559 struct em28xx_frame_t
**f
, unsigned char *buf
, int len
)
561 void *fieldstart
, *startwrite
, *startread
;
562 int linesdone
, currlinedone
, offset
, lencopy
,remain
;
564 if(dev
->frame_size
!= (*f
)->buf
.length
){
565 em28xx_err("frame_size %i and buf.length %i are different!!!\n",dev
->frame_size
,(*f
)->buf
.length
);
569 if ((*f
)->fieldbytesused
+ len
> dev
->field_size
)
570 len
=dev
->field_size
- (*f
)->fieldbytesused
;
572 if (buf
[0] != 0x88 && buf
[0] != 0x22) {
573 em28xx_isocdbg("frame is not complete\n");
582 fieldstart
= (*f
)->bufmem
;
584 fieldstart
= (*f
)->bufmem
+ dev
->bytesperline
;
586 linesdone
= (*f
)->fieldbytesused
/ dev
->bytesperline
;
587 currlinedone
= (*f
)->fieldbytesused
% dev
->bytesperline
;
588 offset
= linesdone
* dev
->bytesperline
* 2 + currlinedone
;
589 startwrite
= fieldstart
+ offset
;
590 lencopy
= dev
->bytesperline
- currlinedone
;
591 lencopy
= lencopy
> remain
? remain
: lencopy
;
593 memcpy(startwrite
, startread
, lencopy
);
597 startwrite
+= lencopy
+ dev
->bytesperline
;
598 startread
+= lencopy
;
599 if (dev
->bytesperline
> remain
)
602 lencopy
= dev
->bytesperline
;
604 memcpy(startwrite
, startread
, lencopy
);
608 (*f
)->fieldbytesused
+= len
;
613 * handles the incoming isoc urbs and fills the frames from our inqueue
615 static void em28xx_isocIrq(struct urb
*urb
)
617 struct em28xx
*dev
= urb
->context
;
619 struct em28xx_frame_t
**f
;
620 unsigned long lock_flags
;
624 #ifdef ENABLE_DEBUG_ISOC_FRAMES
626 em28xx_isoc_dump(urb
);
629 if (urb
->status
== -ENOENT
)
632 f
= &dev
->frame_current
;
634 if (dev
->stream
== STREAM_INTERRUPT
) {
635 dev
->stream
= STREAM_OFF
;
637 (*f
)->state
= F_QUEUED
;
638 em28xx_isocdbg("stream interrupted");
639 wake_up_interruptible(&dev
->wait_stream
);
642 if ((dev
->state
& DEV_DISCONNECTED
) || (dev
->state
& DEV_MISCONFIGURED
))
645 if (dev
->stream
== STREAM_ON
&& !list_empty(&dev
->inqueue
)) {
647 (*f
) = list_entry(dev
->inqueue
.next
,
648 struct em28xx_frame_t
, frame
);
650 for (i
= 0; i
< urb
->number_of_packets
; i
++) {
651 unsigned char *buf
= urb
->transfer_buffer
+
652 urb
->iso_frame_desc
[i
].offset
;
653 int len
= urb
->iso_frame_desc
[i
].actual_length
- 4;
655 if (urb
->iso_frame_desc
[i
].status
) {
656 em28xx_isocdbg("data error: [%d] len=%d, status=%d", i
,
657 urb
->iso_frame_desc
[i
].actual_length
,
658 urb
->iso_frame_desc
[i
].status
);
659 if (urb
->iso_frame_desc
[i
].status
!= -EPROTO
)
662 if (urb
->iso_frame_desc
[i
].actual_length
<= 0) {
663 em28xx_isocdbg("packet %d is empty",i
);
666 if (urb
->iso_frame_desc
[i
].actual_length
>
668 em28xx_isocdbg("packet bigger than packet size");
672 if (buf
[0] == 0x22 && buf
[1] == 0x5a) {
673 em28xx_isocdbg("Video frame, length=%i!",len
);
675 if (em28xx_isoc_video(dev
,f
,&lock_flags
,buf
[2]))
677 } else if (buf
[0]==0x33 && buf
[1]==0x95 && buf
[2]==0x00) {
678 em28xx_isocdbg("VBI HEADER!!!");
682 if ((*f
)->state
== F_GRABBING
) {
683 em28xx_isoc_video_copy(dev
,f
,buf
, len
);
688 for (i
= 0; i
< urb
->number_of_packets
; i
++) {
689 urb
->iso_frame_desc
[i
].status
= 0;
690 urb
->iso_frame_desc
[i
].actual_length
= 0;
694 if ((status
= usb_submit_urb(urb
, GFP_ATOMIC
))) {
695 em28xx_errdev("resubmit of urb failed (error=%i)\n", status
);
696 dev
->state
|= DEV_MISCONFIGURED
;
698 wake_up_interruptible(&dev
->wait_frame
);
703 * em28xx_uninit_isoc()
704 * deallocates the buffers and urbs allocated during em28xx_init_iosc()
706 void em28xx_uninit_isoc(struct em28xx
*dev
)
710 for (i
= 0; i
< EM28XX_NUM_BUFS
; i
++) {
712 usb_kill_urb(dev
->urb
[i
]);
713 if (dev
->transfer_buffer
[i
]){
714 usb_buffer_free(dev
->udev
,(EM28XX_NUM_PACKETS
*dev
->max_pkt_size
),dev
->transfer_buffer
[i
],dev
->urb
[i
]->transfer_dma
);
716 usb_free_urb(dev
->urb
[i
]);
719 dev
->transfer_buffer
[i
] = NULL
;
721 em28xx_capture_start(dev
, 0);
726 * allocates transfer buffers and submits the urbs for isoc transfer
728 int em28xx_init_isoc(struct em28xx
*dev
)
730 /* change interface to 3 which allows the biggest packet sizes */
732 const int sb_size
= EM28XX_NUM_PACKETS
* dev
->max_pkt_size
;
734 /* reset streaming vars */
735 dev
->frame_current
= NULL
;
736 dev
->frame_count
= 0;
739 for (i
= 0; i
< EM28XX_NUM_BUFS
; i
++) {
742 /* allocate transfer buffer */
743 urb
= usb_alloc_urb(EM28XX_NUM_PACKETS
, GFP_KERNEL
);
745 em28xx_errdev("cannot alloc urb %i\n", i
);
746 em28xx_uninit_isoc(dev
);
749 dev
->transfer_buffer
[i
] = usb_buffer_alloc(dev
->udev
, sb_size
, GFP_KERNEL
,&urb
->transfer_dma
);
750 if (!dev
->transfer_buffer
[i
]) {
752 ("unable to allocate %i bytes for transfer buffer %i\n",
754 em28xx_uninit_isoc(dev
);
758 memset(dev
->transfer_buffer
[i
], 0, sb_size
);
759 urb
->dev
= dev
->udev
;
761 urb
->pipe
= usb_rcvisocpipe(dev
->udev
, 0x82);
762 urb
->transfer_flags
= URB_ISO_ASAP
;
764 urb
->transfer_buffer
= dev
->transfer_buffer
[i
];
765 urb
->complete
= em28xx_isocIrq
;
766 urb
->number_of_packets
= EM28XX_NUM_PACKETS
;
767 urb
->transfer_buffer_length
= sb_size
;
768 for (j
= k
= 0; j
< EM28XX_NUM_PACKETS
;
769 j
++, k
+= dev
->max_pkt_size
) {
770 urb
->iso_frame_desc
[j
].offset
= k
;
771 urb
->iso_frame_desc
[j
].length
=
778 for (i
= 0; i
< EM28XX_NUM_BUFS
; i
++) {
779 errCode
= usb_submit_urb(dev
->urb
[i
], GFP_KERNEL
);
781 em28xx_errdev("submit of urb %i failed (error=%i)\n", i
,
783 em28xx_uninit_isoc(dev
);
791 int em28xx_set_alternate(struct em28xx
*dev
)
793 int errCode
, prev_alt
= dev
->alt
;
797 for(i
=0;i
< dev
->num_alt
; i
++)
798 if(dev
->alt_max_pkt_size
[i
]>dev
->alt_max_pkt_size
[dev
->alt
])
802 if (dev
->alt
!= prev_alt
) {
803 dev
->max_pkt_size
= dev
->alt_max_pkt_size
[dev
->alt
];
804 em28xx_coredbg("setting alternate %d with wMaxPacketSize=%u\n", dev
->alt
,
806 errCode
= usb_set_interface(dev
->udev
, 0, dev
->alt
);
808 em28xx_errdev ("cannot change alternate number to %d (error=%i)\n",