2 * usbvision-core.c - driver for NT100x USB video capture devices
5 * Copyright (c) 1999-2005 Joerg Heckenbach <joerg@heckenbach-aw.de>
6 * Dwaine Garden <dwainegarden@rogers.com>
8 * This module is part of usbvision driver project.
9 * Updates to driver completed by Dwaine P. Garden
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; either version 2 of the License, or
14 * (at your option) any later version.
16 * This program is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 * GNU General Public License for more details.
21 * You should have received a copy of the GNU General Public License
22 * along with this program; if not, write to the Free Software
23 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
26 #include <linux/kernel.h>
27 #include <linux/list.h>
28 #include <linux/timer.h>
29 #include <linux/slab.h>
31 #include <linux/utsname.h>
32 #include <linux/highmem.h>
33 #include <linux/vmalloc.h>
34 #include <linux/module.h>
35 #include <linux/init.h>
36 #include <linux/spinlock.h>
38 #include <linux/videodev2.h>
39 #include <linux/video_decoder.h>
40 #include <linux/i2c.h>
42 #include <media/saa7115.h>
43 #include <media/v4l2-common.h>
44 #include <media/tuner.h>
46 #include <linux/workqueue.h>
49 #include <linux/kmod.h>
52 #include "usbvision.h"
54 static unsigned int core_debug
;
55 module_param(core_debug
,int,0644);
56 MODULE_PARM_DESC(core_debug
,"enable debug messages [core]");
58 static unsigned int force_testpattern
;
59 module_param(force_testpattern
,int,0644);
60 MODULE_PARM_DESC(force_testpattern
,"enable test pattern display [core]");
62 static int adjustCompression
= 1; /* Set the compression to be adaptive */
63 module_param(adjustCompression
, int, 0444);
64 MODULE_PARM_DESC(adjustCompression
, " Set the ADPCM compression for the device. Default: 1 (On)");
66 /* To help people with Black and White output with using s-video input.
67 * Some cables and input device are wired differently. */
68 static int SwitchSVideoInput
;
69 module_param(SwitchSVideoInput
, int, 0444);
70 MODULE_PARM_DESC(SwitchSVideoInput
, " Set the S-Video input. Some cables and input device are wired differently. Default: 0 (Off)");
72 static unsigned int adjust_X_Offset
= -1;
73 module_param(adjust_X_Offset
, int, 0644);
74 MODULE_PARM_DESC(adjust_X_Offset
, "adjust X offset display [core]");
76 static unsigned int adjust_Y_Offset
= -1;
77 module_param(adjust_Y_Offset
, int, 0644);
78 MODULE_PARM_DESC(adjust_Y_Offset
, "adjust Y offset display [core]");
81 #define ENABLE_HEXDUMP 0 /* Enable if you need it */
84 #ifdef USBVISION_DEBUG
85 #define PDEBUG(level, fmt, args...) { \
86 if (core_debug & (level)) \
87 printk(KERN_INFO KBUILD_MODNAME ":[%s:%d] " fmt, \
88 __func__, __LINE__ , ## args); \
91 #define PDEBUG(level, fmt, args...) do {} while(0)
94 #define DBG_HEADER 1<<0
97 #define DBG_PARSE 1<<3
98 #define DBG_SCRATCH 1<<4
101 static const int max_imgwidth
= MAX_FRAME_WIDTH
;
102 static const int max_imgheight
= MAX_FRAME_HEIGHT
;
103 static const int min_imgwidth
= MIN_FRAME_WIDTH
;
104 static const int min_imgheight
= MIN_FRAME_HEIGHT
;
106 /* The value of 'scratch_buf_size' affects quality of the picture
107 * in many ways. Shorter buffers may cause loss of data when client
108 * is too slow. Larger buffers are memory-consuming and take longer
109 * to work with. This setting can be adjusted, but the default value
110 * should be OK for most desktop users.
112 #define DEFAULT_SCRATCH_BUF_SIZE (0x20000) // 128kB memory scratch buffer
113 static const int scratch_buf_size
= DEFAULT_SCRATCH_BUF_SIZE
;
115 // Function prototypes
116 static int usbvision_request_intra (struct usb_usbvision
*usbvision
);
117 static int usbvision_unrequest_intra (struct usb_usbvision
*usbvision
);
118 static int usbvision_adjust_compression (struct usb_usbvision
*usbvision
);
119 static int usbvision_measure_bandwidth (struct usb_usbvision
*usbvision
);
121 /*******************************/
122 /* Memory management functions */
123 /*******************************/
126 * Here we want the physical address of the memory.
127 * This is used when initializing the contents of the area.
130 static void *usbvision_rvmalloc(unsigned long size
)
135 size
= PAGE_ALIGN(size
);
136 mem
= vmalloc_32(size
);
140 memset(mem
, 0, size
); /* Clear the ram out, no junk to the user */
141 adr
= (unsigned long) mem
;
143 SetPageReserved(vmalloc_to_page((void *)adr
));
151 static void usbvision_rvfree(void *mem
, unsigned long size
)
158 size
= PAGE_ALIGN(size
);
160 adr
= (unsigned long) mem
;
161 while ((long) size
> 0) {
162 ClearPageReserved(vmalloc_to_page((void *)adr
));
172 static void usbvision_hexdump(const unsigned char *data
, int len
)
177 for (i
= k
= 0; len
> 0; i
++, len
--) {
178 if (i
> 0 && (i
% 16 == 0)) {
182 k
+= sprintf(&tmp
[k
], "%02x ", data
[i
]);
189 /********************************
190 * scratch ring buffer handling
191 ********************************/
192 static int scratch_len(struct usb_usbvision
*usbvision
) /*This returns the amount of data actually in the buffer */
194 int len
= usbvision
->scratch_write_ptr
- usbvision
->scratch_read_ptr
;
196 len
+= scratch_buf_size
;
198 PDEBUG(DBG_SCRATCH
, "scratch_len() = %d\n", len
);
204 /* This returns the free space left in the buffer */
205 static int scratch_free(struct usb_usbvision
*usbvision
)
207 int free
= usbvision
->scratch_read_ptr
- usbvision
->scratch_write_ptr
;
209 free
+= scratch_buf_size
;
212 free
-= 1; /* at least one byte in the buffer must */
213 /* left blank, otherwise there is no chance to differ between full and empty */
215 PDEBUG(DBG_SCRATCH
, "return %d\n", free
);
221 /* This puts data into the buffer */
222 static int scratch_put(struct usb_usbvision
*usbvision
, unsigned char *data
,
227 if (usbvision
->scratch_write_ptr
+ len
< scratch_buf_size
) {
228 memcpy(usbvision
->scratch
+ usbvision
->scratch_write_ptr
, data
, len
);
229 usbvision
->scratch_write_ptr
+= len
;
232 len_part
= scratch_buf_size
- usbvision
->scratch_write_ptr
;
233 memcpy(usbvision
->scratch
+ usbvision
->scratch_write_ptr
, data
, len_part
);
234 if (len
== len_part
) {
235 usbvision
->scratch_write_ptr
= 0; /* just set write_ptr to zero */
238 memcpy(usbvision
->scratch
, data
+ len_part
, len
- len_part
);
239 usbvision
->scratch_write_ptr
= len
- len_part
;
243 PDEBUG(DBG_SCRATCH
, "len=%d, new write_ptr=%d\n", len
, usbvision
->scratch_write_ptr
);
248 /* This marks the write_ptr as position of new frame header */
249 static void scratch_mark_header(struct usb_usbvision
*usbvision
)
251 PDEBUG(DBG_SCRATCH
, "header at write_ptr=%d\n", usbvision
->scratch_headermarker_write_ptr
);
253 usbvision
->scratch_headermarker
[usbvision
->scratch_headermarker_write_ptr
] =
254 usbvision
->scratch_write_ptr
;
255 usbvision
->scratch_headermarker_write_ptr
+= 1;
256 usbvision
->scratch_headermarker_write_ptr
%= USBVISION_NUM_HEADERMARKER
;
259 /* This gets data from the buffer at the given "ptr" position */
260 static int scratch_get_extra(struct usb_usbvision
*usbvision
,
261 unsigned char *data
, int *ptr
, int len
)
264 if (*ptr
+ len
< scratch_buf_size
) {
265 memcpy(data
, usbvision
->scratch
+ *ptr
, len
);
269 len_part
= scratch_buf_size
- *ptr
;
270 memcpy(data
, usbvision
->scratch
+ *ptr
, len_part
);
271 if (len
== len_part
) {
272 *ptr
= 0; /* just set the y_ptr to zero */
275 memcpy(data
+ len_part
, usbvision
->scratch
, len
- len_part
);
276 *ptr
= len
- len_part
;
280 PDEBUG(DBG_SCRATCH
, "len=%d, new ptr=%d\n", len
, *ptr
);
286 /* This sets the scratch extra read pointer */
287 static void scratch_set_extra_ptr(struct usb_usbvision
*usbvision
, int *ptr
,
290 *ptr
= (usbvision
->scratch_read_ptr
+ len
)%scratch_buf_size
;
292 PDEBUG(DBG_SCRATCH
, "ptr=%d\n", *ptr
);
296 /*This increments the scratch extra read pointer */
297 static void scratch_inc_extra_ptr(int *ptr
, int len
)
299 *ptr
= (*ptr
+ len
) % scratch_buf_size
;
301 PDEBUG(DBG_SCRATCH
, "ptr=%d\n", *ptr
);
305 /* This gets data from the buffer */
306 static int scratch_get(struct usb_usbvision
*usbvision
, unsigned char *data
,
310 if (usbvision
->scratch_read_ptr
+ len
< scratch_buf_size
) {
311 memcpy(data
, usbvision
->scratch
+ usbvision
->scratch_read_ptr
, len
);
312 usbvision
->scratch_read_ptr
+= len
;
315 len_part
= scratch_buf_size
- usbvision
->scratch_read_ptr
;
316 memcpy(data
, usbvision
->scratch
+ usbvision
->scratch_read_ptr
, len_part
);
317 if (len
== len_part
) {
318 usbvision
->scratch_read_ptr
= 0; /* just set the read_ptr to zero */
321 memcpy(data
+ len_part
, usbvision
->scratch
, len
- len_part
);
322 usbvision
->scratch_read_ptr
= len
- len_part
;
326 PDEBUG(DBG_SCRATCH
, "len=%d, new read_ptr=%d\n", len
, usbvision
->scratch_read_ptr
);
332 /* This sets read pointer to next header and returns it */
333 static int scratch_get_header(struct usb_usbvision
*usbvision
,
334 struct usbvision_frame_header
*header
)
338 PDEBUG(DBG_SCRATCH
, "from read_ptr=%d", usbvision
->scratch_headermarker_read_ptr
);
340 while (usbvision
->scratch_headermarker_write_ptr
-
341 usbvision
->scratch_headermarker_read_ptr
!= 0) {
342 usbvision
->scratch_read_ptr
=
343 usbvision
->scratch_headermarker
[usbvision
->scratch_headermarker_read_ptr
];
344 usbvision
->scratch_headermarker_read_ptr
+= 1;
345 usbvision
->scratch_headermarker_read_ptr
%= USBVISION_NUM_HEADERMARKER
;
346 scratch_get(usbvision
, (unsigned char *)header
, USBVISION_HEADER_LENGTH
);
347 if ((header
->magic_1
== USBVISION_MAGIC_1
)
348 && (header
->magic_2
== USBVISION_MAGIC_2
)
349 && (header
->headerLength
== USBVISION_HEADER_LENGTH
)) {
350 errCode
= USBVISION_HEADER_LENGTH
;
351 header
->frameWidth
= header
->frameWidthLo
+ (header
->frameWidthHi
<< 8);
352 header
->frameHeight
= header
->frameHeightLo
+ (header
->frameHeightHi
<< 8);
361 /*This removes len bytes of old data from the buffer */
362 static void scratch_rm_old(struct usb_usbvision
*usbvision
, int len
)
365 usbvision
->scratch_read_ptr
+= len
;
366 usbvision
->scratch_read_ptr
%= scratch_buf_size
;
367 PDEBUG(DBG_SCRATCH
, "read_ptr is now %d\n", usbvision
->scratch_read_ptr
);
371 /*This resets the buffer - kills all data in it too */
372 static void scratch_reset(struct usb_usbvision
*usbvision
)
374 PDEBUG(DBG_SCRATCH
, "\n");
376 usbvision
->scratch_read_ptr
= 0;
377 usbvision
->scratch_write_ptr
= 0;
378 usbvision
->scratch_headermarker_read_ptr
= 0;
379 usbvision
->scratch_headermarker_write_ptr
= 0;
380 usbvision
->isocstate
= IsocState_NoFrame
;
383 int usbvision_scratch_alloc(struct usb_usbvision
*usbvision
)
385 usbvision
->scratch
= vmalloc_32(scratch_buf_size
);
386 scratch_reset(usbvision
);
387 if(usbvision
->scratch
== NULL
) {
388 err("%s: unable to allocate %d bytes for scratch",
389 __func__
, scratch_buf_size
);
395 void usbvision_scratch_free(struct usb_usbvision
*usbvision
)
397 if (usbvision
->scratch
!= NULL
) {
398 vfree(usbvision
->scratch
);
399 usbvision
->scratch
= NULL
;
404 * usbvision_testpattern()
406 * Procedure forms a test pattern (yellow grid on blue background).
409 * fullframe: if TRUE then entire frame is filled, otherwise the procedure
410 * continues from the current scanline.
411 * pmode 0: fill the frame with solid blue color (like on VCR or TV)
412 * 1: Draw a colored grid
415 static void usbvision_testpattern(struct usb_usbvision
*usbvision
,
416 int fullframe
, int pmode
)
418 static const char proc
[] = "usbvision_testpattern";
419 struct usbvision_frame
*frame
;
425 if (usbvision
== NULL
) {
426 printk(KERN_ERR
"%s: usbvision == NULL\n", proc
);
429 if (usbvision
->curFrame
== NULL
) {
430 printk(KERN_ERR
"%s: usbvision->curFrame is NULL.\n", proc
);
434 /* Grab the current frame */
435 frame
= usbvision
->curFrame
;
437 /* Optionally start at the beginning */
440 frame
->scanlength
= 0;
443 /* Form every scan line */
444 for (; frame
->curline
< frame
->frmheight
; frame
->curline
++) {
447 f
= frame
->data
+ (usbvision
->curwidth
* 3 * frame
->curline
);
448 for (i
= 0; i
< usbvision
->curwidth
; i
++) {
449 unsigned char cb
= 0x80;
450 unsigned char cg
= 0;
451 unsigned char cr
= 0;
454 if (frame
->curline
% 32 == 0)
455 cb
= 0, cg
= cr
= 0xFF;
456 else if (i
% 32 == 0) {
457 if (frame
->curline
% 32 == 1)
459 cb
= 0, cg
= cr
= 0xFF;
466 num_pass
* 2) & 0xFF;
469 num_pass
* 3) & 0xFF;
472 /* Just the blue screen */
482 frame
->grabstate
= FrameState_Done
;
483 frame
->scanlength
+= scan_length
;
489 * usbvision_decompress_alloc()
491 * allocates intermediate buffer for decompression
493 int usbvision_decompress_alloc(struct usb_usbvision
*usbvision
)
495 int IFB_size
= MAX_FRAME_WIDTH
* MAX_FRAME_HEIGHT
* 3 / 2;
496 usbvision
->IntraFrameBuffer
= vmalloc_32(IFB_size
);
497 if (usbvision
->IntraFrameBuffer
== NULL
) {
498 err("%s: unable to allocate %d for compr. frame buffer",
506 * usbvision_decompress_free()
508 * frees intermediate buffer for decompression
510 void usbvision_decompress_free(struct usb_usbvision
*usbvision
)
512 if (usbvision
->IntraFrameBuffer
!= NULL
) {
513 vfree(usbvision
->IntraFrameBuffer
);
514 usbvision
->IntraFrameBuffer
= NULL
;
518 /************************************************************
519 * Here comes the data parsing stuff that is run as interrupt
520 ************************************************************/
522 * usbvision_find_header()
524 * Locate one of supported header markers in the scratch buffer.
526 static enum ParseState
usbvision_find_header(struct usb_usbvision
*usbvision
)
528 struct usbvision_frame
*frame
;
531 frame
= usbvision
->curFrame
;
533 while (scratch_get_header(usbvision
, &frame
->isocHeader
) == USBVISION_HEADER_LENGTH
) {
534 // found header in scratch
535 PDEBUG(DBG_HEADER
, "found header: 0x%02x%02x %d %d %d %d %#x 0x%02x %u %u",
536 frame
->isocHeader
.magic_2
,
537 frame
->isocHeader
.magic_1
,
538 frame
->isocHeader
.headerLength
,
539 frame
->isocHeader
.frameNum
,
540 frame
->isocHeader
.framePhase
,
541 frame
->isocHeader
.frameLatency
,
542 frame
->isocHeader
.dataFormat
,
543 frame
->isocHeader
.formatParam
,
544 frame
->isocHeader
.frameWidth
,
545 frame
->isocHeader
.frameHeight
);
547 if (usbvision
->requestIntra
) {
548 if (frame
->isocHeader
.formatParam
& 0x80) {
550 usbvision
->lastIsocFrameNum
= -1; // do not check for lost frames this time
551 usbvision_unrequest_intra(usbvision
);
562 frame
->frmwidth
= frame
->isocHeader
.frameWidth
* usbvision
->stretch_width
;
563 frame
->frmheight
= frame
->isocHeader
.frameHeight
* usbvision
->stretch_height
;
564 frame
->v4l2_linesize
= (frame
->frmwidth
* frame
->v4l2_format
.depth
)>> 3;
566 else { // no header found
567 PDEBUG(DBG_HEADER
, "skipping scratch data, no header");
568 scratch_reset(usbvision
);
569 return ParseState_EndParse
;
573 if (frame
->isocHeader
.dataFormat
==ISOC_MODE_COMPRESS
) {
574 //check isocHeader.frameNum for lost frames
575 if (usbvision
->lastIsocFrameNum
>= 0) {
576 if (((usbvision
->lastIsocFrameNum
+ 1) % 32) != frame
->isocHeader
.frameNum
) {
577 // unexpected frame drop: need to request new intra frame
578 PDEBUG(DBG_HEADER
, "Lost frame before %d on USB", frame
->isocHeader
.frameNum
);
579 usbvision_request_intra(usbvision
);
580 return ParseState_NextFrame
;
583 usbvision
->lastIsocFrameNum
= frame
->isocHeader
.frameNum
;
585 usbvision
->header_count
++;
586 frame
->scanstate
= ScanState_Lines
;
589 if (force_testpattern
) {
590 usbvision_testpattern(usbvision
, 1, 1);
591 return ParseState_NextFrame
;
593 return ParseState_Continue
;
596 static enum ParseState
usbvision_parse_lines_422(struct usb_usbvision
*usbvision
,
599 volatile struct usbvision_frame
*frame
;
603 unsigned char yuyv
[4]={180, 128, 10, 128}; // YUV components
604 unsigned char rv
, gv
, bv
; // RGB components
605 int clipmask_index
, bytes_per_pixel
;
606 int stretch_bytes
, clipmask_add
;
608 frame
= usbvision
->curFrame
;
609 f
= frame
->data
+ (frame
->v4l2_linesize
* frame
->curline
);
611 /* Make sure there's enough data for the entire line */
612 len
= (frame
->isocHeader
.frameWidth
* 2)+5;
613 if (scratch_len(usbvision
) < len
) {
614 PDEBUG(DBG_PARSE
, "out of data in line %d, need %u.\n", frame
->curline
, len
);
615 return ParseState_Out
;
618 if ((frame
->curline
+ 1) >= frame
->frmheight
) {
619 return ParseState_NextFrame
;
622 bytes_per_pixel
= frame
->v4l2_format
.bytes_per_pixel
;
623 stretch_bytes
= (usbvision
->stretch_width
- 1) * bytes_per_pixel
;
624 clipmask_index
= frame
->curline
* MAX_FRAME_WIDTH
;
625 clipmask_add
= usbvision
->stretch_width
;
627 for (i
= 0; i
< frame
->frmwidth
; i
+=(2 * usbvision
->stretch_width
)) {
629 scratch_get(usbvision
, &yuyv
[0], 4);
631 if (frame
->v4l2_format
.format
== V4L2_PIX_FMT_YUYV
) {
637 YUV_TO_RGB_BY_THE_BOOK(yuyv
[0], yuyv
[1], yuyv
[3], rv
, gv
, bv
);
638 switch (frame
->v4l2_format
.format
) {
639 case V4L2_PIX_FMT_RGB565
:
642 *f
++ = (0x07 & (gv
>> 3)) |
645 case V4L2_PIX_FMT_RGB24
:
650 case V4L2_PIX_FMT_RGB32
:
656 case V4L2_PIX_FMT_RGB555
:
659 *f
++ = (0x03 & (gv
>> 3)) |
664 clipmask_index
+= clipmask_add
;
667 if (frame
->v4l2_format
.format
== V4L2_PIX_FMT_YUYV
) {
673 YUV_TO_RGB_BY_THE_BOOK(yuyv
[2], yuyv
[1], yuyv
[3], rv
, gv
, bv
);
674 switch (frame
->v4l2_format
.format
) {
675 case V4L2_PIX_FMT_RGB565
:
678 *f
++ = (0x07 & (gv
>> 3)) |
681 case V4L2_PIX_FMT_RGB24
:
686 case V4L2_PIX_FMT_RGB32
:
692 case V4L2_PIX_FMT_RGB555
:
695 *f
++ = (0x03 & (gv
>> 3)) |
700 clipmask_index
+= clipmask_add
;
704 frame
->curline
+= usbvision
->stretch_height
;
705 *pcopylen
+= frame
->v4l2_linesize
* usbvision
->stretch_height
;
707 if (frame
->curline
>= frame
->frmheight
) {
708 return ParseState_NextFrame
;
711 return ParseState_Continue
;
715 /* The decompression routine */
716 static int usbvision_decompress(struct usb_usbvision
*usbvision
,unsigned char *Compressed
,
717 unsigned char *Decompressed
, int *StartPos
,
718 int *BlockTypeStartPos
, int Len
)
720 int RestPixel
, Idx
, MaxPos
, Pos
, ExtraPos
, BlockLen
, BlockTypePos
, BlockTypeLen
;
721 unsigned char BlockByte
, BlockCode
, BlockType
, BlockTypeByte
, Integrator
;
725 BlockTypePos
= *BlockTypeStartPos
;
726 MaxPos
= 396; //Pos + Len;
736 for (Idx
= 0; Idx
< Len
; Idx
++) {
739 if (BlockTypeLen
==0) {
740 BlockTypeByte
= Compressed
[BlockTypePos
];
744 BlockType
= (BlockTypeByte
& 0xC0) >> 6;
747 usbvision
->ComprBlockTypes
[BlockType
]++;
750 if (BlockType
== 0) {
751 if(RestPixel
>= 24) {
754 Integrator
= Decompressed
[Idx
];
756 Idx
+= RestPixel
- 1;
760 BlockCode
= Compressed
[Pos
];
762 if (RestPixel
>= 24) {
765 BlockLen
= RestPixel
;
767 RestPixel
-= BlockLen
;
768 ExtraPos
= Pos
+ (BlockLen
/ 4);
774 if ((BlockLen
%4) == 0) {
775 BlockByte
= Compressed
[Pos
];
778 if (BlockType
== 1) { //inter Block
779 Integrator
= Decompressed
[Idx
];
781 switch (BlockByte
& 0xC0) {
783 Integrator
+= Compressed
[ExtraPos
];
787 Integrator
+= BlockCode
;
790 Integrator
-= BlockCode
;
793 Decompressed
[Idx
] = Integrator
;
798 *StartPos
= ExtraPos
;
799 *BlockTypeStartPos
= BlockTypePos
;
805 * usbvision_parse_compress()
807 * Parse compressed frame from the scratch buffer, put
808 * decoded RGB value into the current frame buffer and add the written
809 * number of bytes (RGB) to the *pcopylen.
812 static enum ParseState
usbvision_parse_compress(struct usb_usbvision
*usbvision
,
815 #define USBVISION_STRIP_MAGIC 0x5A
816 #define USBVISION_STRIP_LEN_MAX 400
817 #define USBVISION_STRIP_HEADER_LEN 3
819 struct usbvision_frame
*frame
;
820 unsigned char *f
,*u
= NULL
,*v
= NULL
;
821 unsigned char StripData
[USBVISION_STRIP_LEN_MAX
];
822 unsigned char StripHeader
[USBVISION_STRIP_HEADER_LEN
];
823 int Idx
, IdxEnd
, StripLen
, StripPtr
, StartBlockPos
, BlockPos
, BlockTypePos
;
824 int clipmask_index
, bytes_per_pixel
, rc
;
826 unsigned char rv
, gv
, bv
;
827 static unsigned char *Y
, *U
, *V
;
829 frame
= usbvision
->curFrame
;
830 imageSize
= frame
->frmwidth
* frame
->frmheight
;
831 if ( (frame
->v4l2_format
.format
== V4L2_PIX_FMT_YUV422P
) ||
832 (frame
->v4l2_format
.format
== V4L2_PIX_FMT_YVU420
) ) { // this is a planar format
833 //... v4l2_linesize not used here.
834 f
= frame
->data
+ (frame
->width
* frame
->curline
);
836 f
= frame
->data
+ (frame
->v4l2_linesize
* frame
->curline
);
838 if (frame
->v4l2_format
.format
== V4L2_PIX_FMT_YUYV
){ //initialise u and v pointers
839 // get base of u and b planes add halfoffset
843 + (frame
->frmwidth
>>1) * frame
->curline
;
844 v
= u
+ (imageSize
>>1 );
846 } else if (frame
->v4l2_format
.format
== V4L2_PIX_FMT_YVU420
){
848 v
= frame
->data
+ imageSize
+ ((frame
->curline
* (frame
->width
))>>2) ;
849 u
= v
+ (imageSize
>>2) ;
852 if (frame
->curline
== 0) {
853 usbvision_adjust_compression(usbvision
);
856 if (scratch_len(usbvision
) < USBVISION_STRIP_HEADER_LEN
) {
857 return ParseState_Out
;
860 //get strip header without changing the scratch_read_ptr
861 scratch_set_extra_ptr(usbvision
, &StripPtr
, 0);
862 scratch_get_extra(usbvision
, &StripHeader
[0], &StripPtr
,
863 USBVISION_STRIP_HEADER_LEN
);
865 if (StripHeader
[0] != USBVISION_STRIP_MAGIC
) {
867 usbvision
->stripMagicErrors
++;
868 return ParseState_NextFrame
;
871 if (frame
->curline
!= (int)StripHeader
[2]) {
872 //line number missmatch error
873 usbvision
->stripLineNumberErrors
++;
876 StripLen
= 2 * (unsigned int)StripHeader
[1];
877 if (StripLen
> USBVISION_STRIP_LEN_MAX
) {
879 // I think this never happens
880 usbvision_request_intra(usbvision
);
883 if (scratch_len(usbvision
) < StripLen
) {
884 //there is not enough data for the strip
885 return ParseState_Out
;
888 if (usbvision
->IntraFrameBuffer
) {
889 Y
= usbvision
->IntraFrameBuffer
+ frame
->frmwidth
* frame
->curline
;
890 U
= usbvision
->IntraFrameBuffer
+ imageSize
+ (frame
->frmwidth
/ 2) * (frame
->curline
/ 2);
891 V
= usbvision
->IntraFrameBuffer
+ imageSize
/ 4 * 5 + (frame
->frmwidth
/ 2) * (frame
->curline
/ 2);
894 return ParseState_NextFrame
;
897 bytes_per_pixel
= frame
->v4l2_format
.bytes_per_pixel
;
898 clipmask_index
= frame
->curline
* MAX_FRAME_WIDTH
;
900 scratch_get(usbvision
, StripData
, StripLen
);
902 IdxEnd
= frame
->frmwidth
;
903 BlockTypePos
= USBVISION_STRIP_HEADER_LEN
;
904 StartBlockPos
= BlockTypePos
+ (IdxEnd
- 1) / 96 + (IdxEnd
/ 2 - 1) / 96 + 2;
905 BlockPos
= StartBlockPos
;
907 usbvision
->BlockPos
= BlockPos
;
909 if ((rc
= usbvision_decompress(usbvision
, StripData
, Y
, &BlockPos
, &BlockTypePos
, IdxEnd
)) != IdxEnd
) {
910 //return ParseState_Continue;
912 if (StripLen
> usbvision
->maxStripLen
) {
913 usbvision
->maxStripLen
= StripLen
;
916 if (frame
->curline
%2) {
917 if ((rc
= usbvision_decompress(usbvision
, StripData
, V
, &BlockPos
, &BlockTypePos
, IdxEnd
/2)) != IdxEnd
/2) {
918 //return ParseState_Continue;
922 if ((rc
= usbvision_decompress(usbvision
, StripData
, U
, &BlockPos
, &BlockTypePos
, IdxEnd
/2)) != IdxEnd
/2) {
923 //return ParseState_Continue;
927 if (BlockPos
> usbvision
->comprBlockPos
) {
928 usbvision
->comprBlockPos
= BlockPos
;
930 if (BlockPos
> StripLen
) {
931 usbvision
->stripLenErrors
++;
934 for (Idx
= 0; Idx
< IdxEnd
; Idx
++) {
935 if(frame
->v4l2_format
.format
== V4L2_PIX_FMT_YUYV
) {
937 *f
++ = Idx
& 0x01 ? U
[Idx
/2] : V
[Idx
/2];
939 else if(frame
->v4l2_format
.format
== V4L2_PIX_FMT_YUV422P
) {
946 else if (frame
->v4l2_format
.format
== V4L2_PIX_FMT_YVU420
) {
948 if ( !(( Idx
& 0x01 ) | ( frame
->curline
& 0x01 )) ){
950 /* only need do this for 1 in 4 pixels */
951 /* intraframe buffer is YUV420 format */
959 YUV_TO_RGB_BY_THE_BOOK(Y
[Idx
], U
[Idx
/2], V
[Idx
/2], rv
, gv
, bv
);
960 switch (frame
->v4l2_format
.format
) {
961 case V4L2_PIX_FMT_GREY
:
964 case V4L2_PIX_FMT_RGB555
:
967 *f
++ = (0x03 & (gv
>> 3)) |
970 case V4L2_PIX_FMT_RGB565
:
973 *f
++ = (0x07 & (gv
>> 3)) |
976 case V4L2_PIX_FMT_RGB24
:
981 case V4L2_PIX_FMT_RGB32
:
991 /* Deal with non-integer no. of bytes for YUV420P */
992 if (frame
->v4l2_format
.format
!= V4L2_PIX_FMT_YVU420
)
993 *pcopylen
+= frame
->v4l2_linesize
;
995 *pcopylen
+= frame
->curline
& 0x01 ? frame
->v4l2_linesize
: frame
->v4l2_linesize
<< 1;
999 if (frame
->curline
>= frame
->frmheight
) {
1000 return ParseState_NextFrame
;
1003 return ParseState_Continue
;
1010 * usbvision_parse_lines_420()
1012 * Parse two lines from the scratch buffer, put
1013 * decoded RGB value into the current frame buffer and add the written
1014 * number of bytes (RGB) to the *pcopylen.
1017 static enum ParseState
usbvision_parse_lines_420(struct usb_usbvision
*usbvision
,
1020 struct usbvision_frame
*frame
;
1021 unsigned char *f_even
= NULL
, *f_odd
= NULL
;
1022 unsigned int pixel_per_line
, block
;
1023 int pixel
, block_split
;
1024 int y_ptr
, u_ptr
, v_ptr
, y_odd_offset
;
1025 const int y_block_size
= 128;
1026 const int uv_block_size
= 64;
1027 const int sub_block_size
= 32;
1028 const int y_step
[] = { 0, 0, 0, 2 }, y_step_size
= 4;
1029 const int uv_step
[]= { 0, 0, 0, 4 }, uv_step_size
= 4;
1030 unsigned char y
[2], u
, v
; /* YUV components */
1031 int y_
, u_
, v_
, vb
, uvg
, ur
;
1032 int r_
, g_
, b_
; /* RGB components */
1034 int clipmask_even_index
, clipmask_odd_index
, bytes_per_pixel
;
1035 int clipmask_add
, stretch_bytes
;
1037 frame
= usbvision
->curFrame
;
1038 f_even
= frame
->data
+ (frame
->v4l2_linesize
* frame
->curline
);
1039 f_odd
= f_even
+ frame
->v4l2_linesize
* usbvision
->stretch_height
;
1041 /* Make sure there's enough data for the entire line */
1042 /* In this mode usbvision transfer 3 bytes for every 2 pixels */
1043 /* I need two lines to decode the color */
1044 bytes_per_pixel
= frame
->v4l2_format
.bytes_per_pixel
;
1045 stretch_bytes
= (usbvision
->stretch_width
- 1) * bytes_per_pixel
;
1046 clipmask_even_index
= frame
->curline
* MAX_FRAME_WIDTH
;
1047 clipmask_odd_index
= clipmask_even_index
+ MAX_FRAME_WIDTH
;
1048 clipmask_add
= usbvision
->stretch_width
;
1049 pixel_per_line
= frame
->isocHeader
.frameWidth
;
1051 if (scratch_len(usbvision
) < (int)pixel_per_line
* 3) {
1052 //printk(KERN_DEBUG "out of data, need %d\n", len);
1053 return ParseState_Out
;
1056 if ((frame
->curline
+ 1) >= frame
->frmheight
) {
1057 return ParseState_NextFrame
;
1060 block_split
= (pixel_per_line
%y_block_size
) ? 1 : 0; //are some blocks splitted into different lines?
1062 y_odd_offset
= (pixel_per_line
/ y_block_size
) * (y_block_size
+ uv_block_size
)
1063 + block_split
* uv_block_size
;
1065 scratch_set_extra_ptr(usbvision
, &y_ptr
, y_odd_offset
);
1066 scratch_set_extra_ptr(usbvision
, &u_ptr
, y_block_size
);
1067 scratch_set_extra_ptr(usbvision
, &v_ptr
, y_odd_offset
1068 + (4 - block_split
) * sub_block_size
);
1070 for (block
= 0; block
< (pixel_per_line
/ sub_block_size
);
1074 for (pixel
= 0; pixel
< sub_block_size
; pixel
+=2) {
1075 scratch_get(usbvision
, &y
[0], 2);
1076 scratch_get_extra(usbvision
, &u
, &u_ptr
, 1);
1077 scratch_get_extra(usbvision
, &v
, &v_ptr
, 1);
1079 //I don't use the YUV_TO_RGB macro for better performance
1083 uvg
= -53281 * u_
- 25625 * v_
;
1086 if(frame
->v4l2_format
.format
== V4L2_PIX_FMT_YUYV
) {
1091 y_
= 76284 * (y
[0] - 16);
1093 b_
= (y_
+ vb
) >> 16;
1094 g_
= (y_
+ uvg
)>> 16;
1095 r_
= (y_
+ ur
) >> 16;
1097 switch (frame
->v4l2_format
.format
) {
1098 case V4L2_PIX_FMT_RGB565
:
1101 (0x1F & LIMIT_RGB(r_
)) |
1105 (0xF8 & LIMIT_RGB(b_
));
1107 case V4L2_PIX_FMT_RGB24
:
1108 *f_even
++ = LIMIT_RGB(r_
);
1109 *f_even
++ = LIMIT_RGB(g_
);
1110 *f_even
++ = LIMIT_RGB(b_
);
1112 case V4L2_PIX_FMT_RGB32
:
1113 *f_even
++ = LIMIT_RGB(r_
);
1114 *f_even
++ = LIMIT_RGB(g_
);
1115 *f_even
++ = LIMIT_RGB(b_
);
1118 case V4L2_PIX_FMT_RGB555
:
1120 *f_even
++ = (0x1F & LIMIT_RGB(r_
)) |
1122 *f_even
++ = (0x03 & (g
>> 3)) |
1123 (0x7C & (LIMIT_RGB(b_
) << 2));
1127 clipmask_even_index
+= clipmask_add
;
1128 f_even
+= stretch_bytes
;
1130 if(frame
->v4l2_format
.format
== V4L2_PIX_FMT_YUYV
) {
1135 y_
= 76284 * (y
[1] - 16);
1137 b_
= (y_
+ vb
) >> 16;
1138 g_
= (y_
+ uvg
)>> 16;
1139 r_
= (y_
+ ur
) >> 16;
1141 switch (frame
->v4l2_format
.format
) {
1142 case V4L2_PIX_FMT_RGB565
:
1145 (0x1F & LIMIT_RGB(r_
)) |
1149 (0xF8 & LIMIT_RGB(b_
));
1151 case V4L2_PIX_FMT_RGB24
:
1152 *f_even
++ = LIMIT_RGB(r_
);
1153 *f_even
++ = LIMIT_RGB(g_
);
1154 *f_even
++ = LIMIT_RGB(b_
);
1156 case V4L2_PIX_FMT_RGB32
:
1157 *f_even
++ = LIMIT_RGB(r_
);
1158 *f_even
++ = LIMIT_RGB(g_
);
1159 *f_even
++ = LIMIT_RGB(b_
);
1162 case V4L2_PIX_FMT_RGB555
:
1164 *f_even
++ = (0x1F & LIMIT_RGB(r_
)) |
1166 *f_even
++ = (0x03 & (g
>> 3)) |
1167 (0x7C & (LIMIT_RGB(b_
) << 2));
1171 clipmask_even_index
+= clipmask_add
;
1172 f_even
+= stretch_bytes
;
1174 scratch_get_extra(usbvision
, &y
[0], &y_ptr
, 2);
1176 if(frame
->v4l2_format
.format
== V4L2_PIX_FMT_YUYV
) {
1181 y_
= 76284 * (y
[0] - 16);
1183 b_
= (y_
+ vb
) >> 16;
1184 g_
= (y_
+ uvg
)>> 16;
1185 r_
= (y_
+ ur
) >> 16;
1187 switch (frame
->v4l2_format
.format
) {
1188 case V4L2_PIX_FMT_RGB565
:
1191 (0x1F & LIMIT_RGB(r_
)) |
1195 (0xF8 & LIMIT_RGB(b_
));
1197 case V4L2_PIX_FMT_RGB24
:
1198 *f_odd
++ = LIMIT_RGB(r_
);
1199 *f_odd
++ = LIMIT_RGB(g_
);
1200 *f_odd
++ = LIMIT_RGB(b_
);
1202 case V4L2_PIX_FMT_RGB32
:
1203 *f_odd
++ = LIMIT_RGB(r_
);
1204 *f_odd
++ = LIMIT_RGB(g_
);
1205 *f_odd
++ = LIMIT_RGB(b_
);
1208 case V4L2_PIX_FMT_RGB555
:
1210 *f_odd
++ = (0x1F & LIMIT_RGB(r_
)) |
1212 *f_odd
++ = (0x03 & (g
>> 3)) |
1213 (0x7C & (LIMIT_RGB(b_
) << 2));
1217 clipmask_odd_index
+= clipmask_add
;
1218 f_odd
+= stretch_bytes
;
1220 if(frame
->v4l2_format
.format
== V4L2_PIX_FMT_YUYV
) {
1225 y_
= 76284 * (y
[1] - 16);
1227 b_
= (y_
+ vb
) >> 16;
1228 g_
= (y_
+ uvg
)>> 16;
1229 r_
= (y_
+ ur
) >> 16;
1231 switch (frame
->v4l2_format
.format
) {
1232 case V4L2_PIX_FMT_RGB565
:
1235 (0x1F & LIMIT_RGB(r_
)) |
1239 (0xF8 & LIMIT_RGB(b_
));
1241 case V4L2_PIX_FMT_RGB24
:
1242 *f_odd
++ = LIMIT_RGB(r_
);
1243 *f_odd
++ = LIMIT_RGB(g_
);
1244 *f_odd
++ = LIMIT_RGB(b_
);
1246 case V4L2_PIX_FMT_RGB32
:
1247 *f_odd
++ = LIMIT_RGB(r_
);
1248 *f_odd
++ = LIMIT_RGB(g_
);
1249 *f_odd
++ = LIMIT_RGB(b_
);
1252 case V4L2_PIX_FMT_RGB555
:
1254 *f_odd
++ = (0x1F & LIMIT_RGB(r_
)) |
1256 *f_odd
++ = (0x03 & (g
>> 3)) |
1257 (0x7C & (LIMIT_RGB(b_
) << 2));
1261 clipmask_odd_index
+= clipmask_add
;
1262 f_odd
+= stretch_bytes
;
1265 scratch_rm_old(usbvision
,y_step
[block
% y_step_size
] * sub_block_size
);
1266 scratch_inc_extra_ptr(&y_ptr
, y_step
[(block
+ 2 * block_split
) % y_step_size
]
1268 scratch_inc_extra_ptr(&u_ptr
, uv_step
[block
% uv_step_size
]
1270 scratch_inc_extra_ptr(&v_ptr
, uv_step
[(block
+ 2 * block_split
) % uv_step_size
]
1274 scratch_rm_old(usbvision
, pixel_per_line
* 3 / 2
1275 + block_split
* sub_block_size
);
1277 frame
->curline
+= 2 * usbvision
->stretch_height
;
1278 *pcopylen
+= frame
->v4l2_linesize
* 2 * usbvision
->stretch_height
;
1280 if (frame
->curline
>= frame
->frmheight
)
1281 return ParseState_NextFrame
;
1283 return ParseState_Continue
;
1287 * usbvision_parse_data()
1289 * Generic routine to parse the scratch buffer. It employs either
1290 * usbvision_find_header() or usbvision_parse_lines() to do most
1294 static void usbvision_parse_data(struct usb_usbvision
*usbvision
)
1296 struct usbvision_frame
*frame
;
1297 enum ParseState newstate
;
1299 unsigned long lock_flags
;
1301 frame
= usbvision
->curFrame
;
1303 PDEBUG(DBG_PARSE
, "parsing len=%d\n", scratch_len(usbvision
));
1307 newstate
= ParseState_Out
;
1308 if (scratch_len(usbvision
)) {
1309 if (frame
->scanstate
== ScanState_Scanning
) {
1310 newstate
= usbvision_find_header(usbvision
);
1312 else if (frame
->scanstate
== ScanState_Lines
) {
1313 if (usbvision
->isocMode
== ISOC_MODE_YUV420
) {
1314 newstate
= usbvision_parse_lines_420(usbvision
, ©len
);
1316 else if (usbvision
->isocMode
== ISOC_MODE_YUV422
) {
1317 newstate
= usbvision_parse_lines_422(usbvision
, ©len
);
1319 else if (usbvision
->isocMode
== ISOC_MODE_COMPRESS
) {
1320 newstate
= usbvision_parse_compress(usbvision
, ©len
);
1325 if (newstate
== ParseState_Continue
) {
1328 else if ((newstate
== ParseState_NextFrame
) || (newstate
== ParseState_Out
)) {
1332 return; /* ParseState_EndParse */
1336 if (newstate
== ParseState_NextFrame
) {
1337 frame
->grabstate
= FrameState_Done
;
1338 do_gettimeofday(&(frame
->timestamp
));
1339 frame
->sequence
= usbvision
->frame_num
;
1341 spin_lock_irqsave(&usbvision
->queue_lock
, lock_flags
);
1342 list_move_tail(&(frame
->frame
), &usbvision
->outqueue
);
1343 usbvision
->curFrame
= NULL
;
1344 spin_unlock_irqrestore(&usbvision
->queue_lock
, lock_flags
);
1346 usbvision
->frame_num
++;
1348 /* This will cause the process to request another frame. */
1349 if (waitqueue_active(&usbvision
->wait_frame
)) {
1350 PDEBUG(DBG_PARSE
, "Wake up !");
1351 wake_up_interruptible(&usbvision
->wait_frame
);
1355 frame
->grabstate
= FrameState_Grabbing
;
1358 /* Update the frame's uncompressed length. */
1359 frame
->scanlength
+= copylen
;
1364 * Make all of the blocks of data contiguous
1366 static int usbvision_compress_isochronous(struct usb_usbvision
*usbvision
,
1369 unsigned char *packet_data
;
1372 for (i
= 0; i
< urb
->number_of_packets
; i
++) {
1373 int packet_len
= urb
->iso_frame_desc
[i
].actual_length
;
1374 int packet_stat
= urb
->iso_frame_desc
[i
].status
;
1376 packet_data
= urb
->transfer_buffer
+ urb
->iso_frame_desc
[i
].offset
;
1378 /* Detect and ignore errored packets */
1379 if (packet_stat
) { // packet_stat != 0 ?????????????
1380 PDEBUG(DBG_ISOC
, "data error: [%d] len=%d, status=%X", i
, packet_len
, packet_stat
);
1381 usbvision
->isocErrCount
++;
1385 /* Detect and ignore empty packets */
1386 if (packet_len
< 0) {
1387 PDEBUG(DBG_ISOC
, "error packet [%d]", i
);
1388 usbvision
->isocSkipCount
++;
1391 else if (packet_len
== 0) { /* Frame end ????? */
1392 PDEBUG(DBG_ISOC
, "null packet [%d]", i
);
1393 usbvision
->isocstate
=IsocState_NoFrame
;
1394 usbvision
->isocSkipCount
++;
1397 else if (packet_len
> usbvision
->isocPacketSize
) {
1398 PDEBUG(DBG_ISOC
, "packet[%d] > isocPacketSize", i
);
1399 usbvision
->isocSkipCount
++;
1403 PDEBUG(DBG_ISOC
, "packet ok [%d] len=%d", i
, packet_len
);
1405 if (usbvision
->isocstate
==IsocState_NoFrame
) { //new frame begins
1406 usbvision
->isocstate
=IsocState_InFrame
;
1407 scratch_mark_header(usbvision
);
1408 usbvision_measure_bandwidth(usbvision
);
1409 PDEBUG(DBG_ISOC
, "packet with header");
1413 * If usbvision continues to feed us with data but there is no
1414 * consumption (if, for example, V4L client fell asleep) we
1415 * may overflow the buffer. We have to move old data over to
1416 * free room for new data. This is bad for old data. If we
1417 * just drop new data then it's bad for new data... choose
1418 * your favorite evil here.
1420 if (scratch_free(usbvision
) < packet_len
) {
1422 usbvision
->scratch_ovf_count
++;
1423 PDEBUG(DBG_ISOC
, "scratch buf overflow! scr_len: %d, n: %d",
1424 scratch_len(usbvision
), packet_len
);
1425 scratch_rm_old(usbvision
, packet_len
- scratch_free(usbvision
));
1428 /* Now we know that there is enough room in scratch buffer */
1429 scratch_put(usbvision
, packet_data
, packet_len
);
1430 totlen
+= packet_len
;
1431 usbvision
->isocDataCount
+= packet_len
;
1432 usbvision
->isocPacketCount
++;
1438 printk(KERN_DEBUG
"+%d.\n", usbvision
->scratchlen
);
1439 usbvision_hexdump(data0
, (totlen
> 64) ? 64 : totlen
);
1447 static void usbvision_isocIrq(struct urb
*urb
)
1451 struct usb_usbvision
*usbvision
= urb
->context
;
1453 unsigned long startTime
= jiffies
;
1454 struct usbvision_frame
**f
;
1456 /* We don't want to do anything if we are about to be removed! */
1457 if (!USBVISION_IS_OPERATIONAL(usbvision
))
1460 /* any urb with wrong status is ignored without acknowledgement */
1461 if (urb
->status
== -ENOENT
) {
1465 f
= &usbvision
->curFrame
;
1467 /* Manage streaming interruption */
1468 if (usbvision
->streaming
== Stream_Interrupt
) {
1469 usbvision
->streaming
= Stream_Idle
;
1471 (*f
)->grabstate
= FrameState_Ready
;
1472 (*f
)->scanstate
= ScanState_Scanning
;
1474 PDEBUG(DBG_IRQ
, "stream interrupted");
1475 wake_up_interruptible(&usbvision
->wait_stream
);
1478 /* Copy the data received into our scratch buffer */
1479 len
= usbvision_compress_isochronous(usbvision
, urb
);
1481 usbvision
->isocUrbCount
++;
1482 usbvision
->urb_length
= len
;
1484 if (usbvision
->streaming
== Stream_On
) {
1486 /* If we collected enough data let's parse! */
1487 if ((scratch_len(usbvision
) > USBVISION_HEADER_LENGTH
) &&
1488 (!list_empty(&(usbvision
->inqueue
))) ) {
1490 (*f
) = list_entry(usbvision
->inqueue
.next
,
1491 struct usbvision_frame
,
1494 usbvision_parse_data(usbvision
);
1497 /*If we don't have a frame
1498 we're current working on, complain */
1500 "received data, but no one needs it");
1501 scratch_reset(usbvision
);
1505 PDEBUG(DBG_IRQ
, "received data, but no one needs it");
1506 scratch_reset(usbvision
);
1509 usbvision
->timeInIrq
+= jiffies
- startTime
;
1511 for (i
= 0; i
< USBVISION_URB_FRAMES
; i
++) {
1512 urb
->iso_frame_desc
[i
].status
= 0;
1513 urb
->iso_frame_desc
[i
].actual_length
= 0;
1517 urb
->dev
= usbvision
->dev
;
1518 errCode
= usb_submit_urb (urb
, GFP_ATOMIC
);
1521 err("%s: usb_submit_urb failed: error %d",
1528 /*************************************/
1529 /* Low level usbvision access functions */
1530 /*************************************/
1533 * usbvision_read_reg()
1535 * return < 0 -> Error
1539 int usbvision_read_reg(struct usb_usbvision
*usbvision
, unsigned char reg
)
1542 unsigned char buffer
[1];
1544 if (!USBVISION_IS_OPERATIONAL(usbvision
))
1547 errCode
= usb_control_msg(usbvision
->dev
, usb_rcvctrlpipe(usbvision
->dev
, 1),
1549 USB_DIR_IN
| USB_TYPE_VENDOR
| USB_RECIP_ENDPOINT
,
1550 0, (__u16
) reg
, buffer
, 1, HZ
);
1553 err("%s: failed: error %d", __func__
, errCode
);
1560 * usbvision_write_reg()
1562 * return 1 -> Reg written
1563 * 0 -> usbvision is not yet ready
1564 * -1 -> Something went wrong
1567 int usbvision_write_reg(struct usb_usbvision
*usbvision
, unsigned char reg
,
1568 unsigned char value
)
1572 if (!USBVISION_IS_OPERATIONAL(usbvision
))
1575 errCode
= usb_control_msg(usbvision
->dev
, usb_sndctrlpipe(usbvision
->dev
, 1),
1577 USB_DIR_OUT
| USB_TYPE_VENDOR
|
1578 USB_RECIP_ENDPOINT
, 0, (__u16
) reg
, &value
, 1, HZ
);
1581 err("%s: failed: error %d", __func__
, errCode
);
1587 static void usbvision_ctrlUrb_complete(struct urb
*urb
)
1589 struct usb_usbvision
*usbvision
= (struct usb_usbvision
*)urb
->context
;
1591 PDEBUG(DBG_IRQ
, "");
1592 usbvision
->ctrlUrbBusy
= 0;
1593 if (waitqueue_active(&usbvision
->ctrlUrb_wq
)) {
1594 wake_up_interruptible(&usbvision
->ctrlUrb_wq
);
1599 static int usbvision_write_reg_irq(struct usb_usbvision
*usbvision
,int address
,
1600 unsigned char *data
, int len
)
1604 PDEBUG(DBG_IRQ
, "");
1608 if (usbvision
->ctrlUrbBusy
) {
1611 usbvision
->ctrlUrbBusy
= 1;
1613 usbvision
->ctrlUrbSetup
.bRequestType
= USB_DIR_OUT
| USB_TYPE_VENDOR
| USB_RECIP_ENDPOINT
;
1614 usbvision
->ctrlUrbSetup
.bRequest
= USBVISION_OP_CODE
;
1615 usbvision
->ctrlUrbSetup
.wValue
= 0;
1616 usbvision
->ctrlUrbSetup
.wIndex
= cpu_to_le16(address
);
1617 usbvision
->ctrlUrbSetup
.wLength
= cpu_to_le16(len
);
1618 usb_fill_control_urb (usbvision
->ctrlUrb
, usbvision
->dev
,
1619 usb_sndctrlpipe(usbvision
->dev
, 1),
1620 (unsigned char *)&usbvision
->ctrlUrbSetup
,
1621 (void *)usbvision
->ctrlUrbBuffer
, len
,
1622 usbvision_ctrlUrb_complete
,
1625 memcpy(usbvision
->ctrlUrbBuffer
, data
, len
);
1627 errCode
= usb_submit_urb(usbvision
->ctrlUrb
, GFP_ATOMIC
);
1629 // error in usb_submit_urb()
1630 usbvision
->ctrlUrbBusy
= 0;
1632 PDEBUG(DBG_IRQ
, "submit %d byte: error %d", len
, errCode
);
1637 static int usbvision_init_compression(struct usb_usbvision
*usbvision
)
1641 usbvision
->lastIsocFrameNum
= -1;
1642 usbvision
->isocDataCount
= 0;
1643 usbvision
->isocPacketCount
= 0;
1644 usbvision
->isocSkipCount
= 0;
1645 usbvision
->comprLevel
= 50;
1646 usbvision
->lastComprLevel
= -1;
1647 usbvision
->isocUrbCount
= 0;
1648 usbvision
->requestIntra
= 1;
1649 usbvision
->isocMeasureBandwidthCount
= 0;
1654 /* this function measures the used bandwidth since last call
1655 * return: 0 : no error
1656 * sets usedBandwidth to 1-100 : 1-100% of full bandwidth resp. to isocPacketSize
1658 static int usbvision_measure_bandwidth (struct usb_usbvision
*usbvision
)
1662 if (usbvision
->isocMeasureBandwidthCount
< 2) { // this gives an average bandwidth of 3 frames
1663 usbvision
->isocMeasureBandwidthCount
++;
1666 if ((usbvision
->isocPacketSize
> 0) && (usbvision
->isocPacketCount
> 0)) {
1667 usbvision
->usedBandwidth
= usbvision
->isocDataCount
/
1668 (usbvision
->isocPacketCount
+ usbvision
->isocSkipCount
) *
1669 100 / usbvision
->isocPacketSize
;
1671 usbvision
->isocMeasureBandwidthCount
= 0;
1672 usbvision
->isocDataCount
= 0;
1673 usbvision
->isocPacketCount
= 0;
1674 usbvision
->isocSkipCount
= 0;
1678 static int usbvision_adjust_compression (struct usb_usbvision
*usbvision
)
1681 unsigned char buffer
[6];
1683 PDEBUG(DBG_IRQ
, "");
1684 if ((adjustCompression
) && (usbvision
->usedBandwidth
> 0)) {
1685 usbvision
->comprLevel
+= (usbvision
->usedBandwidth
- 90) / 2;
1686 RESTRICT_TO_RANGE(usbvision
->comprLevel
, 0, 100);
1687 if (usbvision
->comprLevel
!= usbvision
->lastComprLevel
) {
1689 if (usbvision
->bridgeType
== BRIDGE_NT1004
|| usbvision
->bridgeType
== BRIDGE_NT1005
) {
1690 buffer
[0] = (unsigned char)(4 + 16 * usbvision
->comprLevel
/ 100); // PCM Threshold 1
1691 buffer
[1] = (unsigned char)(4 + 8 * usbvision
->comprLevel
/ 100); // PCM Threshold 2
1692 distorsion
= 7 + 248 * usbvision
->comprLevel
/ 100;
1693 buffer
[2] = (unsigned char)(distorsion
& 0xFF); // Average distorsion Threshold (inter)
1694 buffer
[3] = (unsigned char)(distorsion
& 0xFF); // Average distorsion Threshold (intra)
1695 distorsion
= 1 + 42 * usbvision
->comprLevel
/ 100;
1696 buffer
[4] = (unsigned char)(distorsion
& 0xFF); // Maximum distorsion Threshold (inter)
1697 buffer
[5] = (unsigned char)(distorsion
& 0xFF); // Maximum distorsion Threshold (intra)
1699 else { //BRIDGE_NT1003
1700 buffer
[0] = (unsigned char)(4 + 16 * usbvision
->comprLevel
/ 100); // PCM threshold 1
1701 buffer
[1] = (unsigned char)(4 + 8 * usbvision
->comprLevel
/ 100); // PCM threshold 2
1702 distorsion
= 2 + 253 * usbvision
->comprLevel
/ 100;
1703 buffer
[2] = (unsigned char)(distorsion
& 0xFF); // distorsion threshold bit0-7
1704 buffer
[3] = 0; //(unsigned char)((distorsion >> 8) & 0x0F); // distorsion threshold bit 8-11
1705 distorsion
= 0 + 43 * usbvision
->comprLevel
/ 100;
1706 buffer
[4] = (unsigned char)(distorsion
& 0xFF); // maximum distorsion bit0-7
1707 buffer
[5] = 0; //(unsigned char)((distorsion >> 8) & 0x01); // maximum distorsion bit 8
1709 errCode
= usbvision_write_reg_irq(usbvision
, USBVISION_PCM_THR1
, buffer
, 6);
1711 PDEBUG(DBG_IRQ
, "new compr params %#02x %#02x %#02x %#02x %#02x %#02x", buffer
[0],
1712 buffer
[1], buffer
[2], buffer
[3], buffer
[4], buffer
[5]);
1713 usbvision
->lastComprLevel
= usbvision
->comprLevel
;
1720 static int usbvision_request_intra (struct usb_usbvision
*usbvision
)
1723 unsigned char buffer
[1];
1725 PDEBUG(DBG_IRQ
, "");
1726 usbvision
->requestIntra
= 1;
1728 usbvision_write_reg_irq(usbvision
, USBVISION_FORCE_INTRA
, buffer
, 1);
1732 static int usbvision_unrequest_intra (struct usb_usbvision
*usbvision
)
1735 unsigned char buffer
[1];
1737 PDEBUG(DBG_IRQ
, "");
1738 usbvision
->requestIntra
= 0;
1740 usbvision_write_reg_irq(usbvision
, USBVISION_FORCE_INTRA
, buffer
, 1);
1744 /*******************************
1745 * usbvision utility functions
1746 *******************************/
1748 int usbvision_power_off(struct usb_usbvision
*usbvision
)
1752 PDEBUG(DBG_FUNC
, "");
1754 errCode
= usbvision_write_reg(usbvision
, USBVISION_PWR_REG
, USBVISION_SSPND_EN
);
1756 usbvision
->power
= 0;
1758 PDEBUG(DBG_FUNC
, "%s: errCode %d", (errCode
!=1)?"ERROR":"power is off", errCode
);
1763 * usbvision_set_video_format()
1766 static int usbvision_set_video_format(struct usb_usbvision
*usbvision
, int format
)
1768 static const char proc
[] = "usbvision_set_video_format";
1770 unsigned char value
[2];
1772 if (!USBVISION_IS_OPERATIONAL(usbvision
))
1775 PDEBUG(DBG_FUNC
, "isocMode %#02x", format
);
1777 if ((format
!= ISOC_MODE_YUV422
)
1778 && (format
!= ISOC_MODE_YUV420
)
1779 && (format
!= ISOC_MODE_COMPRESS
)) {
1780 printk(KERN_ERR
"usbvision: unknown video format %02x, using default YUV420",
1782 format
= ISOC_MODE_YUV420
;
1784 value
[0] = 0x0A; //TODO: See the effect of the filter
1785 value
[1] = format
; // Sets the VO_MODE register which follows FILT_CONT
1786 rc
= usb_control_msg(usbvision
->dev
, usb_sndctrlpipe(usbvision
->dev
, 1),
1788 USB_DIR_OUT
| USB_TYPE_VENDOR
|
1789 USB_RECIP_ENDPOINT
, 0,
1790 (__u16
) USBVISION_FILT_CONT
, value
, 2, HZ
);
1793 printk(KERN_ERR
"%s: ERROR=%d. USBVISION stopped - "
1794 "reconnect or reload driver.\n", proc
, rc
);
1796 usbvision
->isocMode
= format
;
1801 * usbvision_set_output()
1805 int usbvision_set_output(struct usb_usbvision
*usbvision
, int width
,
1809 int UsbWidth
, UsbHeight
;
1810 unsigned int frameRate
=0, frameDrop
=0;
1811 unsigned char value
[4];
1813 if (!USBVISION_IS_OPERATIONAL(usbvision
)) {
1817 if (width
> MAX_USB_WIDTH
) {
1818 UsbWidth
= width
/ 2;
1819 usbvision
->stretch_width
= 2;
1823 usbvision
->stretch_width
= 1;
1826 if (height
> MAX_USB_HEIGHT
) {
1827 UsbHeight
= height
/ 2;
1828 usbvision
->stretch_height
= 2;
1832 usbvision
->stretch_height
= 1;
1835 RESTRICT_TO_RANGE(UsbWidth
, MIN_FRAME_WIDTH
, MAX_USB_WIDTH
);
1836 UsbWidth
&= ~(MIN_FRAME_WIDTH
-1);
1837 RESTRICT_TO_RANGE(UsbHeight
, MIN_FRAME_HEIGHT
, MAX_USB_HEIGHT
);
1840 PDEBUG(DBG_FUNC
, "usb %dx%d; screen %dx%d; stretch %dx%d",
1841 UsbWidth
, UsbHeight
, width
, height
,
1842 usbvision
->stretch_width
, usbvision
->stretch_height
);
1844 /* I'll not rewrite the same values */
1845 if ((UsbWidth
!= usbvision
->curwidth
) || (UsbHeight
!= usbvision
->curheight
)) {
1846 value
[0] = UsbWidth
& 0xff; //LSB
1847 value
[1] = (UsbWidth
>> 8) & 0x03; //MSB
1848 value
[2] = UsbHeight
& 0xff; //LSB
1849 value
[3] = (UsbHeight
>> 8) & 0x03; //MSB
1851 errCode
= usb_control_msg(usbvision
->dev
, usb_sndctrlpipe(usbvision
->dev
, 1),
1853 USB_DIR_OUT
| USB_TYPE_VENDOR
| USB_RECIP_ENDPOINT
,
1854 0, (__u16
) USBVISION_LXSIZE_O
, value
, 4, HZ
);
1857 err("%s failed: error %d", __func__
, errCode
);
1860 usbvision
->curwidth
= usbvision
->stretch_width
* UsbWidth
;
1861 usbvision
->curheight
= usbvision
->stretch_height
* UsbHeight
;
1864 if (usbvision
->isocMode
== ISOC_MODE_YUV422
) {
1865 frameRate
= (usbvision
->isocPacketSize
* 1000) / (UsbWidth
* UsbHeight
* 2);
1867 else if (usbvision
->isocMode
== ISOC_MODE_YUV420
) {
1868 frameRate
= (usbvision
->isocPacketSize
* 1000) / ((UsbWidth
* UsbHeight
* 12) / 8);
1871 frameRate
= FRAMERATE_MAX
;
1874 if (usbvision
->tvnormId
& V4L2_STD_625_50
) {
1875 frameDrop
= frameRate
* 32 / 25 - 1;
1877 else if (usbvision
->tvnormId
& V4L2_STD_525_60
) {
1878 frameDrop
= frameRate
* 32 / 30 - 1;
1881 RESTRICT_TO_RANGE(frameDrop
, FRAMERATE_MIN
, FRAMERATE_MAX
);
1883 PDEBUG(DBG_FUNC
, "frameRate %d fps, frameDrop %d", frameRate
, frameDrop
);
1885 frameDrop
= FRAMERATE_MAX
; // We can allow the maximum here, because dropping is controlled
1887 /* frameDrop = 7; => framePhase = 1, 5, 9, 13, 17, 21, 25, 0, 4, 8, ...
1889 => frameRate = (7 + 1) * 25 / 32 = 200 / 32 = 6.25;
1891 frameDrop = 9; => framePhase = 1, 5, 8, 11, 14, 17, 21, 24, 27, 1, 4, 8, ...
1892 => frameSkip = 4, 3, 3, 3, 3, 4, 3, 3, 3, 3, 4, ...
1893 => frameRate = (9 + 1) * 25 / 32 = 250 / 32 = 7.8125;
1895 errCode
= usbvision_write_reg(usbvision
, USBVISION_FRM_RATE
, frameDrop
);
1901 * usbvision_frames_alloc
1902 * allocate the required frames
1904 int usbvision_frames_alloc(struct usb_usbvision
*usbvision
, int number_of_frames
)
1908 /*needs to be page aligned cause the buffers can be mapped individually! */
1909 usbvision
->max_frame_size
= PAGE_ALIGN(usbvision
->curwidth
*
1910 usbvision
->curheight
*
1911 usbvision
->palette
.bytes_per_pixel
);
1913 /* Try to do my best to allocate the frames the user want in the remaining memory */
1914 usbvision
->num_frames
= number_of_frames
;
1915 while (usbvision
->num_frames
> 0) {
1916 usbvision
->fbuf_size
= usbvision
->num_frames
* usbvision
->max_frame_size
;
1917 if((usbvision
->fbuf
= usbvision_rvmalloc(usbvision
->fbuf_size
))) {
1920 usbvision
->num_frames
--;
1923 spin_lock_init(&usbvision
->queue_lock
);
1924 init_waitqueue_head(&usbvision
->wait_frame
);
1925 init_waitqueue_head(&usbvision
->wait_stream
);
1927 /* Allocate all buffers */
1928 for (i
= 0; i
< usbvision
->num_frames
; i
++) {
1929 usbvision
->frame
[i
].index
= i
;
1930 usbvision
->frame
[i
].grabstate
= FrameState_Unused
;
1931 usbvision
->frame
[i
].data
= usbvision
->fbuf
+
1932 i
* usbvision
->max_frame_size
;
1934 * Set default sizes for read operation.
1936 usbvision
->stretch_width
= 1;
1937 usbvision
->stretch_height
= 1;
1938 usbvision
->frame
[i
].width
= usbvision
->curwidth
;
1939 usbvision
->frame
[i
].height
= usbvision
->curheight
;
1940 usbvision
->frame
[i
].bytes_read
= 0;
1942 PDEBUG(DBG_FUNC
, "allocated %d frames (%d bytes per frame)",usbvision
->num_frames
,usbvision
->max_frame_size
);
1943 return usbvision
->num_frames
;
1947 * usbvision_frames_free
1948 * frees memory allocated for the frames
1950 void usbvision_frames_free(struct usb_usbvision
*usbvision
)
1952 /* Have to free all that memory */
1953 PDEBUG(DBG_FUNC
, "free %d frames",usbvision
->num_frames
);
1955 if (usbvision
->fbuf
!= NULL
) {
1956 usbvision_rvfree(usbvision
->fbuf
, usbvision
->fbuf_size
);
1957 usbvision
->fbuf
= NULL
;
1959 usbvision
->num_frames
= 0;
1963 * usbvision_empty_framequeues()
1964 * prepare queues for incoming and outgoing frames
1966 void usbvision_empty_framequeues(struct usb_usbvision
*usbvision
)
1970 INIT_LIST_HEAD(&(usbvision
->inqueue
));
1971 INIT_LIST_HEAD(&(usbvision
->outqueue
));
1973 for (i
= 0; i
< USBVISION_NUMFRAMES
; i
++) {
1974 usbvision
->frame
[i
].grabstate
= FrameState_Unused
;
1975 usbvision
->frame
[i
].bytes_read
= 0;
1980 * usbvision_stream_interrupt()
1983 int usbvision_stream_interrupt(struct usb_usbvision
*usbvision
)
1987 /* stop reading from the device */
1989 usbvision
->streaming
= Stream_Interrupt
;
1990 ret
= wait_event_timeout(usbvision
->wait_stream
,
1991 (usbvision
->streaming
== Stream_Idle
),
1992 msecs_to_jiffies(USBVISION_NUMSBUF
*USBVISION_URB_FRAMES
));
1997 * usbvision_set_compress_params()
2001 static int usbvision_set_compress_params(struct usb_usbvision
*usbvision
)
2003 static const char proc
[] = "usbvision_set_compresion_params: ";
2005 unsigned char value
[6];
2007 value
[0] = 0x0F; // Intra-Compression cycle
2008 value
[1] = 0x01; // Reg.45 one line per strip
2009 value
[2] = 0x00; // Reg.46 Force intra mode on all new frames
2010 value
[3] = 0x00; // Reg.47 FORCE_UP <- 0 normal operation (not force)
2011 value
[4] = 0xA2; // Reg.48 BUF_THR I'm not sure if this does something in not compressed mode.
2012 value
[5] = 0x00; // Reg.49 DVI_YUV This has nothing to do with compression
2014 //catched values for NT1004
2015 // value[0] = 0xFF; // Never apply intra mode automatically
2016 // value[1] = 0xF1; // Use full frame height for virtual strip width; One line per strip
2017 // value[2] = 0x01; // Force intra mode on all new frames
2018 // value[3] = 0x00; // Strip size 400 Bytes; do not force up
2019 // value[4] = 0xA2; //
2020 if (!USBVISION_IS_OPERATIONAL(usbvision
))
2023 rc
= usb_control_msg(usbvision
->dev
, usb_sndctrlpipe(usbvision
->dev
, 1),
2025 USB_DIR_OUT
| USB_TYPE_VENDOR
|
2026 USB_RECIP_ENDPOINT
, 0,
2027 (__u16
) USBVISION_INTRA_CYC
, value
, 5, HZ
);
2030 printk(KERN_ERR
"%sERROR=%d. USBVISION stopped - "
2031 "reconnect or reload driver.\n", proc
, rc
);
2035 if (usbvision
->bridgeType
== BRIDGE_NT1004
) {
2036 value
[0] = 20; // PCM Threshold 1
2037 value
[1] = 12; // PCM Threshold 2
2038 value
[2] = 255; // Distorsion Threshold inter
2039 value
[3] = 255; // Distorsion Threshold intra
2040 value
[4] = 43; // Max Distorsion inter
2041 value
[5] = 43; // Max Distorsion intra
2044 value
[0] = 20; // PCM Threshold 1
2045 value
[1] = 12; // PCM Threshold 2
2046 value
[2] = 255; // Distorsion Threshold d7-d0
2047 value
[3] = 0; // Distorsion Threshold d11-d8
2048 value
[4] = 43; // Max Distorsion d7-d0
2049 value
[5] = 0; // Max Distorsion d8
2052 if (!USBVISION_IS_OPERATIONAL(usbvision
))
2055 rc
= usb_control_msg(usbvision
->dev
, usb_sndctrlpipe(usbvision
->dev
, 1),
2057 USB_DIR_OUT
| USB_TYPE_VENDOR
|
2058 USB_RECIP_ENDPOINT
, 0,
2059 (__u16
) USBVISION_PCM_THR1
, value
, 6, HZ
);
2062 printk(KERN_ERR
"%sERROR=%d. USBVISION stopped - "
2063 "reconnect or reload driver.\n", proc
, rc
);
2073 * usbvision_set_input()
2075 * Set the input (saa711x, ...) size x y and other misc input params
2076 * I've no idea if this parameters are right
2079 int usbvision_set_input(struct usb_usbvision
*usbvision
)
2081 static const char proc
[] = "usbvision_set_input: ";
2083 unsigned char value
[8];
2084 unsigned char dvi_yuv_value
;
2086 if (!USBVISION_IS_OPERATIONAL(usbvision
))
2089 /* Set input format expected from decoder*/
2090 if (usbvision_device_data
[usbvision
->DevModel
].Vin_Reg1_override
) {
2091 value
[0] = usbvision_device_data
[usbvision
->DevModel
].Vin_Reg1
;
2092 } else if(usbvision_device_data
[usbvision
->DevModel
].Codec
== CODEC_SAA7113
) {
2093 /* SAA7113 uses 8 bit output */
2094 value
[0] = USBVISION_8_422_SYNC
;
2096 /* I'm sure only about d2-d0 [010] 16 bit 4:2:2 usin sync pulses
2097 * as that is how saa7111 is configured */
2098 value
[0] = USBVISION_16_422_SYNC
;
2099 /* | USBVISION_VSNC_POL | USBVISION_VCLK_POL);*/
2102 rc
= usbvision_write_reg(usbvision
, USBVISION_VIN_REG1
, value
[0]);
2104 printk(KERN_ERR
"%sERROR=%d. USBVISION stopped - "
2105 "reconnect or reload driver.\n", proc
, rc
);
2110 if (usbvision
->tvnormId
& V4L2_STD_PAL
) {
2112 value
[1] = 0x02; //0x02C0 -> 704 Input video line length
2114 value
[3] = 0x01; //0x0120 -> 288 Input video n. of lines
2116 value
[5] = 0x00; //0x0060 -> 96 Input video h offset
2118 value
[7] = 0x00; //0x0016 -> 22 Input video v offset
2119 } else if (usbvision
->tvnormId
& V4L2_STD_SECAM
) {
2121 value
[1] = 0x02; //0x02C0 -> 704 Input video line length
2123 value
[3] = 0x01; //0x0120 -> 288 Input video n. of lines
2125 value
[5] = 0x00; //0x0001 -> 01 Input video h offset
2127 value
[7] = 0x00; //0x0001 -> 01 Input video v offset
2128 } else { /* V4L2_STD_NTSC */
2130 value
[1] = 0x02; //0x02D0 -> 720 Input video line length
2132 value
[3] = 0x00; //0x00F0 -> 240 Input video number of lines
2134 value
[5] = 0x00; //0x0050 -> 80 Input video h offset
2136 value
[7] = 0x00; //0x0010 -> 16 Input video v offset
2139 if (usbvision_device_data
[usbvision
->DevModel
].X_Offset
>= 0) {
2140 value
[4]=usbvision_device_data
[usbvision
->DevModel
].X_Offset
& 0xff;
2141 value
[5]=(usbvision_device_data
[usbvision
->DevModel
].X_Offset
& 0x0300) >> 8;
2144 if (adjust_X_Offset
!= -1) {
2145 value
[4] = adjust_X_Offset
& 0xff;
2146 value
[5] = (adjust_X_Offset
& 0x0300) >> 8;
2149 if (usbvision_device_data
[usbvision
->DevModel
].Y_Offset
>= 0) {
2150 value
[6]=usbvision_device_data
[usbvision
->DevModel
].Y_Offset
& 0xff;
2151 value
[7]=(usbvision_device_data
[usbvision
->DevModel
].Y_Offset
& 0x0300) >> 8;
2154 if (adjust_Y_Offset
!= -1) {
2155 value
[6] = adjust_Y_Offset
& 0xff;
2156 value
[7] = (adjust_Y_Offset
& 0x0300) >> 8;
2159 rc
= usb_control_msg(usbvision
->dev
, usb_sndctrlpipe(usbvision
->dev
, 1),
2160 USBVISION_OP_CODE
, /* USBVISION specific code */
2161 USB_DIR_OUT
| USB_TYPE_VENDOR
| USB_RECIP_ENDPOINT
, 0,
2162 (__u16
) USBVISION_LXSIZE_I
, value
, 8, HZ
);
2164 printk(KERN_ERR
"%sERROR=%d. USBVISION stopped - "
2165 "reconnect or reload driver.\n", proc
, rc
);
2170 dvi_yuv_value
= 0x00; /* U comes after V, Ya comes after U/V, Yb comes after Yb */
2172 if(usbvision_device_data
[usbvision
->DevModel
].Dvi_yuv_override
){
2173 dvi_yuv_value
= usbvision_device_data
[usbvision
->DevModel
].Dvi_yuv
;
2175 else if(usbvision_device_data
[usbvision
->DevModel
].Codec
== CODEC_SAA7113
) {
2176 /* This changes as the fine sync control changes. Further investigation necessary */
2177 dvi_yuv_value
= 0x06;
2180 return (usbvision_write_reg(usbvision
, USBVISION_DVI_YUV
, dvi_yuv_value
));
2185 * usbvision_set_dram_settings()
2187 * Set the buffer address needed by the usbvision dram to operate
2188 * This values has been taken with usbsnoop.
2192 static int usbvision_set_dram_settings(struct usb_usbvision
*usbvision
)
2195 unsigned char value
[8];
2197 if (usbvision
->isocMode
== ISOC_MODE_COMPRESS
) {
2206 // UR: 0x0E200-0x3FFFF = 204288 Words (1 Word = 2 Byte)
2207 // FDL: 0x00000-0x0E099 = 57498 Words
2208 // VDW: 0x0E3FF-0x3FFFF
2220 /* These are the values of the address of the video buffer,
2221 * they have to be loaded into the USBVISION_DRM_PRM1-8
2223 * Start address of video output buffer for read: drm_prm1-2 -> 0x00000
2224 * End address of video output buffer for read: drm_prm1-3 -> 0x1ffff
2225 * Start address of video frame delay buffer: drm_prm1-4 -> 0x20000
2226 * Only used in compressed mode
2227 * End address of video frame delay buffer: drm_prm1-5-6 -> 0x3ffff
2228 * Only used in compressed mode
2229 * Start address of video output buffer for write: drm_prm1-7 -> 0x00000
2230 * End address of video output buffer for write: drm_prm1-8 -> 0x1ffff
2233 if (!USBVISION_IS_OPERATIONAL(usbvision
))
2236 rc
= usb_control_msg(usbvision
->dev
, usb_sndctrlpipe(usbvision
->dev
, 1),
2237 USBVISION_OP_CODE
, /* USBVISION specific code */
2238 USB_DIR_OUT
| USB_TYPE_VENDOR
|
2239 USB_RECIP_ENDPOINT
, 0,
2240 (__u16
) USBVISION_DRM_PRM1
, value
, 8, HZ
);
2243 err("%sERROR=%d", __func__
, rc
);
2247 /* Restart the video buffer logic */
2248 if ((rc
= usbvision_write_reg(usbvision
, USBVISION_DRM_CONT
, USBVISION_RES_UR
|
2249 USBVISION_RES_FDL
| USBVISION_RES_VDW
)) < 0)
2251 rc
= usbvision_write_reg(usbvision
, USBVISION_DRM_CONT
, 0x00);
2259 * Power on the device, enables suspend-resume logic
2260 * & reset the isoc End-Point
2264 int usbvision_power_on(struct usb_usbvision
*usbvision
)
2268 PDEBUG(DBG_FUNC
, "");
2270 usbvision_write_reg(usbvision
, USBVISION_PWR_REG
, USBVISION_SSPND_EN
);
2271 usbvision_write_reg(usbvision
, USBVISION_PWR_REG
,
2272 USBVISION_SSPND_EN
| USBVISION_RES2
);
2274 usbvision_write_reg(usbvision
, USBVISION_PWR_REG
,
2275 USBVISION_SSPND_EN
| USBVISION_PWR_VID
);
2276 errCode
= usbvision_write_reg(usbvision
, USBVISION_PWR_REG
,
2277 USBVISION_SSPND_EN
| USBVISION_PWR_VID
| USBVISION_RES2
);
2279 usbvision
->power
= 1;
2281 PDEBUG(DBG_FUNC
, "%s: errCode %d", (errCode
<0)?"ERROR":"power is on", errCode
);
2287 * usbvision timer stuff
2290 // to call usbvision_power_off from task queue
2291 static void call_usbvision_power_off(struct work_struct
*work
)
2293 struct usb_usbvision
*usbvision
= container_of(work
, struct usb_usbvision
, powerOffWork
);
2295 PDEBUG(DBG_FUNC
, "");
2296 if(mutex_lock_interruptible(&usbvision
->lock
)) {
2301 if(usbvision
->user
== 0) {
2302 usbvision_i2c_unregister(usbvision
);
2304 usbvision_power_off(usbvision
);
2305 usbvision
->initialized
= 0;
2307 mutex_unlock(&usbvision
->lock
);
2310 static void usbvision_powerOffTimer(unsigned long data
)
2312 struct usb_usbvision
*usbvision
= (void *) data
;
2314 PDEBUG(DBG_FUNC
, "");
2315 del_timer(&usbvision
->powerOffTimer
);
2316 INIT_WORK(&usbvision
->powerOffWork
, call_usbvision_power_off
);
2317 (void) schedule_work(&usbvision
->powerOffWork
);
2320 void usbvision_init_powerOffTimer(struct usb_usbvision
*usbvision
)
2322 init_timer(&usbvision
->powerOffTimer
);
2323 usbvision
->powerOffTimer
.data
= (long) usbvision
;
2324 usbvision
->powerOffTimer
.function
= usbvision_powerOffTimer
;
2327 void usbvision_set_powerOffTimer(struct usb_usbvision
*usbvision
)
2329 mod_timer(&usbvision
->powerOffTimer
, jiffies
+ USBVISION_POWEROFF_TIME
);
2332 void usbvision_reset_powerOffTimer(struct usb_usbvision
*usbvision
)
2334 if (timer_pending(&usbvision
->powerOffTimer
)) {
2335 del_timer(&usbvision
->powerOffTimer
);
2340 * usbvision_begin_streaming()
2341 * Sure you have to put bit 7 to 0, if not incoming frames are droped, but no
2342 * idea about the rest
2344 int usbvision_begin_streaming(struct usb_usbvision
*usbvision
)
2348 if (usbvision
->isocMode
== ISOC_MODE_COMPRESS
) {
2349 usbvision_init_compression(usbvision
);
2351 errCode
= usbvision_write_reg(usbvision
, USBVISION_VIN_REG2
, USBVISION_NOHVALID
|
2352 usbvision
->Vin_Reg2_Preset
);
2357 * usbvision_restart_isoc()
2358 * Not sure yet if touching here PWR_REG make loose the config
2361 int usbvision_restart_isoc(struct usb_usbvision
*usbvision
)
2367 usbvision_write_reg(usbvision
, USBVISION_PWR_REG
,
2368 USBVISION_SSPND_EN
| USBVISION_PWR_VID
)) < 0)
2372 usbvision_write_reg(usbvision
, USBVISION_PWR_REG
,
2373 USBVISION_SSPND_EN
| USBVISION_PWR_VID
|
2374 USBVISION_RES2
)) < 0)
2378 usbvision_write_reg(usbvision
, USBVISION_VIN_REG2
,
2379 USBVISION_KEEP_BLANK
| USBVISION_NOHVALID
|
2380 usbvision
->Vin_Reg2_Preset
)) < 0) return ret
;
2382 /* TODO: schedule timeout */
2383 while ((usbvision_read_reg(usbvision
, USBVISION_STATUS_REG
) & 0x01) != 1);
2388 int usbvision_audio_off(struct usb_usbvision
*usbvision
)
2390 if (usbvision_write_reg(usbvision
, USBVISION_IOPIN_REG
, USBVISION_AUDIO_MUTE
) < 0) {
2391 printk(KERN_ERR
"usbvision_audio_off: can't wirte reg\n");
2394 usbvision
->AudioMute
= 0;
2395 usbvision
->AudioChannel
= USBVISION_AUDIO_MUTE
;
2399 int usbvision_set_audio(struct usb_usbvision
*usbvision
, int AudioChannel
)
2401 if (!usbvision
->AudioMute
) {
2402 if (usbvision_write_reg(usbvision
, USBVISION_IOPIN_REG
, AudioChannel
) < 0) {
2403 printk(KERN_ERR
"usbvision_set_audio: can't write iopin register for audio switching\n");
2407 usbvision
->AudioChannel
= AudioChannel
;
2411 int usbvision_setup(struct usb_usbvision
*usbvision
,int format
)
2413 usbvision_set_video_format(usbvision
, format
);
2414 usbvision_set_dram_settings(usbvision
);
2415 usbvision_set_compress_params(usbvision
);
2416 usbvision_set_input(usbvision
);
2417 usbvision_set_output(usbvision
, MAX_USB_WIDTH
, MAX_USB_HEIGHT
);
2418 usbvision_restart_isoc(usbvision
);
2421 return USBVISION_IS_OPERATIONAL(usbvision
);
2424 int usbvision_set_alternate(struct usb_usbvision
*dev
)
2426 int errCode
, prev_alt
= dev
->ifaceAlt
;
2430 for(i
=0;i
< dev
->num_alt
; i
++)
2431 if(dev
->alt_max_pkt_size
[i
]>dev
->alt_max_pkt_size
[dev
->ifaceAlt
])
2434 if (dev
->ifaceAlt
!= prev_alt
) {
2435 dev
->isocPacketSize
= dev
->alt_max_pkt_size
[dev
->ifaceAlt
];
2436 PDEBUG(DBG_FUNC
,"setting alternate %d with wMaxPacketSize=%u", dev
->ifaceAlt
,dev
->isocPacketSize
);
2437 errCode
= usb_set_interface(dev
->dev
, dev
->iface
, dev
->ifaceAlt
);
2439 err ("cannot change alternate number to %d (error=%i)",
2440 dev
->ifaceAlt
, errCode
);
2445 PDEBUG(DBG_ISOC
, "ISO Packet Length:%d", dev
->isocPacketSize
);
2451 * usbvision_init_isoc()
2454 int usbvision_init_isoc(struct usb_usbvision
*usbvision
)
2456 struct usb_device
*dev
= usbvision
->dev
;
2457 int bufIdx
, errCode
, regValue
;
2460 if (!USBVISION_IS_OPERATIONAL(usbvision
))
2463 usbvision
->curFrame
= NULL
;
2464 scratch_reset(usbvision
);
2466 /* Alternate interface 1 is is the biggest frame size */
2467 errCode
= usbvision_set_alternate(usbvision
);
2469 usbvision
->last_error
= errCode
;
2472 sb_size
= USBVISION_URB_FRAMES
* usbvision
->isocPacketSize
;
2474 regValue
= (16 - usbvision_read_reg(usbvision
,
2475 USBVISION_ALTER_REG
)) & 0x0F;
2477 usbvision
->usb_bandwidth
= regValue
>> 1;
2478 PDEBUG(DBG_ISOC
, "USB Bandwidth Usage: %dMbit/Sec",
2479 usbvision
->usb_bandwidth
);
2483 /* We double buffer the Iso lists */
2485 for (bufIdx
= 0; bufIdx
< USBVISION_NUMSBUF
; bufIdx
++) {
2489 urb
= usb_alloc_urb(USBVISION_URB_FRAMES
, GFP_KERNEL
);
2491 err("%s: usb_alloc_urb() failed", __func__
);
2494 usbvision
->sbuf
[bufIdx
].urb
= urb
;
2495 usbvision
->sbuf
[bufIdx
].data
=
2496 usb_buffer_alloc(usbvision
->dev
,
2499 &urb
->transfer_dma
);
2501 urb
->context
= usbvision
;
2502 urb
->pipe
= usb_rcvisocpipe(dev
, usbvision
->video_endp
);
2503 urb
->transfer_flags
= URB_ISO_ASAP
;
2505 urb
->transfer_buffer
= usbvision
->sbuf
[bufIdx
].data
;
2506 urb
->complete
= usbvision_isocIrq
;
2507 urb
->number_of_packets
= USBVISION_URB_FRAMES
;
2508 urb
->transfer_buffer_length
=
2509 usbvision
->isocPacketSize
* USBVISION_URB_FRAMES
;
2510 for (j
= k
= 0; j
< USBVISION_URB_FRAMES
; j
++,
2511 k
+= usbvision
->isocPacketSize
) {
2512 urb
->iso_frame_desc
[j
].offset
= k
;
2513 urb
->iso_frame_desc
[j
].length
=
2514 usbvision
->isocPacketSize
;
2518 /* Submit all URBs */
2519 for (bufIdx
= 0; bufIdx
< USBVISION_NUMSBUF
; bufIdx
++) {
2520 errCode
= usb_submit_urb(usbvision
->sbuf
[bufIdx
].urb
,
2523 err("%s: usb_submit_urb(%d) failed: error %d",
2524 __func__
, bufIdx
, errCode
);
2528 usbvision
->streaming
= Stream_Idle
;
2529 PDEBUG(DBG_ISOC
, "%s: streaming=1 usbvision->video_endp=$%02x",
2531 usbvision
->video_endp
);
2536 * usbvision_stop_isoc()
2538 * This procedure stops streaming and deallocates URBs. Then it
2539 * activates zero-bandwidth alt. setting of the video interface.
2542 void usbvision_stop_isoc(struct usb_usbvision
*usbvision
)
2544 int bufIdx
, errCode
, regValue
;
2545 int sb_size
= USBVISION_URB_FRAMES
* usbvision
->isocPacketSize
;
2547 if ((usbvision
->streaming
== Stream_Off
) || (usbvision
->dev
== NULL
))
2550 /* Unschedule all of the iso td's */
2551 for (bufIdx
= 0; bufIdx
< USBVISION_NUMSBUF
; bufIdx
++) {
2552 usb_kill_urb(usbvision
->sbuf
[bufIdx
].urb
);
2553 if (usbvision
->sbuf
[bufIdx
].data
){
2554 usb_buffer_free(usbvision
->dev
,
2556 usbvision
->sbuf
[bufIdx
].data
,
2557 usbvision
->sbuf
[bufIdx
].urb
->transfer_dma
);
2559 usb_free_urb(usbvision
->sbuf
[bufIdx
].urb
);
2560 usbvision
->sbuf
[bufIdx
].urb
= NULL
;
2563 PDEBUG(DBG_ISOC
, "%s: streaming=Stream_Off\n", __func__
);
2564 usbvision
->streaming
= Stream_Off
;
2566 if (!usbvision
->remove_pending
) {
2568 /* Set packet size to 0 */
2569 usbvision
->ifaceAlt
=0;
2570 errCode
= usb_set_interface(usbvision
->dev
, usbvision
->iface
,
2571 usbvision
->ifaceAlt
);
2573 err("%s: usb_set_interface() failed: error %d",
2575 usbvision
->last_error
= errCode
;
2577 regValue
= (16-usbvision_read_reg(usbvision
, USBVISION_ALTER_REG
)) & 0x0F;
2578 usbvision
->isocPacketSize
=
2579 (regValue
== 0) ? 0 : (regValue
* 64) - 1;
2580 PDEBUG(DBG_ISOC
, "ISO Packet Length:%d",
2581 usbvision
->isocPacketSize
);
2583 usbvision
->usb_bandwidth
= regValue
>> 1;
2584 PDEBUG(DBG_ISOC
, "USB Bandwidth Usage: %dMbit/Sec",
2585 usbvision
->usb_bandwidth
);
2589 int usbvision_muxsel(struct usb_usbvision
*usbvision
, int channel
)
2591 /* inputs #0 and #3 are constant for every SAA711x. */
2592 /* inputs #1 and #2 are variable for SAA7111 and SAA7113 */
2593 int mode
[4]= {SAA7115_COMPOSITE0
, 0, 0, SAA7115_COMPOSITE3
};
2594 int audio
[]= {1, 0, 0, 0};
2595 struct v4l2_routing route
;
2596 //channel 0 is TV with audiochannel 1 (tuner mono)
2597 //channel 1 is Composite with audio channel 0 (line in)
2598 //channel 2 is S-Video with audio channel 0 (line in)
2599 //channel 3 is additional video inputs to the device with audio channel 0 (line in)
2601 RESTRICT_TO_RANGE(channel
, 0, usbvision
->video_inputs
);
2602 usbvision
->ctl_input
= channel
;
2604 // set the new channel
2605 // Regular USB TV Tuners -> channel: 0 = Television, 1 = Composite, 2 = S-Video
2606 // Four video input devices -> channel: 0 = Chan White, 1 = Chan Green, 2 = Chan Yellow, 3 = Chan Red
2608 switch (usbvision_device_data
[usbvision
->DevModel
].Codec
) {
2610 mode
[1] = SAA7115_COMPOSITE2
;
2611 if (SwitchSVideoInput
) {
2612 /* To handle problems with S-Video Input for
2613 * some devices. Use SwitchSVideoInput
2614 * parameter when loading the module.*/
2615 mode
[2] = SAA7115_COMPOSITE1
;
2618 mode
[2] = SAA7115_SVIDEO1
;
2623 /* modes for saa7111 */
2624 mode
[1] = SAA7115_COMPOSITE1
;
2625 mode
[2] = SAA7115_SVIDEO1
;
2628 route
.input
= mode
[channel
];
2630 call_i2c_clients(usbvision
, VIDIOC_INT_S_VIDEO_ROUTING
,&route
);
2631 usbvision_set_audio(usbvision
, audio
[channel
]);
2636 * Overrides for Emacs so that we follow Linus's tabbing style.
2637 * ---------------------------------------------------------------------------