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", 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" : "%02x\n", val
);
188 int em28xx_read_reg(struct em28xx
*dev
, u16 reg
)
190 return em28xx_read_reg_req(dev
, USB_REQ_GET_STATUS
, reg
);
194 * em28xx_write_regs_req()
195 * sends data to the usb device, specifying bRequest
197 int em28xx_write_regs_req(struct em28xx
*dev
, u8 req
, u16 reg
, char *buf
,
202 /*usb_control_msg seems to expect a kmalloced buffer */
205 if (dev
->state
& DEV_DISCONNECTED
)
208 bufs
= kmalloc(len
, GFP_KERNEL
);
210 em28xx_regdbg("req=%02x reg=%02x:", req
, reg
);
214 for (i
= 0; i
< len
; ++i
)
215 printk (" %02x", (unsigned char)buf
[i
]);
221 memcpy(bufs
, buf
, len
);
222 ret
= usb_control_msg(dev
->udev
, usb_sndctrlpipe(dev
->udev
, 0), req
,
223 USB_DIR_OUT
| USB_TYPE_VENDOR
| USB_RECIP_DEVICE
,
224 0x0000, reg
, bufs
, len
, HZ
);
225 msleep(5); /* FIXME: magic number */
230 int em28xx_write_regs(struct em28xx
*dev
, u16 reg
, char *buf
, int len
)
232 return em28xx_write_regs_req(dev
, USB_REQ_GET_STATUS
, reg
, buf
, len
);
236 * em28xx_write_reg_bits()
237 * sets only some bits (specified by bitmask) of a register, by first reading
240 int em28xx_write_reg_bits(struct em28xx
*dev
, u16 reg
, u8 val
,
245 if ((oldval
= em28xx_read_reg(dev
, reg
)) < 0)
247 newval
= (((u8
) oldval
) & ~bitmask
) | (val
& bitmask
);
248 return em28xx_write_regs(dev
, reg
, &newval
, 1);
252 * em28xx_write_ac97()
253 * write a 16 bit value to the specified AC97 address (LSB first!)
255 static int em28xx_write_ac97(struct em28xx
*dev
, u8 reg
, u8
*val
)
258 u8 addr
= reg
& 0x7f;
259 if ((ret
= em28xx_write_regs(dev
, AC97LSB_REG
, val
, 2)) < 0)
261 if ((ret
= em28xx_write_regs(dev
, AC97ADDR_REG
, &addr
, 1)) < 0)
263 if ((ret
= em28xx_read_reg(dev
, AC97BUSY_REG
)) < 0)
265 else if (((u8
) ret
) & 0x01) {
266 em28xx_warn ("AC97 command still being executed: not handled properly!\n");
271 int em28xx_set_audio_source(struct em28xx
*dev
)
273 static char *enable
= "\x08\x08";
274 static char *disable
= "\x08\x88";
275 char *video
= enable
, *line
= disable
;
279 if (dev
->is_em2800
) {
281 input
= EM2800_AUDIO_SRC_LINE
;
283 input
= EM2800_AUDIO_SRC_TUNER
;
285 ret
= em28xx_write_regs(dev
, EM2800_AUDIOSRC_REG
, &input
, 1);
290 if (dev
->has_msp34xx
)
291 input
= EM28XX_AUDIO_SRC_TUNER
;
293 switch (dev
->ctl_ainput
) {
294 case EM28XX_AMUX_VIDEO
:
295 input
= EM28XX_AUDIO_SRC_TUNER
;
298 case EM28XX_AMUX_LINE_IN
:
299 input
= EM28XX_AUDIO_SRC_LINE
;
302 case EM28XX_AMUX_AC97_VIDEO
:
303 input
= EM28XX_AUDIO_SRC_LINE
;
305 case EM28XX_AMUX_AC97_LINE_IN
:
306 input
= EM28XX_AUDIO_SRC_LINE
;
313 ret
= em28xx_write_reg_bits(dev
, AUDIOSRC_REG
, input
, 0xc0);
320 /* Sets AC97 mixer registers */
322 ret
= em28xx_write_ac97(dev
, VIDEO_AC97
, video
);
326 ret
= em28xx_write_ac97(dev
, LINE_IN_AC97
, line
);
331 int em28xx_audio_analog_set(struct em28xx
*dev
)
334 char s
[2] = { 0x00, 0x00 };
337 s
[0] |= 0x1f - dev
->volume
;
338 s
[1] |= 0x1f - dev
->volume
;
342 ret
= em28xx_write_ac97(dev
, MASTER_AC97
, s
);
346 if (dev
->has_12mhz_i2s
)
352 ret
= em28xx_write_reg_bits(dev
, XCLK_REG
, xclk
, 0xa7);
357 /* Selects the proper audio input */
358 ret
= em28xx_set_audio_source(dev
);
362 EXPORT_SYMBOL_GPL(em28xx_audio_analog_set
);
364 int em28xx_colorlevels_set_default(struct em28xx
*dev
)
366 em28xx_write_regs(dev
, YGAIN_REG
, "\x10", 1); /* contrast */
367 em28xx_write_regs(dev
, YOFFSET_REG
, "\x00", 1); /* brightness */
368 em28xx_write_regs(dev
, UVGAIN_REG
, "\x10", 1); /* saturation */
369 em28xx_write_regs(dev
, UOFFSET_REG
, "\x00", 1);
370 em28xx_write_regs(dev
, VOFFSET_REG
, "\x00", 1);
371 em28xx_write_regs(dev
, SHARPNESS_REG
, "\x00", 1);
373 em28xx_write_regs(dev
, GAMMA_REG
, "\x20", 1);
374 em28xx_write_regs(dev
, RGAIN_REG
, "\x20", 1);
375 em28xx_write_regs(dev
, GGAIN_REG
, "\x20", 1);
376 em28xx_write_regs(dev
, BGAIN_REG
, "\x20", 1);
377 em28xx_write_regs(dev
, ROFFSET_REG
, "\x00", 1);
378 em28xx_write_regs(dev
, GOFFSET_REG
, "\x00", 1);
379 return em28xx_write_regs(dev
, BOFFSET_REG
, "\x00", 1);
382 int em28xx_capture_start(struct em28xx
*dev
, int start
)
385 /* FIXME: which is the best order? */
386 /* video registers are sampled by VREF */
387 if ((ret
= em28xx_write_reg_bits(dev
, USBSUSP_REG
, start
? 0x10 : 0x00,
390 /* enable video capture */
391 return em28xx_write_regs(dev
, VINENABLE_REG
, start
? "\x67" : "\x27", 1);
394 int em28xx_outfmt_set_yuv422(struct em28xx
*dev
)
396 em28xx_write_regs(dev
, OUTFMT_REG
, "\x34", 1);
397 em28xx_write_regs(dev
, VINMODE_REG
, "\x10", 1);
398 return em28xx_write_regs(dev
, VINCTRL_REG
, "\x11", 1);
401 static int em28xx_accumulator_set(struct em28xx
*dev
, u8 xmin
, u8 xmax
,
404 em28xx_coredbg("em28xx Scale: (%d,%d)-(%d,%d)\n", xmin
, ymin
, xmax
, ymax
);
406 em28xx_write_regs(dev
, XMIN_REG
, &xmin
, 1);
407 em28xx_write_regs(dev
, XMAX_REG
, &xmax
, 1);
408 em28xx_write_regs(dev
, YMIN_REG
, &ymin
, 1);
409 return em28xx_write_regs(dev
, YMAX_REG
, &ymax
, 1);
412 static int em28xx_capture_area_set(struct em28xx
*dev
, u8 hstart
, u8 vstart
,
413 u16 width
, u16 height
)
417 u8 overflow
= (height
>> 7 & 0x02) | (width
>> 8 & 0x01);
419 em28xx_coredbg("em28xx Area Set: (%d,%d)\n", (width
| (overflow
& 2) << 7),
420 (height
| (overflow
& 1) << 8));
422 em28xx_write_regs(dev
, HSTART_REG
, &hstart
, 1);
423 em28xx_write_regs(dev
, VSTART_REG
, &vstart
, 1);
424 em28xx_write_regs(dev
, CWIDTH_REG
, &cwidth
, 1);
425 em28xx_write_regs(dev
, CHEIGHT_REG
, &cheight
, 1);
426 return em28xx_write_regs(dev
, OFLOW_REG
, &overflow
, 1);
429 static int em28xx_scaler_set(struct em28xx
*dev
, u16 h
, u16 v
)
432 /* the em2800 scaler only supports scaling down to 50% */
434 mode
= (v
? 0x20 : 0x00) | (h
? 0x10 : 0x00);
439 em28xx_write_regs(dev
, HSCALELOW_REG
, (char *)buf
, 2);
442 em28xx_write_regs(dev
, VSCALELOW_REG
, (char *)buf
, 2);
443 /* it seems that both H and V scalers must be active to work correctly */
444 mode
= (h
|| v
)? 0x30: 0x00;
446 return em28xx_write_reg_bits(dev
, COMPR_REG
, mode
, 0x30);
449 /* FIXME: this only function read values from dev */
450 int em28xx_resolution_set(struct em28xx
*dev
)
453 width
= norm_maxw(dev
);
454 height
= norm_maxh(dev
) >> 1;
456 em28xx_outfmt_set_yuv422(dev
);
457 em28xx_accumulator_set(dev
, 1, (width
- 4) >> 2, 1, (height
- 4) >> 2);
458 em28xx_capture_area_set(dev
, 0, 0, width
>> 2, height
>> 2);
459 return em28xx_scaler_set(dev
, dev
->hscale
, dev
->vscale
);
463 /******************* isoc transfer handling ****************************/
465 #ifdef ENABLE_DEBUG_ISOC_FRAMES
466 static void em28xx_isoc_dump(struct urb
*urb
)
472 printk(KERN_DEBUG
"isocIrq: sf=%d np=%d ec=%x\n",
473 urb
->start_frame
, urb
->number_of_packets
,
475 for (i
= 0; i
< urb
->number_of_packets
; i
++) {
477 urb
->transfer_buffer
+
478 urb
->iso_frame_desc
[i
].offset
;
479 int alen
= urb
->iso_frame_desc
[i
].actual_length
;
481 if (buf
[0] == 0x88) {
484 } else if (buf
[0] == 0x22) {
486 "= l=%d nt=%d bpp=%d\n",
487 len
- 4 * ntrans
, ntrans
,
488 ntrans
== 0 ? 0 : len
/ ntrans
);
492 printk(KERN_DEBUG
"!\n");
494 printk(KERN_DEBUG
" n=%d s=%d al=%d %x\n", i
,
495 urb
->iso_frame_desc
[i
].status
,
496 urb
->iso_frame_desc
[i
].actual_length
,
498 *((unsigned char *)(urb
->transfer_buffer
+
499 urb
->iso_frame_desc
[i
].
505 static inline int em28xx_isoc_video(struct em28xx
*dev
,struct em28xx_frame_t
**f
,
506 unsigned long *lock_flags
, unsigned char buf
)
509 if ((*f
)->state
== F_GRABBING
) {
510 /*previous frame is incomplete */
511 if ((*f
)->fieldbytesused
< dev
->field_size
) {
512 (*f
)->state
= F_ERROR
;
513 em28xx_isocdbg ("dropping incomplete bottom field (%i missing bytes)",
514 dev
->field_size
-(*f
)->fieldbytesused
);
516 (*f
)->state
= F_DONE
;
517 (*f
)->buf
.bytesused
= dev
->frame_size
;
520 if ((*f
)->state
== F_DONE
|| (*f
)->state
== F_ERROR
) {
521 /* move current frame to outqueue and get next free buffer from inqueue */
522 spin_lock_irqsave(&dev
-> queue_lock
, *lock_flags
);
523 list_move_tail(&(*f
)->frame
, &dev
->outqueue
);
524 if (!list_empty(&dev
->inqueue
))
525 (*f
) = list_entry(dev
-> inqueue
.next
,
526 struct em28xx_frame_t
,frame
);
529 spin_unlock_irqrestore(&dev
->queue_lock
,*lock_flags
);
532 em28xx_isocdbg ("new frame but no buffer is free");
535 do_gettimeofday(&(*f
)->buf
.timestamp
);
536 (*f
)->buf
.sequence
= ++dev
->frame_count
;
537 (*f
)->buf
.field
= V4L2_FIELD_INTERLACED
;
538 (*f
)->state
= F_GRABBING
;
539 (*f
)->buf
.bytesused
= 0;
541 (*f
)->fieldbytesused
= 0;
543 /* acquiring bottom field */
544 if ((*f
)->state
== F_GRABBING
) {
545 if (!(*f
)->top_field
) {
546 (*f
)->state
= F_ERROR
;
547 em28xx_isocdbg ("unexpected begin of bottom field; discarding it");
548 } else if ((*f
)-> fieldbytesused
< dev
->field_size
- 172) {
549 (*f
)->state
= F_ERROR
;
550 em28xx_isocdbg ("dropping incomplete top field (%i missing bytes)",
551 dev
->field_size
-(*f
)->fieldbytesused
);
554 (*f
)->fieldbytesused
= 0;
561 static inline void em28xx_isoc_video_copy(struct em28xx
*dev
,
562 struct em28xx_frame_t
**f
, unsigned char *buf
, int len
)
564 void *fieldstart
, *startwrite
, *startread
;
565 int linesdone
, currlinedone
, offset
, lencopy
,remain
;
567 if(dev
->frame_size
!= (*f
)->buf
.length
){
568 em28xx_err("frame_size %i and buf.length %i are different!!!\n",dev
->frame_size
,(*f
)->buf
.length
);
572 if ((*f
)->fieldbytesused
+ len
> dev
->field_size
)
573 len
=dev
->field_size
- (*f
)->fieldbytesused
;
575 if (buf
[0] != 0x88 && buf
[0] != 0x22) {
576 em28xx_isocdbg("frame is not complete\n");
585 fieldstart
= (*f
)->bufmem
;
587 fieldstart
= (*f
)->bufmem
+ dev
->bytesperline
;
589 linesdone
= (*f
)->fieldbytesused
/ dev
->bytesperline
;
590 currlinedone
= (*f
)->fieldbytesused
% dev
->bytesperline
;
591 offset
= linesdone
* dev
->bytesperline
* 2 + currlinedone
;
592 startwrite
= fieldstart
+ offset
;
593 lencopy
= dev
->bytesperline
- currlinedone
;
594 lencopy
= lencopy
> remain
? remain
: lencopy
;
596 memcpy(startwrite
, startread
, lencopy
);
600 startwrite
+= lencopy
+ dev
->bytesperline
;
601 startread
+= lencopy
;
602 if (dev
->bytesperline
> remain
)
605 lencopy
= dev
->bytesperline
;
607 memcpy(startwrite
, startread
, lencopy
);
611 (*f
)->fieldbytesused
+= len
;
616 * handles the incoming isoc urbs and fills the frames from our inqueue
618 static void em28xx_isocIrq(struct urb
*urb
)
620 struct em28xx
*dev
= urb
->context
;
622 struct em28xx_frame_t
**f
;
623 unsigned long lock_flags
;
627 #ifdef ENABLE_DEBUG_ISOC_FRAMES
629 em28xx_isoc_dump(urb
);
632 if (urb
->status
== -ENOENT
)
635 f
= &dev
->frame_current
;
637 if (dev
->stream
== STREAM_INTERRUPT
) {
638 dev
->stream
= STREAM_OFF
;
640 (*f
)->state
= F_QUEUED
;
641 em28xx_isocdbg("stream interrupted");
642 wake_up_interruptible(&dev
->wait_stream
);
645 if ((dev
->state
& DEV_DISCONNECTED
) || (dev
->state
& DEV_MISCONFIGURED
))
648 if (dev
->stream
== STREAM_ON
&& !list_empty(&dev
->inqueue
)) {
650 (*f
) = list_entry(dev
->inqueue
.next
,
651 struct em28xx_frame_t
, frame
);
653 for (i
= 0; i
< urb
->number_of_packets
; i
++) {
654 unsigned char *buf
= urb
->transfer_buffer
+
655 urb
->iso_frame_desc
[i
].offset
;
656 int len
= urb
->iso_frame_desc
[i
].actual_length
- 4;
658 if (urb
->iso_frame_desc
[i
].status
) {
659 em28xx_isocdbg("data error: [%d] len=%d, status=%d", i
,
660 urb
->iso_frame_desc
[i
].actual_length
,
661 urb
->iso_frame_desc
[i
].status
);
662 if (urb
->iso_frame_desc
[i
].status
!= -EPROTO
)
665 if (urb
->iso_frame_desc
[i
].actual_length
<= 0) {
666 em28xx_isocdbg("packet %d is empty",i
);
669 if (urb
->iso_frame_desc
[i
].actual_length
>
671 em28xx_isocdbg("packet bigger than packet size");
675 if (buf
[0] == 0x22 && buf
[1] == 0x5a) {
676 em28xx_isocdbg("Video frame, length=%i!",len
);
678 if (em28xx_isoc_video(dev
,f
,&lock_flags
,buf
[2]))
680 } else if (buf
[0]==0x33 && buf
[1]==0x95 && buf
[2]==0x00) {
681 em28xx_isocdbg("VBI HEADER!!!");
685 if ((*f
)->state
== F_GRABBING
) {
686 em28xx_isoc_video_copy(dev
,f
,buf
, len
);
691 for (i
= 0; i
< urb
->number_of_packets
; i
++) {
692 urb
->iso_frame_desc
[i
].status
= 0;
693 urb
->iso_frame_desc
[i
].actual_length
= 0;
697 if ((status
= usb_submit_urb(urb
, GFP_ATOMIC
))) {
698 em28xx_errdev("resubmit of urb failed (error=%i)\n", status
);
699 dev
->state
|= DEV_MISCONFIGURED
;
701 wake_up_interruptible(&dev
->wait_frame
);
706 * em28xx_uninit_isoc()
707 * deallocates the buffers and urbs allocated during em28xx_init_iosc()
709 void em28xx_uninit_isoc(struct em28xx
*dev
)
713 for (i
= 0; i
< EM28XX_NUM_BUFS
; i
++) {
715 usb_kill_urb(dev
->urb
[i
]);
716 if (dev
->transfer_buffer
[i
]){
717 usb_buffer_free(dev
->udev
,(EM28XX_NUM_PACKETS
*dev
->max_pkt_size
),dev
->transfer_buffer
[i
],dev
->urb
[i
]->transfer_dma
);
719 usb_free_urb(dev
->urb
[i
]);
722 dev
->transfer_buffer
[i
] = NULL
;
724 em28xx_capture_start(dev
, 0);
729 * allocates transfer buffers and submits the urbs for isoc transfer
731 int em28xx_init_isoc(struct em28xx
*dev
)
733 /* change interface to 3 which allows the biggest packet sizes */
735 const int sb_size
= EM28XX_NUM_PACKETS
* dev
->max_pkt_size
;
737 /* reset streaming vars */
738 dev
->frame_current
= NULL
;
739 dev
->frame_count
= 0;
742 for (i
= 0; i
< EM28XX_NUM_BUFS
; i
++) {
745 /* allocate transfer buffer */
746 urb
= usb_alloc_urb(EM28XX_NUM_PACKETS
, GFP_KERNEL
);
748 em28xx_errdev("cannot alloc urb %i\n", i
);
749 em28xx_uninit_isoc(dev
);
752 dev
->transfer_buffer
[i
] = usb_buffer_alloc(dev
->udev
, sb_size
, GFP_KERNEL
,&urb
->transfer_dma
);
753 if (!dev
->transfer_buffer
[i
]) {
755 ("unable to allocate %i bytes for transfer buffer %i\n",
757 em28xx_uninit_isoc(dev
);
761 memset(dev
->transfer_buffer
[i
], 0, sb_size
);
762 urb
->dev
= dev
->udev
;
764 urb
->pipe
= usb_rcvisocpipe(dev
->udev
, 0x82);
765 urb
->transfer_flags
= URB_ISO_ASAP
;
767 urb
->transfer_buffer
= dev
->transfer_buffer
[i
];
768 urb
->complete
= em28xx_isocIrq
;
769 urb
->number_of_packets
= EM28XX_NUM_PACKETS
;
770 urb
->transfer_buffer_length
= sb_size
;
771 for (j
= k
= 0; j
< EM28XX_NUM_PACKETS
;
772 j
++, k
+= dev
->max_pkt_size
) {
773 urb
->iso_frame_desc
[j
].offset
= k
;
774 urb
->iso_frame_desc
[j
].length
=
781 for (i
= 0; i
< EM28XX_NUM_BUFS
; i
++) {
782 errCode
= usb_submit_urb(dev
->urb
[i
], GFP_KERNEL
);
784 em28xx_errdev("submit of urb %i failed (error=%i)\n", i
,
786 em28xx_uninit_isoc(dev
);
794 int em28xx_set_alternate(struct em28xx
*dev
)
796 int errCode
, prev_alt
= dev
->alt
;
800 for(i
=0;i
< dev
->num_alt
; i
++)
801 if(dev
->alt_max_pkt_size
[i
]>dev
->alt_max_pkt_size
[dev
->alt
])
805 if (dev
->alt
!= prev_alt
) {
806 dev
->max_pkt_size
= dev
->alt_max_pkt_size
[dev
->alt
];
807 em28xx_coredbg("setting alternate %d with wMaxPacketSize=%u\n", dev
->alt
,
809 errCode
= usb_set_interface(dev
->udev
, 0, dev
->alt
);
811 em28xx_errdev ("cannot change alternate number to %d (error=%i)\n",