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>
48 #include "usbvision.h"
50 static unsigned int core_debug
;
51 module_param(core_debug
,int,0644);
52 MODULE_PARM_DESC(core_debug
,"enable debug messages [core]");
54 static unsigned int force_testpattern
;
55 module_param(force_testpattern
,int,0644);
56 MODULE_PARM_DESC(force_testpattern
,"enable test pattern display [core]");
58 static int adjustCompression
= 1; /* Set the compression to be adaptive */
59 module_param(adjustCompression
, int, 0444);
60 MODULE_PARM_DESC(adjustCompression
, " Set the ADPCM compression for the device. Default: 1 (On)");
62 /* To help people with Black and White output with using s-video input.
63 * Some cables and input device are wired differently. */
64 static int SwitchSVideoInput
;
65 module_param(SwitchSVideoInput
, int, 0444);
66 MODULE_PARM_DESC(SwitchSVideoInput
, " Set the S-Video input. Some cables and input device are wired differently. Default: 0 (Off)");
68 static unsigned int adjust_X_Offset
= -1;
69 module_param(adjust_X_Offset
, int, 0644);
70 MODULE_PARM_DESC(adjust_X_Offset
, "adjust X offset display [core]");
72 static unsigned int adjust_Y_Offset
= -1;
73 module_param(adjust_Y_Offset
, int, 0644);
74 MODULE_PARM_DESC(adjust_Y_Offset
, "adjust Y offset display [core]");
77 #define ENABLE_HEXDUMP 0 /* Enable if you need it */
80 #ifdef USBVISION_DEBUG
81 #define PDEBUG(level, fmt, args...) { \
82 if (core_debug & (level)) \
83 printk(KERN_INFO KBUILD_MODNAME ":[%s:%d] " fmt, \
84 __func__, __LINE__ , ## args); \
87 #define PDEBUG(level, fmt, args...) do {} while(0)
90 #define DBG_HEADER 1<<0
93 #define DBG_PARSE 1<<3
94 #define DBG_SCRATCH 1<<4
97 static const int max_imgwidth
= MAX_FRAME_WIDTH
;
98 static const int max_imgheight
= MAX_FRAME_HEIGHT
;
99 static const int min_imgwidth
= MIN_FRAME_WIDTH
;
100 static const int min_imgheight
= MIN_FRAME_HEIGHT
;
102 /* The value of 'scratch_buf_size' affects quality of the picture
103 * in many ways. Shorter buffers may cause loss of data when client
104 * is too slow. Larger buffers are memory-consuming and take longer
105 * to work with. This setting can be adjusted, but the default value
106 * should be OK for most desktop users.
108 #define DEFAULT_SCRATCH_BUF_SIZE (0x20000) // 128kB memory scratch buffer
109 static const int scratch_buf_size
= DEFAULT_SCRATCH_BUF_SIZE
;
111 // Function prototypes
112 static int usbvision_request_intra (struct usb_usbvision
*usbvision
);
113 static int usbvision_unrequest_intra (struct usb_usbvision
*usbvision
);
114 static int usbvision_adjust_compression (struct usb_usbvision
*usbvision
);
115 static int usbvision_measure_bandwidth (struct usb_usbvision
*usbvision
);
117 /*******************************/
118 /* Memory management functions */
119 /*******************************/
122 * Here we want the physical address of the memory.
123 * This is used when initializing the contents of the area.
126 static void *usbvision_rvmalloc(unsigned long size
)
131 size
= PAGE_ALIGN(size
);
132 mem
= vmalloc_32(size
);
136 memset(mem
, 0, size
); /* Clear the ram out, no junk to the user */
137 adr
= (unsigned long) mem
;
139 SetPageReserved(vmalloc_to_page((void *)adr
));
147 static void usbvision_rvfree(void *mem
, unsigned long size
)
154 size
= PAGE_ALIGN(size
);
156 adr
= (unsigned long) mem
;
157 while ((long) size
> 0) {
158 ClearPageReserved(vmalloc_to_page((void *)adr
));
168 static void usbvision_hexdump(const unsigned char *data
, int len
)
173 for (i
= k
= 0; len
> 0; i
++, len
--) {
174 if (i
> 0 && (i
% 16 == 0)) {
178 k
+= sprintf(&tmp
[k
], "%02x ", data
[i
]);
185 /********************************
186 * scratch ring buffer handling
187 ********************************/
188 static int scratch_len(struct usb_usbvision
*usbvision
) /*This returns the amount of data actually in the buffer */
190 int len
= usbvision
->scratch_write_ptr
- usbvision
->scratch_read_ptr
;
192 len
+= scratch_buf_size
;
194 PDEBUG(DBG_SCRATCH
, "scratch_len() = %d\n", len
);
200 /* This returns the free space left in the buffer */
201 static int scratch_free(struct usb_usbvision
*usbvision
)
203 int free
= usbvision
->scratch_read_ptr
- usbvision
->scratch_write_ptr
;
205 free
+= scratch_buf_size
;
208 free
-= 1; /* at least one byte in the buffer must */
209 /* left blank, otherwise there is no chance to differ between full and empty */
211 PDEBUG(DBG_SCRATCH
, "return %d\n", free
);
217 /* This puts data into the buffer */
218 static int scratch_put(struct usb_usbvision
*usbvision
, unsigned char *data
,
223 if (usbvision
->scratch_write_ptr
+ len
< scratch_buf_size
) {
224 memcpy(usbvision
->scratch
+ usbvision
->scratch_write_ptr
, data
, len
);
225 usbvision
->scratch_write_ptr
+= len
;
228 len_part
= scratch_buf_size
- usbvision
->scratch_write_ptr
;
229 memcpy(usbvision
->scratch
+ usbvision
->scratch_write_ptr
, data
, len_part
);
230 if (len
== len_part
) {
231 usbvision
->scratch_write_ptr
= 0; /* just set write_ptr to zero */
234 memcpy(usbvision
->scratch
, data
+ len_part
, len
- len_part
);
235 usbvision
->scratch_write_ptr
= len
- len_part
;
239 PDEBUG(DBG_SCRATCH
, "len=%d, new write_ptr=%d\n", len
, usbvision
->scratch_write_ptr
);
244 /* This marks the write_ptr as position of new frame header */
245 static void scratch_mark_header(struct usb_usbvision
*usbvision
)
247 PDEBUG(DBG_SCRATCH
, "header at write_ptr=%d\n", usbvision
->scratch_headermarker_write_ptr
);
249 usbvision
->scratch_headermarker
[usbvision
->scratch_headermarker_write_ptr
] =
250 usbvision
->scratch_write_ptr
;
251 usbvision
->scratch_headermarker_write_ptr
+= 1;
252 usbvision
->scratch_headermarker_write_ptr
%= USBVISION_NUM_HEADERMARKER
;
255 /* This gets data from the buffer at the given "ptr" position */
256 static int scratch_get_extra(struct usb_usbvision
*usbvision
,
257 unsigned char *data
, int *ptr
, int len
)
260 if (*ptr
+ len
< scratch_buf_size
) {
261 memcpy(data
, usbvision
->scratch
+ *ptr
, len
);
265 len_part
= scratch_buf_size
- *ptr
;
266 memcpy(data
, usbvision
->scratch
+ *ptr
, len_part
);
267 if (len
== len_part
) {
268 *ptr
= 0; /* just set the y_ptr to zero */
271 memcpy(data
+ len_part
, usbvision
->scratch
, len
- len_part
);
272 *ptr
= len
- len_part
;
276 PDEBUG(DBG_SCRATCH
, "len=%d, new ptr=%d\n", len
, *ptr
);
282 /* This sets the scratch extra read pointer */
283 static void scratch_set_extra_ptr(struct usb_usbvision
*usbvision
, int *ptr
,
286 *ptr
= (usbvision
->scratch_read_ptr
+ len
)%scratch_buf_size
;
288 PDEBUG(DBG_SCRATCH
, "ptr=%d\n", *ptr
);
292 /*This increments the scratch extra read pointer */
293 static void scratch_inc_extra_ptr(int *ptr
, int len
)
295 *ptr
= (*ptr
+ len
) % scratch_buf_size
;
297 PDEBUG(DBG_SCRATCH
, "ptr=%d\n", *ptr
);
301 /* This gets data from the buffer */
302 static int scratch_get(struct usb_usbvision
*usbvision
, unsigned char *data
,
306 if (usbvision
->scratch_read_ptr
+ len
< scratch_buf_size
) {
307 memcpy(data
, usbvision
->scratch
+ usbvision
->scratch_read_ptr
, len
);
308 usbvision
->scratch_read_ptr
+= len
;
311 len_part
= scratch_buf_size
- usbvision
->scratch_read_ptr
;
312 memcpy(data
, usbvision
->scratch
+ usbvision
->scratch_read_ptr
, len_part
);
313 if (len
== len_part
) {
314 usbvision
->scratch_read_ptr
= 0; /* just set the read_ptr to zero */
317 memcpy(data
+ len_part
, usbvision
->scratch
, len
- len_part
);
318 usbvision
->scratch_read_ptr
= len
- len_part
;
322 PDEBUG(DBG_SCRATCH
, "len=%d, new read_ptr=%d\n", len
, usbvision
->scratch_read_ptr
);
328 /* This sets read pointer to next header and returns it */
329 static int scratch_get_header(struct usb_usbvision
*usbvision
,
330 struct usbvision_frame_header
*header
)
334 PDEBUG(DBG_SCRATCH
, "from read_ptr=%d", usbvision
->scratch_headermarker_read_ptr
);
336 while (usbvision
->scratch_headermarker_write_ptr
-
337 usbvision
->scratch_headermarker_read_ptr
!= 0) {
338 usbvision
->scratch_read_ptr
=
339 usbvision
->scratch_headermarker
[usbvision
->scratch_headermarker_read_ptr
];
340 usbvision
->scratch_headermarker_read_ptr
+= 1;
341 usbvision
->scratch_headermarker_read_ptr
%= USBVISION_NUM_HEADERMARKER
;
342 scratch_get(usbvision
, (unsigned char *)header
, USBVISION_HEADER_LENGTH
);
343 if ((header
->magic_1
== USBVISION_MAGIC_1
)
344 && (header
->magic_2
== USBVISION_MAGIC_2
)
345 && (header
->headerLength
== USBVISION_HEADER_LENGTH
)) {
346 errCode
= USBVISION_HEADER_LENGTH
;
347 header
->frameWidth
= header
->frameWidthLo
+ (header
->frameWidthHi
<< 8);
348 header
->frameHeight
= header
->frameHeightLo
+ (header
->frameHeightHi
<< 8);
357 /*This removes len bytes of old data from the buffer */
358 static void scratch_rm_old(struct usb_usbvision
*usbvision
, int len
)
361 usbvision
->scratch_read_ptr
+= len
;
362 usbvision
->scratch_read_ptr
%= scratch_buf_size
;
363 PDEBUG(DBG_SCRATCH
, "read_ptr is now %d\n", usbvision
->scratch_read_ptr
);
367 /*This resets the buffer - kills all data in it too */
368 static void scratch_reset(struct usb_usbvision
*usbvision
)
370 PDEBUG(DBG_SCRATCH
, "\n");
372 usbvision
->scratch_read_ptr
= 0;
373 usbvision
->scratch_write_ptr
= 0;
374 usbvision
->scratch_headermarker_read_ptr
= 0;
375 usbvision
->scratch_headermarker_write_ptr
= 0;
376 usbvision
->isocstate
= IsocState_NoFrame
;
379 int usbvision_scratch_alloc(struct usb_usbvision
*usbvision
)
381 usbvision
->scratch
= vmalloc_32(scratch_buf_size
);
382 scratch_reset(usbvision
);
383 if(usbvision
->scratch
== NULL
) {
384 err("%s: unable to allocate %d bytes for scratch",
385 __func__
, scratch_buf_size
);
391 void usbvision_scratch_free(struct usb_usbvision
*usbvision
)
393 if (usbvision
->scratch
!= NULL
) {
394 vfree(usbvision
->scratch
);
395 usbvision
->scratch
= NULL
;
400 * usbvision_testpattern()
402 * Procedure forms a test pattern (yellow grid on blue background).
405 * fullframe: if TRUE then entire frame is filled, otherwise the procedure
406 * continues from the current scanline.
407 * pmode 0: fill the frame with solid blue color (like on VCR or TV)
408 * 1: Draw a colored grid
411 static void usbvision_testpattern(struct usb_usbvision
*usbvision
,
412 int fullframe
, int pmode
)
414 static const char proc
[] = "usbvision_testpattern";
415 struct usbvision_frame
*frame
;
421 if (usbvision
== NULL
) {
422 printk(KERN_ERR
"%s: usbvision == NULL\n", proc
);
425 if (usbvision
->curFrame
== NULL
) {
426 printk(KERN_ERR
"%s: usbvision->curFrame is NULL.\n", proc
);
430 /* Grab the current frame */
431 frame
= usbvision
->curFrame
;
433 /* Optionally start at the beginning */
436 frame
->scanlength
= 0;
439 /* Form every scan line */
440 for (; frame
->curline
< frame
->frmheight
; frame
->curline
++) {
443 f
= frame
->data
+ (usbvision
->curwidth
* 3 * frame
->curline
);
444 for (i
= 0; i
< usbvision
->curwidth
; i
++) {
445 unsigned char cb
= 0x80;
446 unsigned char cg
= 0;
447 unsigned char cr
= 0;
450 if (frame
->curline
% 32 == 0)
451 cb
= 0, cg
= cr
= 0xFF;
452 else if (i
% 32 == 0) {
453 if (frame
->curline
% 32 == 1)
455 cb
= 0, cg
= cr
= 0xFF;
462 num_pass
* 2) & 0xFF;
465 num_pass
* 3) & 0xFF;
468 /* Just the blue screen */
478 frame
->grabstate
= FrameState_Done
;
479 frame
->scanlength
+= scan_length
;
485 * usbvision_decompress_alloc()
487 * allocates intermediate buffer for decompression
489 int usbvision_decompress_alloc(struct usb_usbvision
*usbvision
)
491 int IFB_size
= MAX_FRAME_WIDTH
* MAX_FRAME_HEIGHT
* 3 / 2;
492 usbvision
->IntraFrameBuffer
= vmalloc_32(IFB_size
);
493 if (usbvision
->IntraFrameBuffer
== NULL
) {
494 err("%s: unable to allocate %d for compr. frame buffer",
502 * usbvision_decompress_free()
504 * frees intermediate buffer for decompression
506 void usbvision_decompress_free(struct usb_usbvision
*usbvision
)
508 if (usbvision
->IntraFrameBuffer
!= NULL
) {
509 vfree(usbvision
->IntraFrameBuffer
);
510 usbvision
->IntraFrameBuffer
= NULL
;
514 /************************************************************
515 * Here comes the data parsing stuff that is run as interrupt
516 ************************************************************/
518 * usbvision_find_header()
520 * Locate one of supported header markers in the scratch buffer.
522 static enum ParseState
usbvision_find_header(struct usb_usbvision
*usbvision
)
524 struct usbvision_frame
*frame
;
527 frame
= usbvision
->curFrame
;
529 while (scratch_get_header(usbvision
, &frame
->isocHeader
) == USBVISION_HEADER_LENGTH
) {
530 // found header in scratch
531 PDEBUG(DBG_HEADER
, "found header: 0x%02x%02x %d %d %d %d %#x 0x%02x %u %u",
532 frame
->isocHeader
.magic_2
,
533 frame
->isocHeader
.magic_1
,
534 frame
->isocHeader
.headerLength
,
535 frame
->isocHeader
.frameNum
,
536 frame
->isocHeader
.framePhase
,
537 frame
->isocHeader
.frameLatency
,
538 frame
->isocHeader
.dataFormat
,
539 frame
->isocHeader
.formatParam
,
540 frame
->isocHeader
.frameWidth
,
541 frame
->isocHeader
.frameHeight
);
543 if (usbvision
->requestIntra
) {
544 if (frame
->isocHeader
.formatParam
& 0x80) {
546 usbvision
->lastIsocFrameNum
= -1; // do not check for lost frames this time
547 usbvision_unrequest_intra(usbvision
);
558 frame
->frmwidth
= frame
->isocHeader
.frameWidth
* usbvision
->stretch_width
;
559 frame
->frmheight
= frame
->isocHeader
.frameHeight
* usbvision
->stretch_height
;
560 frame
->v4l2_linesize
= (frame
->frmwidth
* frame
->v4l2_format
.depth
)>> 3;
562 else { // no header found
563 PDEBUG(DBG_HEADER
, "skipping scratch data, no header");
564 scratch_reset(usbvision
);
565 return ParseState_EndParse
;
569 if (frame
->isocHeader
.dataFormat
==ISOC_MODE_COMPRESS
) {
570 //check isocHeader.frameNum for lost frames
571 if (usbvision
->lastIsocFrameNum
>= 0) {
572 if (((usbvision
->lastIsocFrameNum
+ 1) % 32) != frame
->isocHeader
.frameNum
) {
573 // unexpected frame drop: need to request new intra frame
574 PDEBUG(DBG_HEADER
, "Lost frame before %d on USB", frame
->isocHeader
.frameNum
);
575 usbvision_request_intra(usbvision
);
576 return ParseState_NextFrame
;
579 usbvision
->lastIsocFrameNum
= frame
->isocHeader
.frameNum
;
581 usbvision
->header_count
++;
582 frame
->scanstate
= ScanState_Lines
;
585 if (force_testpattern
) {
586 usbvision_testpattern(usbvision
, 1, 1);
587 return ParseState_NextFrame
;
589 return ParseState_Continue
;
592 static enum ParseState
usbvision_parse_lines_422(struct usb_usbvision
*usbvision
,
595 volatile struct usbvision_frame
*frame
;
599 unsigned char yuyv
[4]={180, 128, 10, 128}; // YUV components
600 unsigned char rv
, gv
, bv
; // RGB components
601 int clipmask_index
, bytes_per_pixel
;
602 int stretch_bytes
, clipmask_add
;
604 frame
= usbvision
->curFrame
;
605 f
= frame
->data
+ (frame
->v4l2_linesize
* frame
->curline
);
607 /* Make sure there's enough data for the entire line */
608 len
= (frame
->isocHeader
.frameWidth
* 2)+5;
609 if (scratch_len(usbvision
) < len
) {
610 PDEBUG(DBG_PARSE
, "out of data in line %d, need %u.\n", frame
->curline
, len
);
611 return ParseState_Out
;
614 if ((frame
->curline
+ 1) >= frame
->frmheight
) {
615 return ParseState_NextFrame
;
618 bytes_per_pixel
= frame
->v4l2_format
.bytes_per_pixel
;
619 stretch_bytes
= (usbvision
->stretch_width
- 1) * bytes_per_pixel
;
620 clipmask_index
= frame
->curline
* MAX_FRAME_WIDTH
;
621 clipmask_add
= usbvision
->stretch_width
;
623 for (i
= 0; i
< frame
->frmwidth
; i
+=(2 * usbvision
->stretch_width
)) {
625 scratch_get(usbvision
, &yuyv
[0], 4);
627 if (frame
->v4l2_format
.format
== V4L2_PIX_FMT_YUYV
) {
633 YUV_TO_RGB_BY_THE_BOOK(yuyv
[0], yuyv
[1], yuyv
[3], rv
, gv
, bv
);
634 switch (frame
->v4l2_format
.format
) {
635 case V4L2_PIX_FMT_RGB565
:
638 *f
++ = (0x07 & (gv
>> 3)) |
641 case V4L2_PIX_FMT_RGB24
:
646 case V4L2_PIX_FMT_RGB32
:
652 case V4L2_PIX_FMT_RGB555
:
655 *f
++ = (0x03 & (gv
>> 3)) |
660 clipmask_index
+= clipmask_add
;
663 if (frame
->v4l2_format
.format
== V4L2_PIX_FMT_YUYV
) {
669 YUV_TO_RGB_BY_THE_BOOK(yuyv
[2], yuyv
[1], yuyv
[3], rv
, gv
, bv
);
670 switch (frame
->v4l2_format
.format
) {
671 case V4L2_PIX_FMT_RGB565
:
674 *f
++ = (0x07 & (gv
>> 3)) |
677 case V4L2_PIX_FMT_RGB24
:
682 case V4L2_PIX_FMT_RGB32
:
688 case V4L2_PIX_FMT_RGB555
:
691 *f
++ = (0x03 & (gv
>> 3)) |
696 clipmask_index
+= clipmask_add
;
700 frame
->curline
+= usbvision
->stretch_height
;
701 *pcopylen
+= frame
->v4l2_linesize
* usbvision
->stretch_height
;
703 if (frame
->curline
>= frame
->frmheight
) {
704 return ParseState_NextFrame
;
707 return ParseState_Continue
;
711 /* The decompression routine */
712 static int usbvision_decompress(struct usb_usbvision
*usbvision
,unsigned char *Compressed
,
713 unsigned char *Decompressed
, int *StartPos
,
714 int *BlockTypeStartPos
, int Len
)
716 int RestPixel
, Idx
, MaxPos
, Pos
, ExtraPos
, BlockLen
, BlockTypePos
, BlockTypeLen
;
717 unsigned char BlockByte
, BlockCode
, BlockType
, BlockTypeByte
, Integrator
;
721 BlockTypePos
= *BlockTypeStartPos
;
722 MaxPos
= 396; //Pos + Len;
732 for (Idx
= 0; Idx
< Len
; Idx
++) {
735 if (BlockTypeLen
==0) {
736 BlockTypeByte
= Compressed
[BlockTypePos
];
740 BlockType
= (BlockTypeByte
& 0xC0) >> 6;
743 usbvision
->ComprBlockTypes
[BlockType
]++;
746 if (BlockType
== 0) {
747 if(RestPixel
>= 24) {
750 Integrator
= Decompressed
[Idx
];
752 Idx
+= RestPixel
- 1;
756 BlockCode
= Compressed
[Pos
];
758 if (RestPixel
>= 24) {
761 BlockLen
= RestPixel
;
763 RestPixel
-= BlockLen
;
764 ExtraPos
= Pos
+ (BlockLen
/ 4);
770 if ((BlockLen
%4) == 0) {
771 BlockByte
= Compressed
[Pos
];
774 if (BlockType
== 1) { //inter Block
775 Integrator
= Decompressed
[Idx
];
777 switch (BlockByte
& 0xC0) {
779 Integrator
+= Compressed
[ExtraPos
];
783 Integrator
+= BlockCode
;
786 Integrator
-= BlockCode
;
789 Decompressed
[Idx
] = Integrator
;
794 *StartPos
= ExtraPos
;
795 *BlockTypeStartPos
= BlockTypePos
;
801 * usbvision_parse_compress()
803 * Parse compressed frame from the scratch buffer, put
804 * decoded RGB value into the current frame buffer and add the written
805 * number of bytes (RGB) to the *pcopylen.
808 static enum ParseState
usbvision_parse_compress(struct usb_usbvision
*usbvision
,
811 #define USBVISION_STRIP_MAGIC 0x5A
812 #define USBVISION_STRIP_LEN_MAX 400
813 #define USBVISION_STRIP_HEADER_LEN 3
815 struct usbvision_frame
*frame
;
816 unsigned char *f
,*u
= NULL
,*v
= NULL
;
817 unsigned char StripData
[USBVISION_STRIP_LEN_MAX
];
818 unsigned char StripHeader
[USBVISION_STRIP_HEADER_LEN
];
819 int Idx
, IdxEnd
, StripLen
, StripPtr
, StartBlockPos
, BlockPos
, BlockTypePos
;
820 int clipmask_index
, bytes_per_pixel
, rc
;
822 unsigned char rv
, gv
, bv
;
823 static unsigned char *Y
, *U
, *V
;
825 frame
= usbvision
->curFrame
;
826 imageSize
= frame
->frmwidth
* frame
->frmheight
;
827 if ( (frame
->v4l2_format
.format
== V4L2_PIX_FMT_YUV422P
) ||
828 (frame
->v4l2_format
.format
== V4L2_PIX_FMT_YVU420
) ) { // this is a planar format
829 //... v4l2_linesize not used here.
830 f
= frame
->data
+ (frame
->width
* frame
->curline
);
832 f
= frame
->data
+ (frame
->v4l2_linesize
* frame
->curline
);
834 if (frame
->v4l2_format
.format
== V4L2_PIX_FMT_YUYV
){ //initialise u and v pointers
835 // get base of u and b planes add halfoffset
839 + (frame
->frmwidth
>>1) * frame
->curline
;
840 v
= u
+ (imageSize
>>1 );
842 } else if (frame
->v4l2_format
.format
== V4L2_PIX_FMT_YVU420
){
844 v
= frame
->data
+ imageSize
+ ((frame
->curline
* (frame
->width
))>>2) ;
845 u
= v
+ (imageSize
>>2) ;
848 if (frame
->curline
== 0) {
849 usbvision_adjust_compression(usbvision
);
852 if (scratch_len(usbvision
) < USBVISION_STRIP_HEADER_LEN
) {
853 return ParseState_Out
;
856 //get strip header without changing the scratch_read_ptr
857 scratch_set_extra_ptr(usbvision
, &StripPtr
, 0);
858 scratch_get_extra(usbvision
, &StripHeader
[0], &StripPtr
,
859 USBVISION_STRIP_HEADER_LEN
);
861 if (StripHeader
[0] != USBVISION_STRIP_MAGIC
) {
863 usbvision
->stripMagicErrors
++;
864 return ParseState_NextFrame
;
867 if (frame
->curline
!= (int)StripHeader
[2]) {
868 //line number missmatch error
869 usbvision
->stripLineNumberErrors
++;
872 StripLen
= 2 * (unsigned int)StripHeader
[1];
873 if (StripLen
> USBVISION_STRIP_LEN_MAX
) {
875 // I think this never happens
876 usbvision_request_intra(usbvision
);
879 if (scratch_len(usbvision
) < StripLen
) {
880 //there is not enough data for the strip
881 return ParseState_Out
;
884 if (usbvision
->IntraFrameBuffer
) {
885 Y
= usbvision
->IntraFrameBuffer
+ frame
->frmwidth
* frame
->curline
;
886 U
= usbvision
->IntraFrameBuffer
+ imageSize
+ (frame
->frmwidth
/ 2) * (frame
->curline
/ 2);
887 V
= usbvision
->IntraFrameBuffer
+ imageSize
/ 4 * 5 + (frame
->frmwidth
/ 2) * (frame
->curline
/ 2);
890 return ParseState_NextFrame
;
893 bytes_per_pixel
= frame
->v4l2_format
.bytes_per_pixel
;
894 clipmask_index
= frame
->curline
* MAX_FRAME_WIDTH
;
896 scratch_get(usbvision
, StripData
, StripLen
);
898 IdxEnd
= frame
->frmwidth
;
899 BlockTypePos
= USBVISION_STRIP_HEADER_LEN
;
900 StartBlockPos
= BlockTypePos
+ (IdxEnd
- 1) / 96 + (IdxEnd
/ 2 - 1) / 96 + 2;
901 BlockPos
= StartBlockPos
;
903 usbvision
->BlockPos
= BlockPos
;
905 if ((rc
= usbvision_decompress(usbvision
, StripData
, Y
, &BlockPos
, &BlockTypePos
, IdxEnd
)) != IdxEnd
) {
906 //return ParseState_Continue;
908 if (StripLen
> usbvision
->maxStripLen
) {
909 usbvision
->maxStripLen
= StripLen
;
912 if (frame
->curline
%2) {
913 if ((rc
= usbvision_decompress(usbvision
, StripData
, V
, &BlockPos
, &BlockTypePos
, IdxEnd
/2)) != IdxEnd
/2) {
914 //return ParseState_Continue;
918 if ((rc
= usbvision_decompress(usbvision
, StripData
, U
, &BlockPos
, &BlockTypePos
, IdxEnd
/2)) != IdxEnd
/2) {
919 //return ParseState_Continue;
923 if (BlockPos
> usbvision
->comprBlockPos
) {
924 usbvision
->comprBlockPos
= BlockPos
;
926 if (BlockPos
> StripLen
) {
927 usbvision
->stripLenErrors
++;
930 for (Idx
= 0; Idx
< IdxEnd
; Idx
++) {
931 if(frame
->v4l2_format
.format
== V4L2_PIX_FMT_YUYV
) {
933 *f
++ = Idx
& 0x01 ? U
[Idx
/2] : V
[Idx
/2];
935 else if(frame
->v4l2_format
.format
== V4L2_PIX_FMT_YUV422P
) {
942 else if (frame
->v4l2_format
.format
== V4L2_PIX_FMT_YVU420
) {
944 if ( !(( Idx
& 0x01 ) | ( frame
->curline
& 0x01 )) ){
946 /* only need do this for 1 in 4 pixels */
947 /* intraframe buffer is YUV420 format */
955 YUV_TO_RGB_BY_THE_BOOK(Y
[Idx
], U
[Idx
/2], V
[Idx
/2], rv
, gv
, bv
);
956 switch (frame
->v4l2_format
.format
) {
957 case V4L2_PIX_FMT_GREY
:
960 case V4L2_PIX_FMT_RGB555
:
963 *f
++ = (0x03 & (gv
>> 3)) |
966 case V4L2_PIX_FMT_RGB565
:
969 *f
++ = (0x07 & (gv
>> 3)) |
972 case V4L2_PIX_FMT_RGB24
:
977 case V4L2_PIX_FMT_RGB32
:
987 /* Deal with non-integer no. of bytes for YUV420P */
988 if (frame
->v4l2_format
.format
!= V4L2_PIX_FMT_YVU420
)
989 *pcopylen
+= frame
->v4l2_linesize
;
991 *pcopylen
+= frame
->curline
& 0x01 ? frame
->v4l2_linesize
: frame
->v4l2_linesize
<< 1;
995 if (frame
->curline
>= frame
->frmheight
) {
996 return ParseState_NextFrame
;
999 return ParseState_Continue
;
1006 * usbvision_parse_lines_420()
1008 * Parse two lines from the scratch buffer, put
1009 * decoded RGB value into the current frame buffer and add the written
1010 * number of bytes (RGB) to the *pcopylen.
1013 static enum ParseState
usbvision_parse_lines_420(struct usb_usbvision
*usbvision
,
1016 struct usbvision_frame
*frame
;
1017 unsigned char *f_even
= NULL
, *f_odd
= NULL
;
1018 unsigned int pixel_per_line
, block
;
1019 int pixel
, block_split
;
1020 int y_ptr
, u_ptr
, v_ptr
, y_odd_offset
;
1021 const int y_block_size
= 128;
1022 const int uv_block_size
= 64;
1023 const int sub_block_size
= 32;
1024 const int y_step
[] = { 0, 0, 0, 2 }, y_step_size
= 4;
1025 const int uv_step
[]= { 0, 0, 0, 4 }, uv_step_size
= 4;
1026 unsigned char y
[2], u
, v
; /* YUV components */
1027 int y_
, u_
, v_
, vb
, uvg
, ur
;
1028 int r_
, g_
, b_
; /* RGB components */
1030 int clipmask_even_index
, clipmask_odd_index
, bytes_per_pixel
;
1031 int clipmask_add
, stretch_bytes
;
1033 frame
= usbvision
->curFrame
;
1034 f_even
= frame
->data
+ (frame
->v4l2_linesize
* frame
->curline
);
1035 f_odd
= f_even
+ frame
->v4l2_linesize
* usbvision
->stretch_height
;
1037 /* Make sure there's enough data for the entire line */
1038 /* In this mode usbvision transfer 3 bytes for every 2 pixels */
1039 /* I need two lines to decode the color */
1040 bytes_per_pixel
= frame
->v4l2_format
.bytes_per_pixel
;
1041 stretch_bytes
= (usbvision
->stretch_width
- 1) * bytes_per_pixel
;
1042 clipmask_even_index
= frame
->curline
* MAX_FRAME_WIDTH
;
1043 clipmask_odd_index
= clipmask_even_index
+ MAX_FRAME_WIDTH
;
1044 clipmask_add
= usbvision
->stretch_width
;
1045 pixel_per_line
= frame
->isocHeader
.frameWidth
;
1047 if (scratch_len(usbvision
) < (int)pixel_per_line
* 3) {
1048 //printk(KERN_DEBUG "out of data, need %d\n", len);
1049 return ParseState_Out
;
1052 if ((frame
->curline
+ 1) >= frame
->frmheight
) {
1053 return ParseState_NextFrame
;
1056 block_split
= (pixel_per_line
%y_block_size
) ? 1 : 0; //are some blocks splitted into different lines?
1058 y_odd_offset
= (pixel_per_line
/ y_block_size
) * (y_block_size
+ uv_block_size
)
1059 + block_split
* uv_block_size
;
1061 scratch_set_extra_ptr(usbvision
, &y_ptr
, y_odd_offset
);
1062 scratch_set_extra_ptr(usbvision
, &u_ptr
, y_block_size
);
1063 scratch_set_extra_ptr(usbvision
, &v_ptr
, y_odd_offset
1064 + (4 - block_split
) * sub_block_size
);
1066 for (block
= 0; block
< (pixel_per_line
/ sub_block_size
);
1070 for (pixel
= 0; pixel
< sub_block_size
; pixel
+=2) {
1071 scratch_get(usbvision
, &y
[0], 2);
1072 scratch_get_extra(usbvision
, &u
, &u_ptr
, 1);
1073 scratch_get_extra(usbvision
, &v
, &v_ptr
, 1);
1075 //I don't use the YUV_TO_RGB macro for better performance
1079 uvg
= -53281 * u_
- 25625 * v_
;
1082 if(frame
->v4l2_format
.format
== V4L2_PIX_FMT_YUYV
) {
1087 y_
= 76284 * (y
[0] - 16);
1089 b_
= (y_
+ vb
) >> 16;
1090 g_
= (y_
+ uvg
)>> 16;
1091 r_
= (y_
+ ur
) >> 16;
1093 switch (frame
->v4l2_format
.format
) {
1094 case V4L2_PIX_FMT_RGB565
:
1097 (0x1F & LIMIT_RGB(r_
)) |
1101 (0xF8 & LIMIT_RGB(b_
));
1103 case V4L2_PIX_FMT_RGB24
:
1104 *f_even
++ = LIMIT_RGB(r_
);
1105 *f_even
++ = LIMIT_RGB(g_
);
1106 *f_even
++ = LIMIT_RGB(b_
);
1108 case V4L2_PIX_FMT_RGB32
:
1109 *f_even
++ = LIMIT_RGB(r_
);
1110 *f_even
++ = LIMIT_RGB(g_
);
1111 *f_even
++ = LIMIT_RGB(b_
);
1114 case V4L2_PIX_FMT_RGB555
:
1116 *f_even
++ = (0x1F & LIMIT_RGB(r_
)) |
1118 *f_even
++ = (0x03 & (g
>> 3)) |
1119 (0x7C & (LIMIT_RGB(b_
) << 2));
1123 clipmask_even_index
+= clipmask_add
;
1124 f_even
+= stretch_bytes
;
1126 if(frame
->v4l2_format
.format
== V4L2_PIX_FMT_YUYV
) {
1131 y_
= 76284 * (y
[1] - 16);
1133 b_
= (y_
+ vb
) >> 16;
1134 g_
= (y_
+ uvg
)>> 16;
1135 r_
= (y_
+ ur
) >> 16;
1137 switch (frame
->v4l2_format
.format
) {
1138 case V4L2_PIX_FMT_RGB565
:
1141 (0x1F & LIMIT_RGB(r_
)) |
1145 (0xF8 & LIMIT_RGB(b_
));
1147 case V4L2_PIX_FMT_RGB24
:
1148 *f_even
++ = LIMIT_RGB(r_
);
1149 *f_even
++ = LIMIT_RGB(g_
);
1150 *f_even
++ = LIMIT_RGB(b_
);
1152 case V4L2_PIX_FMT_RGB32
:
1153 *f_even
++ = LIMIT_RGB(r_
);
1154 *f_even
++ = LIMIT_RGB(g_
);
1155 *f_even
++ = LIMIT_RGB(b_
);
1158 case V4L2_PIX_FMT_RGB555
:
1160 *f_even
++ = (0x1F & LIMIT_RGB(r_
)) |
1162 *f_even
++ = (0x03 & (g
>> 3)) |
1163 (0x7C & (LIMIT_RGB(b_
) << 2));
1167 clipmask_even_index
+= clipmask_add
;
1168 f_even
+= stretch_bytes
;
1170 scratch_get_extra(usbvision
, &y
[0], &y_ptr
, 2);
1172 if(frame
->v4l2_format
.format
== V4L2_PIX_FMT_YUYV
) {
1177 y_
= 76284 * (y
[0] - 16);
1179 b_
= (y_
+ vb
) >> 16;
1180 g_
= (y_
+ uvg
)>> 16;
1181 r_
= (y_
+ ur
) >> 16;
1183 switch (frame
->v4l2_format
.format
) {
1184 case V4L2_PIX_FMT_RGB565
:
1187 (0x1F & LIMIT_RGB(r_
)) |
1191 (0xF8 & LIMIT_RGB(b_
));
1193 case V4L2_PIX_FMT_RGB24
:
1194 *f_odd
++ = LIMIT_RGB(r_
);
1195 *f_odd
++ = LIMIT_RGB(g_
);
1196 *f_odd
++ = LIMIT_RGB(b_
);
1198 case V4L2_PIX_FMT_RGB32
:
1199 *f_odd
++ = LIMIT_RGB(r_
);
1200 *f_odd
++ = LIMIT_RGB(g_
);
1201 *f_odd
++ = LIMIT_RGB(b_
);
1204 case V4L2_PIX_FMT_RGB555
:
1206 *f_odd
++ = (0x1F & LIMIT_RGB(r_
)) |
1208 *f_odd
++ = (0x03 & (g
>> 3)) |
1209 (0x7C & (LIMIT_RGB(b_
) << 2));
1213 clipmask_odd_index
+= clipmask_add
;
1214 f_odd
+= stretch_bytes
;
1216 if(frame
->v4l2_format
.format
== V4L2_PIX_FMT_YUYV
) {
1221 y_
= 76284 * (y
[1] - 16);
1223 b_
= (y_
+ vb
) >> 16;
1224 g_
= (y_
+ uvg
)>> 16;
1225 r_
= (y_
+ ur
) >> 16;
1227 switch (frame
->v4l2_format
.format
) {
1228 case V4L2_PIX_FMT_RGB565
:
1231 (0x1F & LIMIT_RGB(r_
)) |
1235 (0xF8 & LIMIT_RGB(b_
));
1237 case V4L2_PIX_FMT_RGB24
:
1238 *f_odd
++ = LIMIT_RGB(r_
);
1239 *f_odd
++ = LIMIT_RGB(g_
);
1240 *f_odd
++ = LIMIT_RGB(b_
);
1242 case V4L2_PIX_FMT_RGB32
:
1243 *f_odd
++ = LIMIT_RGB(r_
);
1244 *f_odd
++ = LIMIT_RGB(g_
);
1245 *f_odd
++ = LIMIT_RGB(b_
);
1248 case V4L2_PIX_FMT_RGB555
:
1250 *f_odd
++ = (0x1F & LIMIT_RGB(r_
)) |
1252 *f_odd
++ = (0x03 & (g
>> 3)) |
1253 (0x7C & (LIMIT_RGB(b_
) << 2));
1257 clipmask_odd_index
+= clipmask_add
;
1258 f_odd
+= stretch_bytes
;
1261 scratch_rm_old(usbvision
,y_step
[block
% y_step_size
] * sub_block_size
);
1262 scratch_inc_extra_ptr(&y_ptr
, y_step
[(block
+ 2 * block_split
) % y_step_size
]
1264 scratch_inc_extra_ptr(&u_ptr
, uv_step
[block
% uv_step_size
]
1266 scratch_inc_extra_ptr(&v_ptr
, uv_step
[(block
+ 2 * block_split
) % uv_step_size
]
1270 scratch_rm_old(usbvision
, pixel_per_line
* 3 / 2
1271 + block_split
* sub_block_size
);
1273 frame
->curline
+= 2 * usbvision
->stretch_height
;
1274 *pcopylen
+= frame
->v4l2_linesize
* 2 * usbvision
->stretch_height
;
1276 if (frame
->curline
>= frame
->frmheight
)
1277 return ParseState_NextFrame
;
1279 return ParseState_Continue
;
1283 * usbvision_parse_data()
1285 * Generic routine to parse the scratch buffer. It employs either
1286 * usbvision_find_header() or usbvision_parse_lines() to do most
1290 static void usbvision_parse_data(struct usb_usbvision
*usbvision
)
1292 struct usbvision_frame
*frame
;
1293 enum ParseState newstate
;
1295 unsigned long lock_flags
;
1297 frame
= usbvision
->curFrame
;
1299 PDEBUG(DBG_PARSE
, "parsing len=%d\n", scratch_len(usbvision
));
1303 newstate
= ParseState_Out
;
1304 if (scratch_len(usbvision
)) {
1305 if (frame
->scanstate
== ScanState_Scanning
) {
1306 newstate
= usbvision_find_header(usbvision
);
1308 else if (frame
->scanstate
== ScanState_Lines
) {
1309 if (usbvision
->isocMode
== ISOC_MODE_YUV420
) {
1310 newstate
= usbvision_parse_lines_420(usbvision
, ©len
);
1312 else if (usbvision
->isocMode
== ISOC_MODE_YUV422
) {
1313 newstate
= usbvision_parse_lines_422(usbvision
, ©len
);
1315 else if (usbvision
->isocMode
== ISOC_MODE_COMPRESS
) {
1316 newstate
= usbvision_parse_compress(usbvision
, ©len
);
1321 if (newstate
== ParseState_Continue
) {
1324 else if ((newstate
== ParseState_NextFrame
) || (newstate
== ParseState_Out
)) {
1328 return; /* ParseState_EndParse */
1332 if (newstate
== ParseState_NextFrame
) {
1333 frame
->grabstate
= FrameState_Done
;
1334 do_gettimeofday(&(frame
->timestamp
));
1335 frame
->sequence
= usbvision
->frame_num
;
1337 spin_lock_irqsave(&usbvision
->queue_lock
, lock_flags
);
1338 list_move_tail(&(frame
->frame
), &usbvision
->outqueue
);
1339 usbvision
->curFrame
= NULL
;
1340 spin_unlock_irqrestore(&usbvision
->queue_lock
, lock_flags
);
1342 usbvision
->frame_num
++;
1344 /* This will cause the process to request another frame. */
1345 if (waitqueue_active(&usbvision
->wait_frame
)) {
1346 PDEBUG(DBG_PARSE
, "Wake up !");
1347 wake_up_interruptible(&usbvision
->wait_frame
);
1351 frame
->grabstate
= FrameState_Grabbing
;
1354 /* Update the frame's uncompressed length. */
1355 frame
->scanlength
+= copylen
;
1360 * Make all of the blocks of data contiguous
1362 static int usbvision_compress_isochronous(struct usb_usbvision
*usbvision
,
1365 unsigned char *packet_data
;
1368 for (i
= 0; i
< urb
->number_of_packets
; i
++) {
1369 int packet_len
= urb
->iso_frame_desc
[i
].actual_length
;
1370 int packet_stat
= urb
->iso_frame_desc
[i
].status
;
1372 packet_data
= urb
->transfer_buffer
+ urb
->iso_frame_desc
[i
].offset
;
1374 /* Detect and ignore errored packets */
1375 if (packet_stat
) { // packet_stat != 0 ?????????????
1376 PDEBUG(DBG_ISOC
, "data error: [%d] len=%d, status=%X", i
, packet_len
, packet_stat
);
1377 usbvision
->isocErrCount
++;
1381 /* Detect and ignore empty packets */
1382 if (packet_len
< 0) {
1383 PDEBUG(DBG_ISOC
, "error packet [%d]", i
);
1384 usbvision
->isocSkipCount
++;
1387 else if (packet_len
== 0) { /* Frame end ????? */
1388 PDEBUG(DBG_ISOC
, "null packet [%d]", i
);
1389 usbvision
->isocstate
=IsocState_NoFrame
;
1390 usbvision
->isocSkipCount
++;
1393 else if (packet_len
> usbvision
->isocPacketSize
) {
1394 PDEBUG(DBG_ISOC
, "packet[%d] > isocPacketSize", i
);
1395 usbvision
->isocSkipCount
++;
1399 PDEBUG(DBG_ISOC
, "packet ok [%d] len=%d", i
, packet_len
);
1401 if (usbvision
->isocstate
==IsocState_NoFrame
) { //new frame begins
1402 usbvision
->isocstate
=IsocState_InFrame
;
1403 scratch_mark_header(usbvision
);
1404 usbvision_measure_bandwidth(usbvision
);
1405 PDEBUG(DBG_ISOC
, "packet with header");
1409 * If usbvision continues to feed us with data but there is no
1410 * consumption (if, for example, V4L client fell asleep) we
1411 * may overflow the buffer. We have to move old data over to
1412 * free room for new data. This is bad for old data. If we
1413 * just drop new data then it's bad for new data... choose
1414 * your favorite evil here.
1416 if (scratch_free(usbvision
) < packet_len
) {
1418 usbvision
->scratch_ovf_count
++;
1419 PDEBUG(DBG_ISOC
, "scratch buf overflow! scr_len: %d, n: %d",
1420 scratch_len(usbvision
), packet_len
);
1421 scratch_rm_old(usbvision
, packet_len
- scratch_free(usbvision
));
1424 /* Now we know that there is enough room in scratch buffer */
1425 scratch_put(usbvision
, packet_data
, packet_len
);
1426 totlen
+= packet_len
;
1427 usbvision
->isocDataCount
+= packet_len
;
1428 usbvision
->isocPacketCount
++;
1434 printk(KERN_DEBUG
"+%d.\n", usbvision
->scratchlen
);
1435 usbvision_hexdump(data0
, (totlen
> 64) ? 64 : totlen
);
1443 static void usbvision_isocIrq(struct urb
*urb
)
1447 struct usb_usbvision
*usbvision
= urb
->context
;
1449 unsigned long startTime
= jiffies
;
1450 struct usbvision_frame
**f
;
1452 /* We don't want to do anything if we are about to be removed! */
1453 if (!USBVISION_IS_OPERATIONAL(usbvision
))
1456 /* any urb with wrong status is ignored without acknowledgement */
1457 if (urb
->status
== -ENOENT
) {
1461 f
= &usbvision
->curFrame
;
1463 /* Manage streaming interruption */
1464 if (usbvision
->streaming
== Stream_Interrupt
) {
1465 usbvision
->streaming
= Stream_Idle
;
1467 (*f
)->grabstate
= FrameState_Ready
;
1468 (*f
)->scanstate
= ScanState_Scanning
;
1470 PDEBUG(DBG_IRQ
, "stream interrupted");
1471 wake_up_interruptible(&usbvision
->wait_stream
);
1474 /* Copy the data received into our scratch buffer */
1475 len
= usbvision_compress_isochronous(usbvision
, urb
);
1477 usbvision
->isocUrbCount
++;
1478 usbvision
->urb_length
= len
;
1480 if (usbvision
->streaming
== Stream_On
) {
1482 /* If we collected enough data let's parse! */
1483 if ((scratch_len(usbvision
) > USBVISION_HEADER_LENGTH
) &&
1484 (!list_empty(&(usbvision
->inqueue
))) ) {
1486 (*f
) = list_entry(usbvision
->inqueue
.next
,
1487 struct usbvision_frame
,
1490 usbvision_parse_data(usbvision
);
1493 /*If we don't have a frame
1494 we're current working on, complain */
1496 "received data, but no one needs it");
1497 scratch_reset(usbvision
);
1501 PDEBUG(DBG_IRQ
, "received data, but no one needs it");
1502 scratch_reset(usbvision
);
1505 usbvision
->timeInIrq
+= jiffies
- startTime
;
1507 for (i
= 0; i
< USBVISION_URB_FRAMES
; i
++) {
1508 urb
->iso_frame_desc
[i
].status
= 0;
1509 urb
->iso_frame_desc
[i
].actual_length
= 0;
1513 urb
->dev
= usbvision
->dev
;
1514 errCode
= usb_submit_urb (urb
, GFP_ATOMIC
);
1517 err("%s: usb_submit_urb failed: error %d",
1524 /*************************************/
1525 /* Low level usbvision access functions */
1526 /*************************************/
1529 * usbvision_read_reg()
1531 * return < 0 -> Error
1535 int usbvision_read_reg(struct usb_usbvision
*usbvision
, unsigned char reg
)
1538 unsigned char buffer
[1];
1540 if (!USBVISION_IS_OPERATIONAL(usbvision
))
1543 errCode
= usb_control_msg(usbvision
->dev
, usb_rcvctrlpipe(usbvision
->dev
, 1),
1545 USB_DIR_IN
| USB_TYPE_VENDOR
| USB_RECIP_ENDPOINT
,
1546 0, (__u16
) reg
, buffer
, 1, HZ
);
1549 err("%s: failed: error %d", __func__
, errCode
);
1556 * usbvision_write_reg()
1558 * return 1 -> Reg written
1559 * 0 -> usbvision is not yet ready
1560 * -1 -> Something went wrong
1563 int usbvision_write_reg(struct usb_usbvision
*usbvision
, unsigned char reg
,
1564 unsigned char value
)
1568 if (!USBVISION_IS_OPERATIONAL(usbvision
))
1571 errCode
= usb_control_msg(usbvision
->dev
, usb_sndctrlpipe(usbvision
->dev
, 1),
1573 USB_DIR_OUT
| USB_TYPE_VENDOR
|
1574 USB_RECIP_ENDPOINT
, 0, (__u16
) reg
, &value
, 1, HZ
);
1577 err("%s: failed: error %d", __func__
, errCode
);
1583 static void usbvision_ctrlUrb_complete(struct urb
*urb
)
1585 struct usb_usbvision
*usbvision
= (struct usb_usbvision
*)urb
->context
;
1587 PDEBUG(DBG_IRQ
, "");
1588 usbvision
->ctrlUrbBusy
= 0;
1589 if (waitqueue_active(&usbvision
->ctrlUrb_wq
)) {
1590 wake_up_interruptible(&usbvision
->ctrlUrb_wq
);
1595 static int usbvision_write_reg_irq(struct usb_usbvision
*usbvision
,int address
,
1596 unsigned char *data
, int len
)
1600 PDEBUG(DBG_IRQ
, "");
1604 if (usbvision
->ctrlUrbBusy
) {
1607 usbvision
->ctrlUrbBusy
= 1;
1609 usbvision
->ctrlUrbSetup
.bRequestType
= USB_DIR_OUT
| USB_TYPE_VENDOR
| USB_RECIP_ENDPOINT
;
1610 usbvision
->ctrlUrbSetup
.bRequest
= USBVISION_OP_CODE
;
1611 usbvision
->ctrlUrbSetup
.wValue
= 0;
1612 usbvision
->ctrlUrbSetup
.wIndex
= cpu_to_le16(address
);
1613 usbvision
->ctrlUrbSetup
.wLength
= cpu_to_le16(len
);
1614 usb_fill_control_urb (usbvision
->ctrlUrb
, usbvision
->dev
,
1615 usb_sndctrlpipe(usbvision
->dev
, 1),
1616 (unsigned char *)&usbvision
->ctrlUrbSetup
,
1617 (void *)usbvision
->ctrlUrbBuffer
, len
,
1618 usbvision_ctrlUrb_complete
,
1621 memcpy(usbvision
->ctrlUrbBuffer
, data
, len
);
1623 errCode
= usb_submit_urb(usbvision
->ctrlUrb
, GFP_ATOMIC
);
1625 // error in usb_submit_urb()
1626 usbvision
->ctrlUrbBusy
= 0;
1628 PDEBUG(DBG_IRQ
, "submit %d byte: error %d", len
, errCode
);
1633 static int usbvision_init_compression(struct usb_usbvision
*usbvision
)
1637 usbvision
->lastIsocFrameNum
= -1;
1638 usbvision
->isocDataCount
= 0;
1639 usbvision
->isocPacketCount
= 0;
1640 usbvision
->isocSkipCount
= 0;
1641 usbvision
->comprLevel
= 50;
1642 usbvision
->lastComprLevel
= -1;
1643 usbvision
->isocUrbCount
= 0;
1644 usbvision
->requestIntra
= 1;
1645 usbvision
->isocMeasureBandwidthCount
= 0;
1650 /* this function measures the used bandwidth since last call
1651 * return: 0 : no error
1652 * sets usedBandwidth to 1-100 : 1-100% of full bandwidth resp. to isocPacketSize
1654 static int usbvision_measure_bandwidth (struct usb_usbvision
*usbvision
)
1658 if (usbvision
->isocMeasureBandwidthCount
< 2) { // this gives an average bandwidth of 3 frames
1659 usbvision
->isocMeasureBandwidthCount
++;
1662 if ((usbvision
->isocPacketSize
> 0) && (usbvision
->isocPacketCount
> 0)) {
1663 usbvision
->usedBandwidth
= usbvision
->isocDataCount
/
1664 (usbvision
->isocPacketCount
+ usbvision
->isocSkipCount
) *
1665 100 / usbvision
->isocPacketSize
;
1667 usbvision
->isocMeasureBandwidthCount
= 0;
1668 usbvision
->isocDataCount
= 0;
1669 usbvision
->isocPacketCount
= 0;
1670 usbvision
->isocSkipCount
= 0;
1674 static int usbvision_adjust_compression (struct usb_usbvision
*usbvision
)
1677 unsigned char buffer
[6];
1679 PDEBUG(DBG_IRQ
, "");
1680 if ((adjustCompression
) && (usbvision
->usedBandwidth
> 0)) {
1681 usbvision
->comprLevel
+= (usbvision
->usedBandwidth
- 90) / 2;
1682 RESTRICT_TO_RANGE(usbvision
->comprLevel
, 0, 100);
1683 if (usbvision
->comprLevel
!= usbvision
->lastComprLevel
) {
1685 if (usbvision
->bridgeType
== BRIDGE_NT1004
|| usbvision
->bridgeType
== BRIDGE_NT1005
) {
1686 buffer
[0] = (unsigned char)(4 + 16 * usbvision
->comprLevel
/ 100); // PCM Threshold 1
1687 buffer
[1] = (unsigned char)(4 + 8 * usbvision
->comprLevel
/ 100); // PCM Threshold 2
1688 distorsion
= 7 + 248 * usbvision
->comprLevel
/ 100;
1689 buffer
[2] = (unsigned char)(distorsion
& 0xFF); // Average distorsion Threshold (inter)
1690 buffer
[3] = (unsigned char)(distorsion
& 0xFF); // Average distorsion Threshold (intra)
1691 distorsion
= 1 + 42 * usbvision
->comprLevel
/ 100;
1692 buffer
[4] = (unsigned char)(distorsion
& 0xFF); // Maximum distorsion Threshold (inter)
1693 buffer
[5] = (unsigned char)(distorsion
& 0xFF); // Maximum distorsion Threshold (intra)
1695 else { //BRIDGE_NT1003
1696 buffer
[0] = (unsigned char)(4 + 16 * usbvision
->comprLevel
/ 100); // PCM threshold 1
1697 buffer
[1] = (unsigned char)(4 + 8 * usbvision
->comprLevel
/ 100); // PCM threshold 2
1698 distorsion
= 2 + 253 * usbvision
->comprLevel
/ 100;
1699 buffer
[2] = (unsigned char)(distorsion
& 0xFF); // distorsion threshold bit0-7
1700 buffer
[3] = 0; //(unsigned char)((distorsion >> 8) & 0x0F); // distorsion threshold bit 8-11
1701 distorsion
= 0 + 43 * usbvision
->comprLevel
/ 100;
1702 buffer
[4] = (unsigned char)(distorsion
& 0xFF); // maximum distorsion bit0-7
1703 buffer
[5] = 0; //(unsigned char)((distorsion >> 8) & 0x01); // maximum distorsion bit 8
1705 errCode
= usbvision_write_reg_irq(usbvision
, USBVISION_PCM_THR1
, buffer
, 6);
1707 PDEBUG(DBG_IRQ
, "new compr params %#02x %#02x %#02x %#02x %#02x %#02x", buffer
[0],
1708 buffer
[1], buffer
[2], buffer
[3], buffer
[4], buffer
[5]);
1709 usbvision
->lastComprLevel
= usbvision
->comprLevel
;
1716 static int usbvision_request_intra (struct usb_usbvision
*usbvision
)
1719 unsigned char buffer
[1];
1721 PDEBUG(DBG_IRQ
, "");
1722 usbvision
->requestIntra
= 1;
1724 usbvision_write_reg_irq(usbvision
, USBVISION_FORCE_INTRA
, buffer
, 1);
1728 static int usbvision_unrequest_intra (struct usb_usbvision
*usbvision
)
1731 unsigned char buffer
[1];
1733 PDEBUG(DBG_IRQ
, "");
1734 usbvision
->requestIntra
= 0;
1736 usbvision_write_reg_irq(usbvision
, USBVISION_FORCE_INTRA
, buffer
, 1);
1740 /*******************************
1741 * usbvision utility functions
1742 *******************************/
1744 int usbvision_power_off(struct usb_usbvision
*usbvision
)
1748 PDEBUG(DBG_FUNC
, "");
1750 errCode
= usbvision_write_reg(usbvision
, USBVISION_PWR_REG
, USBVISION_SSPND_EN
);
1752 usbvision
->power
= 0;
1754 PDEBUG(DBG_FUNC
, "%s: errCode %d", (errCode
!=1)?"ERROR":"power is off", errCode
);
1759 * usbvision_set_video_format()
1762 static int usbvision_set_video_format(struct usb_usbvision
*usbvision
, int format
)
1764 static const char proc
[] = "usbvision_set_video_format";
1766 unsigned char value
[2];
1768 if (!USBVISION_IS_OPERATIONAL(usbvision
))
1771 PDEBUG(DBG_FUNC
, "isocMode %#02x", format
);
1773 if ((format
!= ISOC_MODE_YUV422
)
1774 && (format
!= ISOC_MODE_YUV420
)
1775 && (format
!= ISOC_MODE_COMPRESS
)) {
1776 printk(KERN_ERR
"usbvision: unknown video format %02x, using default YUV420",
1778 format
= ISOC_MODE_YUV420
;
1780 value
[0] = 0x0A; //TODO: See the effect of the filter
1781 value
[1] = format
; // Sets the VO_MODE register which follows FILT_CONT
1782 rc
= usb_control_msg(usbvision
->dev
, usb_sndctrlpipe(usbvision
->dev
, 1),
1784 USB_DIR_OUT
| USB_TYPE_VENDOR
|
1785 USB_RECIP_ENDPOINT
, 0,
1786 (__u16
) USBVISION_FILT_CONT
, value
, 2, HZ
);
1789 printk(KERN_ERR
"%s: ERROR=%d. USBVISION stopped - "
1790 "reconnect or reload driver.\n", proc
, rc
);
1792 usbvision
->isocMode
= format
;
1797 * usbvision_set_output()
1801 int usbvision_set_output(struct usb_usbvision
*usbvision
, int width
,
1805 int UsbWidth
, UsbHeight
;
1806 unsigned int frameRate
=0, frameDrop
=0;
1807 unsigned char value
[4];
1809 if (!USBVISION_IS_OPERATIONAL(usbvision
)) {
1813 if (width
> MAX_USB_WIDTH
) {
1814 UsbWidth
= width
/ 2;
1815 usbvision
->stretch_width
= 2;
1819 usbvision
->stretch_width
= 1;
1822 if (height
> MAX_USB_HEIGHT
) {
1823 UsbHeight
= height
/ 2;
1824 usbvision
->stretch_height
= 2;
1828 usbvision
->stretch_height
= 1;
1831 RESTRICT_TO_RANGE(UsbWidth
, MIN_FRAME_WIDTH
, MAX_USB_WIDTH
);
1832 UsbWidth
&= ~(MIN_FRAME_WIDTH
-1);
1833 RESTRICT_TO_RANGE(UsbHeight
, MIN_FRAME_HEIGHT
, MAX_USB_HEIGHT
);
1836 PDEBUG(DBG_FUNC
, "usb %dx%d; screen %dx%d; stretch %dx%d",
1837 UsbWidth
, UsbHeight
, width
, height
,
1838 usbvision
->stretch_width
, usbvision
->stretch_height
);
1840 /* I'll not rewrite the same values */
1841 if ((UsbWidth
!= usbvision
->curwidth
) || (UsbHeight
!= usbvision
->curheight
)) {
1842 value
[0] = UsbWidth
& 0xff; //LSB
1843 value
[1] = (UsbWidth
>> 8) & 0x03; //MSB
1844 value
[2] = UsbHeight
& 0xff; //LSB
1845 value
[3] = (UsbHeight
>> 8) & 0x03; //MSB
1847 errCode
= usb_control_msg(usbvision
->dev
, usb_sndctrlpipe(usbvision
->dev
, 1),
1849 USB_DIR_OUT
| USB_TYPE_VENDOR
| USB_RECIP_ENDPOINT
,
1850 0, (__u16
) USBVISION_LXSIZE_O
, value
, 4, HZ
);
1853 err("%s failed: error %d", __func__
, errCode
);
1856 usbvision
->curwidth
= usbvision
->stretch_width
* UsbWidth
;
1857 usbvision
->curheight
= usbvision
->stretch_height
* UsbHeight
;
1860 if (usbvision
->isocMode
== ISOC_MODE_YUV422
) {
1861 frameRate
= (usbvision
->isocPacketSize
* 1000) / (UsbWidth
* UsbHeight
* 2);
1863 else if (usbvision
->isocMode
== ISOC_MODE_YUV420
) {
1864 frameRate
= (usbvision
->isocPacketSize
* 1000) / ((UsbWidth
* UsbHeight
* 12) / 8);
1867 frameRate
= FRAMERATE_MAX
;
1870 if (usbvision
->tvnormId
& V4L2_STD_625_50
) {
1871 frameDrop
= frameRate
* 32 / 25 - 1;
1873 else if (usbvision
->tvnormId
& V4L2_STD_525_60
) {
1874 frameDrop
= frameRate
* 32 / 30 - 1;
1877 RESTRICT_TO_RANGE(frameDrop
, FRAMERATE_MIN
, FRAMERATE_MAX
);
1879 PDEBUG(DBG_FUNC
, "frameRate %d fps, frameDrop %d", frameRate
, frameDrop
);
1881 frameDrop
= FRAMERATE_MAX
; // We can allow the maximum here, because dropping is controlled
1883 /* frameDrop = 7; => framePhase = 1, 5, 9, 13, 17, 21, 25, 0, 4, 8, ...
1885 => frameRate = (7 + 1) * 25 / 32 = 200 / 32 = 6.25;
1887 frameDrop = 9; => framePhase = 1, 5, 8, 11, 14, 17, 21, 24, 27, 1, 4, 8, ...
1888 => frameSkip = 4, 3, 3, 3, 3, 4, 3, 3, 3, 3, 4, ...
1889 => frameRate = (9 + 1) * 25 / 32 = 250 / 32 = 7.8125;
1891 errCode
= usbvision_write_reg(usbvision
, USBVISION_FRM_RATE
, frameDrop
);
1897 * usbvision_frames_alloc
1898 * allocate the required frames
1900 int usbvision_frames_alloc(struct usb_usbvision
*usbvision
, int number_of_frames
)
1904 /*needs to be page aligned cause the buffers can be mapped individually! */
1905 usbvision
->max_frame_size
= PAGE_ALIGN(usbvision
->curwidth
*
1906 usbvision
->curheight
*
1907 usbvision
->palette
.bytes_per_pixel
);
1909 /* Try to do my best to allocate the frames the user want in the remaining memory */
1910 usbvision
->num_frames
= number_of_frames
;
1911 while (usbvision
->num_frames
> 0) {
1912 usbvision
->fbuf_size
= usbvision
->num_frames
* usbvision
->max_frame_size
;
1913 if((usbvision
->fbuf
= usbvision_rvmalloc(usbvision
->fbuf_size
))) {
1916 usbvision
->num_frames
--;
1919 spin_lock_init(&usbvision
->queue_lock
);
1920 init_waitqueue_head(&usbvision
->wait_frame
);
1921 init_waitqueue_head(&usbvision
->wait_stream
);
1923 /* Allocate all buffers */
1924 for (i
= 0; i
< usbvision
->num_frames
; i
++) {
1925 usbvision
->frame
[i
].index
= i
;
1926 usbvision
->frame
[i
].grabstate
= FrameState_Unused
;
1927 usbvision
->frame
[i
].data
= usbvision
->fbuf
+
1928 i
* usbvision
->max_frame_size
;
1930 * Set default sizes for read operation.
1932 usbvision
->stretch_width
= 1;
1933 usbvision
->stretch_height
= 1;
1934 usbvision
->frame
[i
].width
= usbvision
->curwidth
;
1935 usbvision
->frame
[i
].height
= usbvision
->curheight
;
1936 usbvision
->frame
[i
].bytes_read
= 0;
1938 PDEBUG(DBG_FUNC
, "allocated %d frames (%d bytes per frame)",usbvision
->num_frames
,usbvision
->max_frame_size
);
1939 return usbvision
->num_frames
;
1943 * usbvision_frames_free
1944 * frees memory allocated for the frames
1946 void usbvision_frames_free(struct usb_usbvision
*usbvision
)
1948 /* Have to free all that memory */
1949 PDEBUG(DBG_FUNC
, "free %d frames",usbvision
->num_frames
);
1951 if (usbvision
->fbuf
!= NULL
) {
1952 usbvision_rvfree(usbvision
->fbuf
, usbvision
->fbuf_size
);
1953 usbvision
->fbuf
= NULL
;
1955 usbvision
->num_frames
= 0;
1959 * usbvision_empty_framequeues()
1960 * prepare queues for incoming and outgoing frames
1962 void usbvision_empty_framequeues(struct usb_usbvision
*usbvision
)
1966 INIT_LIST_HEAD(&(usbvision
->inqueue
));
1967 INIT_LIST_HEAD(&(usbvision
->outqueue
));
1969 for (i
= 0; i
< USBVISION_NUMFRAMES
; i
++) {
1970 usbvision
->frame
[i
].grabstate
= FrameState_Unused
;
1971 usbvision
->frame
[i
].bytes_read
= 0;
1976 * usbvision_stream_interrupt()
1979 int usbvision_stream_interrupt(struct usb_usbvision
*usbvision
)
1983 /* stop reading from the device */
1985 usbvision
->streaming
= Stream_Interrupt
;
1986 ret
= wait_event_timeout(usbvision
->wait_stream
,
1987 (usbvision
->streaming
== Stream_Idle
),
1988 msecs_to_jiffies(USBVISION_NUMSBUF
*USBVISION_URB_FRAMES
));
1993 * usbvision_set_compress_params()
1997 static int usbvision_set_compress_params(struct usb_usbvision
*usbvision
)
1999 static const char proc
[] = "usbvision_set_compresion_params: ";
2001 unsigned char value
[6];
2003 value
[0] = 0x0F; // Intra-Compression cycle
2004 value
[1] = 0x01; // Reg.45 one line per strip
2005 value
[2] = 0x00; // Reg.46 Force intra mode on all new frames
2006 value
[3] = 0x00; // Reg.47 FORCE_UP <- 0 normal operation (not force)
2007 value
[4] = 0xA2; // Reg.48 BUF_THR I'm not sure if this does something in not compressed mode.
2008 value
[5] = 0x00; // Reg.49 DVI_YUV This has nothing to do with compression
2010 //catched values for NT1004
2011 // value[0] = 0xFF; // Never apply intra mode automatically
2012 // value[1] = 0xF1; // Use full frame height for virtual strip width; One line per strip
2013 // value[2] = 0x01; // Force intra mode on all new frames
2014 // value[3] = 0x00; // Strip size 400 Bytes; do not force up
2015 // value[4] = 0xA2; //
2016 if (!USBVISION_IS_OPERATIONAL(usbvision
))
2019 rc
= usb_control_msg(usbvision
->dev
, usb_sndctrlpipe(usbvision
->dev
, 1),
2021 USB_DIR_OUT
| USB_TYPE_VENDOR
|
2022 USB_RECIP_ENDPOINT
, 0,
2023 (__u16
) USBVISION_INTRA_CYC
, value
, 5, HZ
);
2026 printk(KERN_ERR
"%sERROR=%d. USBVISION stopped - "
2027 "reconnect or reload driver.\n", proc
, rc
);
2031 if (usbvision
->bridgeType
== BRIDGE_NT1004
) {
2032 value
[0] = 20; // PCM Threshold 1
2033 value
[1] = 12; // PCM Threshold 2
2034 value
[2] = 255; // Distorsion Threshold inter
2035 value
[3] = 255; // Distorsion Threshold intra
2036 value
[4] = 43; // Max Distorsion inter
2037 value
[5] = 43; // Max Distorsion intra
2040 value
[0] = 20; // PCM Threshold 1
2041 value
[1] = 12; // PCM Threshold 2
2042 value
[2] = 255; // Distorsion Threshold d7-d0
2043 value
[3] = 0; // Distorsion Threshold d11-d8
2044 value
[4] = 43; // Max Distorsion d7-d0
2045 value
[5] = 0; // Max Distorsion d8
2048 if (!USBVISION_IS_OPERATIONAL(usbvision
))
2051 rc
= usb_control_msg(usbvision
->dev
, usb_sndctrlpipe(usbvision
->dev
, 1),
2053 USB_DIR_OUT
| USB_TYPE_VENDOR
|
2054 USB_RECIP_ENDPOINT
, 0,
2055 (__u16
) USBVISION_PCM_THR1
, value
, 6, HZ
);
2058 printk(KERN_ERR
"%sERROR=%d. USBVISION stopped - "
2059 "reconnect or reload driver.\n", proc
, rc
);
2069 * usbvision_set_input()
2071 * Set the input (saa711x, ...) size x y and other misc input params
2072 * I've no idea if this parameters are right
2075 int usbvision_set_input(struct usb_usbvision
*usbvision
)
2077 static const char proc
[] = "usbvision_set_input: ";
2079 unsigned char value
[8];
2080 unsigned char dvi_yuv_value
;
2082 if (!USBVISION_IS_OPERATIONAL(usbvision
))
2085 /* Set input format expected from decoder*/
2086 if (usbvision_device_data
[usbvision
->DevModel
].Vin_Reg1_override
) {
2087 value
[0] = usbvision_device_data
[usbvision
->DevModel
].Vin_Reg1
;
2088 } else if(usbvision_device_data
[usbvision
->DevModel
].Codec
== CODEC_SAA7113
) {
2089 /* SAA7113 uses 8 bit output */
2090 value
[0] = USBVISION_8_422_SYNC
;
2092 /* I'm sure only about d2-d0 [010] 16 bit 4:2:2 usin sync pulses
2093 * as that is how saa7111 is configured */
2094 value
[0] = USBVISION_16_422_SYNC
;
2095 /* | USBVISION_VSNC_POL | USBVISION_VCLK_POL);*/
2098 rc
= usbvision_write_reg(usbvision
, USBVISION_VIN_REG1
, value
[0]);
2100 printk(KERN_ERR
"%sERROR=%d. USBVISION stopped - "
2101 "reconnect or reload driver.\n", proc
, rc
);
2106 if (usbvision
->tvnormId
& V4L2_STD_PAL
) {
2108 value
[1] = 0x02; //0x02C0 -> 704 Input video line length
2110 value
[3] = 0x01; //0x0120 -> 288 Input video n. of lines
2112 value
[5] = 0x00; //0x0060 -> 96 Input video h offset
2114 value
[7] = 0x00; //0x0016 -> 22 Input video v offset
2115 } else if (usbvision
->tvnormId
& V4L2_STD_SECAM
) {
2117 value
[1] = 0x02; //0x02C0 -> 704 Input video line length
2119 value
[3] = 0x01; //0x0120 -> 288 Input video n. of lines
2121 value
[5] = 0x00; //0x0001 -> 01 Input video h offset
2123 value
[7] = 0x00; //0x0001 -> 01 Input video v offset
2124 } else { /* V4L2_STD_NTSC */
2126 value
[1] = 0x02; //0x02D0 -> 720 Input video line length
2128 value
[3] = 0x00; //0x00F0 -> 240 Input video number of lines
2130 value
[5] = 0x00; //0x0050 -> 80 Input video h offset
2132 value
[7] = 0x00; //0x0010 -> 16 Input video v offset
2135 if (usbvision_device_data
[usbvision
->DevModel
].X_Offset
>= 0) {
2136 value
[4]=usbvision_device_data
[usbvision
->DevModel
].X_Offset
& 0xff;
2137 value
[5]=(usbvision_device_data
[usbvision
->DevModel
].X_Offset
& 0x0300) >> 8;
2140 if (adjust_X_Offset
!= -1) {
2141 value
[4] = adjust_X_Offset
& 0xff;
2142 value
[5] = (adjust_X_Offset
& 0x0300) >> 8;
2145 if (usbvision_device_data
[usbvision
->DevModel
].Y_Offset
>= 0) {
2146 value
[6]=usbvision_device_data
[usbvision
->DevModel
].Y_Offset
& 0xff;
2147 value
[7]=(usbvision_device_data
[usbvision
->DevModel
].Y_Offset
& 0x0300) >> 8;
2150 if (adjust_Y_Offset
!= -1) {
2151 value
[6] = adjust_Y_Offset
& 0xff;
2152 value
[7] = (adjust_Y_Offset
& 0x0300) >> 8;
2155 rc
= usb_control_msg(usbvision
->dev
, usb_sndctrlpipe(usbvision
->dev
, 1),
2156 USBVISION_OP_CODE
, /* USBVISION specific code */
2157 USB_DIR_OUT
| USB_TYPE_VENDOR
| USB_RECIP_ENDPOINT
, 0,
2158 (__u16
) USBVISION_LXSIZE_I
, value
, 8, HZ
);
2160 printk(KERN_ERR
"%sERROR=%d. USBVISION stopped - "
2161 "reconnect or reload driver.\n", proc
, rc
);
2166 dvi_yuv_value
= 0x00; /* U comes after V, Ya comes after U/V, Yb comes after Yb */
2168 if(usbvision_device_data
[usbvision
->DevModel
].Dvi_yuv_override
){
2169 dvi_yuv_value
= usbvision_device_data
[usbvision
->DevModel
].Dvi_yuv
;
2171 else if(usbvision_device_data
[usbvision
->DevModel
].Codec
== CODEC_SAA7113
) {
2172 /* This changes as the fine sync control changes. Further investigation necessary */
2173 dvi_yuv_value
= 0x06;
2176 return (usbvision_write_reg(usbvision
, USBVISION_DVI_YUV
, dvi_yuv_value
));
2181 * usbvision_set_dram_settings()
2183 * Set the buffer address needed by the usbvision dram to operate
2184 * This values has been taken with usbsnoop.
2188 static int usbvision_set_dram_settings(struct usb_usbvision
*usbvision
)
2191 unsigned char value
[8];
2193 if (usbvision
->isocMode
== ISOC_MODE_COMPRESS
) {
2202 // UR: 0x0E200-0x3FFFF = 204288 Words (1 Word = 2 Byte)
2203 // FDL: 0x00000-0x0E099 = 57498 Words
2204 // VDW: 0x0E3FF-0x3FFFF
2216 /* These are the values of the address of the video buffer,
2217 * they have to be loaded into the USBVISION_DRM_PRM1-8
2219 * Start address of video output buffer for read: drm_prm1-2 -> 0x00000
2220 * End address of video output buffer for read: drm_prm1-3 -> 0x1ffff
2221 * Start address of video frame delay buffer: drm_prm1-4 -> 0x20000
2222 * Only used in compressed mode
2223 * End address of video frame delay buffer: drm_prm1-5-6 -> 0x3ffff
2224 * Only used in compressed mode
2225 * Start address of video output buffer for write: drm_prm1-7 -> 0x00000
2226 * End address of video output buffer for write: drm_prm1-8 -> 0x1ffff
2229 if (!USBVISION_IS_OPERATIONAL(usbvision
))
2232 rc
= usb_control_msg(usbvision
->dev
, usb_sndctrlpipe(usbvision
->dev
, 1),
2233 USBVISION_OP_CODE
, /* USBVISION specific code */
2234 USB_DIR_OUT
| USB_TYPE_VENDOR
|
2235 USB_RECIP_ENDPOINT
, 0,
2236 (__u16
) USBVISION_DRM_PRM1
, value
, 8, HZ
);
2239 err("%sERROR=%d", __func__
, rc
);
2243 /* Restart the video buffer logic */
2244 if ((rc
= usbvision_write_reg(usbvision
, USBVISION_DRM_CONT
, USBVISION_RES_UR
|
2245 USBVISION_RES_FDL
| USBVISION_RES_VDW
)) < 0)
2247 rc
= usbvision_write_reg(usbvision
, USBVISION_DRM_CONT
, 0x00);
2255 * Power on the device, enables suspend-resume logic
2256 * & reset the isoc End-Point
2260 int usbvision_power_on(struct usb_usbvision
*usbvision
)
2264 PDEBUG(DBG_FUNC
, "");
2266 usbvision_write_reg(usbvision
, USBVISION_PWR_REG
, USBVISION_SSPND_EN
);
2267 usbvision_write_reg(usbvision
, USBVISION_PWR_REG
,
2268 USBVISION_SSPND_EN
| USBVISION_RES2
);
2270 usbvision_write_reg(usbvision
, USBVISION_PWR_REG
,
2271 USBVISION_SSPND_EN
| USBVISION_PWR_VID
);
2272 errCode
= usbvision_write_reg(usbvision
, USBVISION_PWR_REG
,
2273 USBVISION_SSPND_EN
| USBVISION_PWR_VID
| USBVISION_RES2
);
2275 usbvision
->power
= 1;
2277 PDEBUG(DBG_FUNC
, "%s: errCode %d", (errCode
<0)?"ERROR":"power is on", errCode
);
2283 * usbvision timer stuff
2286 // to call usbvision_power_off from task queue
2287 static void call_usbvision_power_off(struct work_struct
*work
)
2289 struct usb_usbvision
*usbvision
= container_of(work
, struct usb_usbvision
, powerOffWork
);
2291 PDEBUG(DBG_FUNC
, "");
2292 if(mutex_lock_interruptible(&usbvision
->lock
)) {
2297 if(usbvision
->user
== 0) {
2298 usbvision_i2c_unregister(usbvision
);
2300 usbvision_power_off(usbvision
);
2301 usbvision
->initialized
= 0;
2303 mutex_unlock(&usbvision
->lock
);
2306 static void usbvision_powerOffTimer(unsigned long data
)
2308 struct usb_usbvision
*usbvision
= (void *) data
;
2310 PDEBUG(DBG_FUNC
, "");
2311 del_timer(&usbvision
->powerOffTimer
);
2312 INIT_WORK(&usbvision
->powerOffWork
, call_usbvision_power_off
);
2313 (void) schedule_work(&usbvision
->powerOffWork
);
2316 void usbvision_init_powerOffTimer(struct usb_usbvision
*usbvision
)
2318 init_timer(&usbvision
->powerOffTimer
);
2319 usbvision
->powerOffTimer
.data
= (long) usbvision
;
2320 usbvision
->powerOffTimer
.function
= usbvision_powerOffTimer
;
2323 void usbvision_set_powerOffTimer(struct usb_usbvision
*usbvision
)
2325 mod_timer(&usbvision
->powerOffTimer
, jiffies
+ USBVISION_POWEROFF_TIME
);
2328 void usbvision_reset_powerOffTimer(struct usb_usbvision
*usbvision
)
2330 if (timer_pending(&usbvision
->powerOffTimer
)) {
2331 del_timer(&usbvision
->powerOffTimer
);
2336 * usbvision_begin_streaming()
2337 * Sure you have to put bit 7 to 0, if not incoming frames are droped, but no
2338 * idea about the rest
2340 int usbvision_begin_streaming(struct usb_usbvision
*usbvision
)
2344 if (usbvision
->isocMode
== ISOC_MODE_COMPRESS
) {
2345 usbvision_init_compression(usbvision
);
2347 errCode
= usbvision_write_reg(usbvision
, USBVISION_VIN_REG2
, USBVISION_NOHVALID
|
2348 usbvision
->Vin_Reg2_Preset
);
2353 * usbvision_restart_isoc()
2354 * Not sure yet if touching here PWR_REG make loose the config
2357 int usbvision_restart_isoc(struct usb_usbvision
*usbvision
)
2363 usbvision_write_reg(usbvision
, USBVISION_PWR_REG
,
2364 USBVISION_SSPND_EN
| USBVISION_PWR_VID
)) < 0)
2368 usbvision_write_reg(usbvision
, USBVISION_PWR_REG
,
2369 USBVISION_SSPND_EN
| USBVISION_PWR_VID
|
2370 USBVISION_RES2
)) < 0)
2374 usbvision_write_reg(usbvision
, USBVISION_VIN_REG2
,
2375 USBVISION_KEEP_BLANK
| USBVISION_NOHVALID
|
2376 usbvision
->Vin_Reg2_Preset
)) < 0) return ret
;
2378 /* TODO: schedule timeout */
2379 while ((usbvision_read_reg(usbvision
, USBVISION_STATUS_REG
) & 0x01) != 1);
2384 int usbvision_audio_off(struct usb_usbvision
*usbvision
)
2386 if (usbvision_write_reg(usbvision
, USBVISION_IOPIN_REG
, USBVISION_AUDIO_MUTE
) < 0) {
2387 printk(KERN_ERR
"usbvision_audio_off: can't wirte reg\n");
2390 usbvision
->AudioMute
= 0;
2391 usbvision
->AudioChannel
= USBVISION_AUDIO_MUTE
;
2395 int usbvision_set_audio(struct usb_usbvision
*usbvision
, int AudioChannel
)
2397 if (!usbvision
->AudioMute
) {
2398 if (usbvision_write_reg(usbvision
, USBVISION_IOPIN_REG
, AudioChannel
) < 0) {
2399 printk(KERN_ERR
"usbvision_set_audio: can't write iopin register for audio switching\n");
2403 usbvision
->AudioChannel
= AudioChannel
;
2407 int usbvision_setup(struct usb_usbvision
*usbvision
,int format
)
2409 usbvision_set_video_format(usbvision
, format
);
2410 usbvision_set_dram_settings(usbvision
);
2411 usbvision_set_compress_params(usbvision
);
2412 usbvision_set_input(usbvision
);
2413 usbvision_set_output(usbvision
, MAX_USB_WIDTH
, MAX_USB_HEIGHT
);
2414 usbvision_restart_isoc(usbvision
);
2417 return USBVISION_IS_OPERATIONAL(usbvision
);
2420 int usbvision_set_alternate(struct usb_usbvision
*dev
)
2422 int errCode
, prev_alt
= dev
->ifaceAlt
;
2426 for(i
=0;i
< dev
->num_alt
; i
++)
2427 if(dev
->alt_max_pkt_size
[i
]>dev
->alt_max_pkt_size
[dev
->ifaceAlt
])
2430 if (dev
->ifaceAlt
!= prev_alt
) {
2431 dev
->isocPacketSize
= dev
->alt_max_pkt_size
[dev
->ifaceAlt
];
2432 PDEBUG(DBG_FUNC
,"setting alternate %d with wMaxPacketSize=%u", dev
->ifaceAlt
,dev
->isocPacketSize
);
2433 errCode
= usb_set_interface(dev
->dev
, dev
->iface
, dev
->ifaceAlt
);
2435 err ("cannot change alternate number to %d (error=%i)",
2436 dev
->ifaceAlt
, errCode
);
2441 PDEBUG(DBG_ISOC
, "ISO Packet Length:%d", dev
->isocPacketSize
);
2447 * usbvision_init_isoc()
2450 int usbvision_init_isoc(struct usb_usbvision
*usbvision
)
2452 struct usb_device
*dev
= usbvision
->dev
;
2453 int bufIdx
, errCode
, regValue
;
2456 if (!USBVISION_IS_OPERATIONAL(usbvision
))
2459 usbvision
->curFrame
= NULL
;
2460 scratch_reset(usbvision
);
2462 /* Alternate interface 1 is is the biggest frame size */
2463 errCode
= usbvision_set_alternate(usbvision
);
2465 usbvision
->last_error
= errCode
;
2468 sb_size
= USBVISION_URB_FRAMES
* usbvision
->isocPacketSize
;
2470 regValue
= (16 - usbvision_read_reg(usbvision
,
2471 USBVISION_ALTER_REG
)) & 0x0F;
2473 usbvision
->usb_bandwidth
= regValue
>> 1;
2474 PDEBUG(DBG_ISOC
, "USB Bandwidth Usage: %dMbit/Sec",
2475 usbvision
->usb_bandwidth
);
2479 /* We double buffer the Iso lists */
2481 for (bufIdx
= 0; bufIdx
< USBVISION_NUMSBUF
; bufIdx
++) {
2485 urb
= usb_alloc_urb(USBVISION_URB_FRAMES
, GFP_KERNEL
);
2487 err("%s: usb_alloc_urb() failed", __func__
);
2490 usbvision
->sbuf
[bufIdx
].urb
= urb
;
2491 usbvision
->sbuf
[bufIdx
].data
=
2492 usb_buffer_alloc(usbvision
->dev
,
2495 &urb
->transfer_dma
);
2497 urb
->context
= usbvision
;
2498 urb
->pipe
= usb_rcvisocpipe(dev
, usbvision
->video_endp
);
2499 urb
->transfer_flags
= URB_ISO_ASAP
;
2501 urb
->transfer_buffer
= usbvision
->sbuf
[bufIdx
].data
;
2502 urb
->complete
= usbvision_isocIrq
;
2503 urb
->number_of_packets
= USBVISION_URB_FRAMES
;
2504 urb
->transfer_buffer_length
=
2505 usbvision
->isocPacketSize
* USBVISION_URB_FRAMES
;
2506 for (j
= k
= 0; j
< USBVISION_URB_FRAMES
; j
++,
2507 k
+= usbvision
->isocPacketSize
) {
2508 urb
->iso_frame_desc
[j
].offset
= k
;
2509 urb
->iso_frame_desc
[j
].length
=
2510 usbvision
->isocPacketSize
;
2514 /* Submit all URBs */
2515 for (bufIdx
= 0; bufIdx
< USBVISION_NUMSBUF
; bufIdx
++) {
2516 errCode
= usb_submit_urb(usbvision
->sbuf
[bufIdx
].urb
,
2519 err("%s: usb_submit_urb(%d) failed: error %d",
2520 __func__
, bufIdx
, errCode
);
2524 usbvision
->streaming
= Stream_Idle
;
2525 PDEBUG(DBG_ISOC
, "%s: streaming=1 usbvision->video_endp=$%02x",
2527 usbvision
->video_endp
);
2532 * usbvision_stop_isoc()
2534 * This procedure stops streaming and deallocates URBs. Then it
2535 * activates zero-bandwidth alt. setting of the video interface.
2538 void usbvision_stop_isoc(struct usb_usbvision
*usbvision
)
2540 int bufIdx
, errCode
, regValue
;
2541 int sb_size
= USBVISION_URB_FRAMES
* usbvision
->isocPacketSize
;
2543 if ((usbvision
->streaming
== Stream_Off
) || (usbvision
->dev
== NULL
))
2546 /* Unschedule all of the iso td's */
2547 for (bufIdx
= 0; bufIdx
< USBVISION_NUMSBUF
; bufIdx
++) {
2548 usb_kill_urb(usbvision
->sbuf
[bufIdx
].urb
);
2549 if (usbvision
->sbuf
[bufIdx
].data
){
2550 usb_buffer_free(usbvision
->dev
,
2552 usbvision
->sbuf
[bufIdx
].data
,
2553 usbvision
->sbuf
[bufIdx
].urb
->transfer_dma
);
2555 usb_free_urb(usbvision
->sbuf
[bufIdx
].urb
);
2556 usbvision
->sbuf
[bufIdx
].urb
= NULL
;
2559 PDEBUG(DBG_ISOC
, "%s: streaming=Stream_Off\n", __func__
);
2560 usbvision
->streaming
= Stream_Off
;
2562 if (!usbvision
->remove_pending
) {
2564 /* Set packet size to 0 */
2565 usbvision
->ifaceAlt
=0;
2566 errCode
= usb_set_interface(usbvision
->dev
, usbvision
->iface
,
2567 usbvision
->ifaceAlt
);
2569 err("%s: usb_set_interface() failed: error %d",
2571 usbvision
->last_error
= errCode
;
2573 regValue
= (16-usbvision_read_reg(usbvision
, USBVISION_ALTER_REG
)) & 0x0F;
2574 usbvision
->isocPacketSize
=
2575 (regValue
== 0) ? 0 : (regValue
* 64) - 1;
2576 PDEBUG(DBG_ISOC
, "ISO Packet Length:%d",
2577 usbvision
->isocPacketSize
);
2579 usbvision
->usb_bandwidth
= regValue
>> 1;
2580 PDEBUG(DBG_ISOC
, "USB Bandwidth Usage: %dMbit/Sec",
2581 usbvision
->usb_bandwidth
);
2585 int usbvision_muxsel(struct usb_usbvision
*usbvision
, int channel
)
2587 /* inputs #0 and #3 are constant for every SAA711x. */
2588 /* inputs #1 and #2 are variable for SAA7111 and SAA7113 */
2589 int mode
[4]= {SAA7115_COMPOSITE0
, 0, 0, SAA7115_COMPOSITE3
};
2590 int audio
[]= {1, 0, 0, 0};
2591 struct v4l2_routing route
;
2592 //channel 0 is TV with audiochannel 1 (tuner mono)
2593 //channel 1 is Composite with audio channel 0 (line in)
2594 //channel 2 is S-Video with audio channel 0 (line in)
2595 //channel 3 is additional video inputs to the device with audio channel 0 (line in)
2597 RESTRICT_TO_RANGE(channel
, 0, usbvision
->video_inputs
);
2598 usbvision
->ctl_input
= channel
;
2600 // set the new channel
2601 // Regular USB TV Tuners -> channel: 0 = Television, 1 = Composite, 2 = S-Video
2602 // Four video input devices -> channel: 0 = Chan White, 1 = Chan Green, 2 = Chan Yellow, 3 = Chan Red
2604 switch (usbvision_device_data
[usbvision
->DevModel
].Codec
) {
2606 mode
[1] = SAA7115_COMPOSITE2
;
2607 if (SwitchSVideoInput
) {
2608 /* To handle problems with S-Video Input for
2609 * some devices. Use SwitchSVideoInput
2610 * parameter when loading the module.*/
2611 mode
[2] = SAA7115_COMPOSITE1
;
2614 mode
[2] = SAA7115_SVIDEO1
;
2619 /* modes for saa7111 */
2620 mode
[1] = SAA7115_COMPOSITE1
;
2621 mode
[2] = SAA7115_SVIDEO1
;
2624 route
.input
= mode
[channel
];
2626 call_i2c_clients(usbvision
, VIDIOC_INT_S_VIDEO_ROUTING
,&route
);
2627 usbvision_set_audio(usbvision
, audio
[channel
]);
2632 * Overrides for Emacs so that we follow Linus's tabbing style.
2633 * ---------------------------------------------------------------------------