[PATCH] USB: convert a bunch of USB semaphores to mutexes
[linux-3.10.git] / drivers / usb / media / vicam.c
1 /*
2  * USB ViCam WebCam driver
3  * Copyright (c) 2002 Joe Burks (jburks@wavicle.org),
4  *                    Christopher L Cheney (ccheney@cheney.cx),
5  *                    Pavel Machek (pavel@suse.cz),
6  *                    John Tyner (jtyner@cs.ucr.edu),
7  *                    Monroe Williams (monroe@pobox.com)
8  *
9  * Supports 3COM HomeConnect PC Digital WebCam
10  *
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.
15  *
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.
20  *
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.
24  *
25  * This source code is based heavily on the CPiA webcam driver which was
26  * written by Peter Pregler, Scott J. Bertin and Johannes Erdfelt
27  *
28  * Portions of this code were also copied from usbvideo.c
29  *
30  * Special thanks to the the whole team at Sourceforge for help making
31  * this driver become a reality.  Notably:
32  * Andy Armstrong who reverse engineered the color encoding and
33  * Pavel Machek and Chris Cheney who worked on reverse engineering the
34  *    camera controls and wrote the first generation driver.
35  */
36
37 #include <linux/kernel.h>
38 #include <linux/module.h>
39 #include <linux/init.h>
40 #include <linux/videodev.h>
41 #include <linux/usb.h>
42 #include <linux/vmalloc.h>
43 #include <linux/slab.h>
44 #include <linux/proc_fs.h>
45 #include <linux/mutex.h>
46 #include "usbvideo.h"
47
48 // #define VICAM_DEBUG
49
50 #ifdef VICAM_DEBUG
51 #define ADBG(lineno,fmt,args...) printk(fmt, jiffies, __FUNCTION__, lineno, ##args)
52 #define DBG(fmt,args...) ADBG((__LINE__),KERN_DEBUG __FILE__"(%ld):%s (%d):"fmt,##args)
53 #else
54 #define DBG(fmn,args...) do {} while(0)
55 #endif
56
57 #define DRIVER_AUTHOR           "Joe Burks, jburks@wavicle.org"
58 #define DRIVER_DESC             "ViCam WebCam Driver"
59
60 /* Define these values to match your device */
61 #define USB_VICAM_VENDOR_ID     0x04c1
62 #define USB_VICAM_PRODUCT_ID    0x009d
63
64 #define VICAM_BYTES_PER_PIXEL   3
65 #define VICAM_MAX_READ_SIZE     (512*242+128)
66 #define VICAM_MAX_FRAME_SIZE    (VICAM_BYTES_PER_PIXEL*320*240)
67 #define VICAM_FRAMES            2
68
69 #define VICAM_HEADER_SIZE       64
70
71 #define clamp( x, l, h )        max_t( __typeof__( x ),         \
72                                        ( l ),                   \
73                                        min_t( __typeof__( x ),  \
74                                               ( h ),            \
75                                               ( x ) ) )
76
77 /* Not sure what all the bytes in these char
78  * arrays do, but they're necessary to make
79  * the camera work.
80  */
81
82 static unsigned char setup1[] = {
83         0xB6, 0xC3, 0x1F, 0x00, 0x02, 0x64, 0xE7, 0x67,
84         0xFD, 0xFF, 0x0E, 0xC0, 0xE7, 0x09, 0xDE, 0x00,
85         0x8E, 0x00, 0xC0, 0x09, 0x40, 0x03, 0xC0, 0x17,
86         0x44, 0x03, 0x4B, 0xAF, 0xC0, 0x07, 0x00, 0x00,
87         0x4B, 0xAF, 0x97, 0xCF, 0x00, 0x00
88 };
89
90 static unsigned char setup2[] = {
91         0xB6, 0xC3, 0x03, 0x00, 0x03, 0x64, 0x18, 0x00,
92         0x00, 0x00
93 };
94
95 static unsigned char setup3[] = {
96         0xB6, 0xC3, 0x01, 0x00, 0x06, 0x64, 0x00, 0x00
97 };
98
99 static unsigned char setup4[] = {
100         0xB6, 0xC3, 0x8F, 0x06, 0x02, 0x64, 0xE7, 0x07,
101         0x00, 0x00, 0x08, 0xC0, 0xE7, 0x07, 0x00, 0x00,
102         0x3E, 0xC0, 0xE7, 0x07, 0x54, 0x01, 0xAA, 0x00,
103         0xE7, 0x07, 0xC8, 0x05, 0xB6, 0x00, 0xE7, 0x07,
104         0x42, 0x01, 0xD2, 0x00, 0xE7, 0x07, 0x7C, 0x00,
105         0x16, 0x00, 0xE7, 0x07, 0x56, 0x00, 0x18, 0x00,
106         0xE7, 0x07, 0x06, 0x00, 0x92, 0xC0, 0xE7, 0x07,
107         0x00, 0x00, 0x1E, 0xC0, 0xE7, 0x07, 0xFF, 0xFF,
108         0x22, 0xC0, 0xE7, 0x07, 0x04, 0x00, 0x24, 0xC0,
109         0xE7, 0x07, 0xEC, 0x27, 0x28, 0xC0, 0xE7, 0x07,
110         0x16, 0x01, 0x8E, 0x00, 0xE7, 0x87, 0x01, 0x00,
111         0x0E, 0xC0, 0x97, 0xCF, 0xD7, 0x09, 0x00, 0xC0,
112         0xE7, 0x77, 0x01, 0x00, 0x92, 0xC0, 0x09, 0xC1,
113         0xE7, 0x09, 0xFE, 0x05, 0x24, 0x01, 0xE7, 0x09,
114         0x04, 0x06, 0x26, 0x01, 0xE7, 0x07, 0x07, 0x00,
115         0x92, 0xC0, 0xE7, 0x05, 0x00, 0xC0, 0xC0, 0xDF,
116         0x97, 0xCF, 0x17, 0x00, 0x57, 0x00, 0x17, 0x02,
117         0xD7, 0x09, 0x00, 0xC0, 0xE7, 0x77, 0x01, 0x00,
118         0x92, 0xC0, 0x0A, 0xC1, 0xE7, 0x57, 0xFF, 0xFF,
119         0xFA, 0x05, 0x0D, 0xC0, 0xE7, 0x57, 0x00, 0x00,
120         0xFA, 0x05, 0x0F, 0xC0, 0x9F, 0xAF, 0xC6, 0x00,
121         0xE7, 0x05, 0x00, 0xC0, 0xC8, 0x05, 0xC1, 0x05,
122         0xC0, 0x05, 0xC0, 0xDF, 0x97, 0xCF, 0x27, 0xDA,
123         0xFA, 0x05, 0xEF, 0x07, 0x01, 0x00, 0x0B, 0x06,
124         0x73, 0xCF, 0x9F, 0xAF, 0x78, 0x01, 0x9F, 0xAF,
125         0x1A, 0x03, 0x6E, 0xCF, 0xE7, 0x09, 0xFC, 0x05,
126         0x24, 0x01, 0xE7, 0x09, 0x02, 0x06, 0x26, 0x01,
127         0xE7, 0x07, 0x07, 0x00, 0x92, 0xC0, 0xE7, 0x09,
128         0xFC, 0x05, 0xFE, 0x05, 0xE7, 0x09, 0x02, 0x06,
129         0x04, 0x06, 0xE7, 0x09, 0x00, 0x06, 0xFC, 0x05,
130         0xE7, 0x09, 0xFE, 0x05, 0x00, 0x06, 0x27, 0xDA,
131         0xFA, 0x05, 0xE7, 0x57, 0x01, 0x00, 0xFA, 0x05,
132         0x02, 0xCA, 0x04, 0xC0, 0x97, 0xCF, 0x9F, 0xAF,
133         0x66, 0x05, 0x97, 0xCF, 0xE7, 0x07, 0x40, 0x00,
134         0x02, 0x06, 0xC8, 0x09, 0xFC, 0x05, 0x9F, 0xAF,
135         0xDA, 0x02, 0x97, 0xCF, 0xCF, 0x17, 0x02, 0x00,
136         0xEF, 0x57, 0x81, 0x00, 0x09, 0x06, 0x9F, 0xA0,
137         0xB6, 0x01, 0xEF, 0x57, 0x80, 0x00, 0x09, 0x06,
138         0x9F, 0xA0, 0x40, 0x02, 0xEF, 0x57, 0x01, 0x00,
139         0x0B, 0x06, 0x9F, 0xA0, 0x46, 0x03, 0xE7, 0x07,
140         0x01, 0x00, 0x0A, 0xC0, 0x46, 0xAF, 0x47, 0xAF,
141         0x9F, 0xAF, 0x40, 0x02, 0xE7, 0x07, 0x2E, 0x00,
142         0x0A, 0xC0, 0xEF, 0x87, 0x80, 0x00, 0x09, 0x06,
143         0x97, 0xCF, 0x00, 0x0E, 0x01, 0x00, 0xC0, 0x57,
144         0x51, 0x00, 0x9F, 0xC0, 0x9E, 0x02, 0xC0, 0x57,
145         0x50, 0x00, 0x20, 0xC0, 0xC0, 0x57, 0x55, 0x00,
146         0x12, 0xC0, 0xC0, 0x57, 0x56, 0x00, 0x9F, 0xC0,
147         0x72, 0x02, 0x9F, 0xCF, 0xD6, 0x02, 0xC1, 0x0B,
148         0x08, 0x06, 0x01, 0xD0, 0x6F, 0x90, 0x08, 0x06,
149         0xC0, 0x07, 0x08, 0x00, 0xC1, 0x0B, 0x08, 0x06,
150         0x9F, 0xAF, 0x28, 0x05, 0x97, 0xCF, 0x2F, 0x0E,
151         0x02, 0x00, 0x08, 0x06, 0xC0, 0x07, 0x08, 0x00,
152         0xC1, 0x0B, 0x08, 0x06, 0x9F, 0xAF, 0x28, 0x05,
153         0x9F, 0xCF, 0xD6, 0x02, 0x2F, 0x0E, 0x02, 0x00,
154         0x09, 0x06, 0xEF, 0x87, 0x80, 0x00, 0x09, 0x06,
155         0x9F, 0xCF, 0xD6, 0x02, 0xEF, 0x67, 0x7F, 0xFF,
156         0x09, 0x06, 0xE7, 0x67, 0xFF, 0xFD, 0x22, 0xC0,
157         0xE7, 0x67, 0xEF, 0xFF, 0x24, 0xC0, 0xE7, 0x87,
158         0x10, 0x00, 0x28, 0xC0, 0x9F, 0xAF, 0xB8, 0x05,
159         0xE7, 0x87, 0xE0, 0x21, 0x24, 0xC0, 0x9F, 0xAF,
160         0xA8, 0x05, 0xE7, 0x87, 0x08, 0x00, 0x24, 0xC0,
161         0xE7, 0x67, 0xDF, 0xFF, 0x24, 0xC0, 0xC8, 0x07,
162         0x0A, 0x00, 0xC0, 0x07, 0x00, 0x00, 0xC1, 0x07,
163         0x01, 0x00, 0x9F, 0xAF, 0x28, 0x05, 0x9F, 0xAF,
164         0xB8, 0x05, 0xC0, 0x07, 0x9E, 0x00, 0x9F, 0xAF,
165         0x44, 0x05, 0xE7, 0x67, 0xFF, 0xFE, 0x24, 0xC0,
166         0xC0, 0x09, 0x20, 0xC0, 0xE7, 0x87, 0x00, 0x01,
167         0x24, 0xC0, 0xC0, 0x77, 0x00, 0x02, 0x0F, 0xC1,
168         0xE7, 0x67, 0xF7, 0xFF, 0x24, 0xC0, 0xE7, 0x67,
169         0xF7, 0xFF, 0x24, 0xC0, 0xE7, 0x87, 0x08, 0x00,
170         0x24, 0xC0, 0x08, 0xDA, 0x5E, 0xC1, 0xEF, 0x07,
171         0x80, 0x00, 0x09, 0x06, 0x97, 0xCF, 0xEF, 0x07,
172         0x01, 0x00, 0x0A, 0x06, 0x97, 0xCF, 0xEF, 0x07,
173         0x00, 0x00, 0x0B, 0x06, 0xEF, 0x07, 0x00, 0x00,
174         0x0A, 0x06, 0xEF, 0x67, 0x7F, 0xFF, 0x09, 0x06,
175         0xEF, 0x07, 0x00, 0x00, 0x0D, 0x06, 0xE7, 0x67,
176         0xEF, 0xFF, 0x28, 0xC0, 0xE7, 0x67, 0x17, 0xD8,
177         0x24, 0xC0, 0xE7, 0x07, 0x00, 0x00, 0x1E, 0xC0,
178         0xE7, 0x07, 0xFF, 0xFF, 0x22, 0xC0, 0x97, 0xCF,
179         0xC8, 0x07, 0x0E, 0x06, 0x9F, 0xAF, 0xDA, 0x02,
180         0xE7, 0x07, 0x00, 0x00, 0xF2, 0x05, 0xE7, 0x07,
181         0x10, 0x00, 0xF6, 0x05, 0xE7, 0x07, 0x0E, 0x06,
182         0xF4, 0x05, 0xE7, 0x07, 0xD6, 0x02, 0xF8, 0x05,
183         0xC8, 0x07, 0xF2, 0x05, 0xC1, 0x07, 0x00, 0x80,
184         0x50, 0xAF, 0x97, 0xCF, 0x2F, 0x0C, 0x02, 0x00,
185         0x07, 0x06, 0x2F, 0x0C, 0x04, 0x00, 0x06, 0x06,
186         0xE7, 0x07, 0x00, 0x00, 0xF2, 0x05, 0xE7, 0x07,
187         0x10, 0x00, 0xF6, 0x05, 0xE7, 0x07, 0xE2, 0x05,
188         0xF4, 0x05, 0xE7, 0x07, 0xCE, 0x02, 0xF8, 0x05,
189         0xC8, 0x07, 0xF2, 0x05, 0xC1, 0x07, 0x00, 0x80,
190         0x51, 0xAF, 0x97, 0xCF, 0x9F, 0xAF, 0x66, 0x04,
191         0x9F, 0xAF, 0x1A, 0x03, 0x59, 0xAF, 0x97, 0xCF,
192         0xC0, 0x07, 0x0E, 0x00, 0xC1, 0x0B, 0x0C, 0x06,
193         0x41, 0xD1, 0x9F, 0xAF, 0x28, 0x05, 0xC0, 0x07,
194         0x3C, 0x00, 0x9F, 0xAF, 0x44, 0x05, 0x68, 0x00,
195         0xC0, 0x07, 0x3B, 0x00, 0x9F, 0xAF, 0x44, 0x05,
196         0x6F, 0x00, 0x0C, 0x06, 0x68, 0x00, 0xE0, 0x07,
197         0x04, 0x01, 0xE8, 0x0B, 0x0A, 0x06, 0xE8, 0x07,
198         0x00, 0x00, 0xE0, 0x07, 0x00, 0x02, 0xE0, 0x07,
199         0xEC, 0x01, 0xE0, 0x07, 0xFC, 0xFF, 0x97, 0xCF,
200         0xE7, 0x07, 0xFF, 0xFF, 0xFA, 0x05, 0xEF, 0x07,
201         0x00, 0x00, 0x0B, 0x06, 0xE7, 0x07, 0x0E, 0x06,
202         0x24, 0x01, 0xE7, 0x07, 0x0E, 0x06, 0xFE, 0x05,
203         0xE7, 0x07, 0x40, 0x00, 0x26, 0x01, 0xE7, 0x07,
204         0x40, 0x00, 0x04, 0x06, 0xE7, 0x07, 0x07, 0x00,
205         0x92, 0xC0, 0x97, 0xCF, 0xEF, 0x07, 0x02, 0x00,
206         0x0B, 0x06, 0x9F, 0xAF, 0x78, 0x01, 0xEF, 0x77,
207         0x80, 0x00, 0x07, 0x06, 0x9F, 0xC0, 0x14, 0x04,
208         0xEF, 0x77, 0x01, 0x00, 0x07, 0x06, 0x37, 0xC0,
209         0xEF, 0x77, 0x01, 0x00, 0x0D, 0x06, 0x0F, 0xC1,
210         0xEF, 0x07, 0x01, 0x00, 0x0D, 0x06, 0xC0, 0x07,
211         0x02, 0x00, 0xC1, 0x07, 0x30, 0x00, 0x9F, 0xAF,
212         0x28, 0x05, 0xC0, 0x07, 0x01, 0x00, 0xC1, 0x07,
213         0x02, 0x00, 0x9F, 0xAF, 0x28, 0x05, 0xC8, 0x07,
214         0xFF, 0x4F, 0x9F, 0xAF, 0xA8, 0x05, 0xC0, 0x07,
215         0x38, 0x00, 0x9F, 0xAF, 0x44, 0x05, 0xC1, 0x77,
216         0x03, 0x00, 0x02, 0xC1, 0x08, 0xDA, 0x75, 0xC1,
217         0xC1, 0x77, 0x01, 0x00, 0x0A, 0xC1, 0xC0, 0x07,
218         0x01, 0x00, 0xC1, 0x07, 0x02, 0x00, 0x9F, 0xAF,
219         0x28, 0x05, 0xEF, 0x07, 0x01, 0x00, 0x06, 0x06,
220         0x2C, 0xCF, 0xC0, 0x07, 0x01, 0x00, 0xC1, 0x07,
221         0x04, 0x00, 0x9F, 0xAF, 0x28, 0x05, 0xEF, 0x07,
222         0x00, 0x00, 0x06, 0x06, 0x22, 0xCF, 0xEF, 0x07,
223         0x00, 0x00, 0x0D, 0x06, 0xEF, 0x57, 0x01, 0x00,
224         0x06, 0x06, 0x1B, 0xC0, 0xC0, 0x07, 0x01, 0x00,
225         0xC1, 0x07, 0x01, 0x00, 0x9F, 0xAF, 0x28, 0x05,
226         0xC0, 0x07, 0x02, 0x00, 0xC1, 0x07, 0x30, 0x00,
227         0x9F, 0xAF, 0x28, 0x05, 0xC8, 0x07, 0xFF, 0x4F,
228         0x9F, 0xAF, 0xA8, 0x05, 0xC0, 0x07, 0x38, 0x00,
229         0x9F, 0xAF, 0x44, 0x05, 0xC1, 0x67, 0x03, 0x00,
230         0xC1, 0x57, 0x03, 0x00, 0x02, 0xC0, 0x08, 0xDA,
231         0x73, 0xC1, 0xC0, 0x07, 0x02, 0x00, 0xC1, 0x07,
232         0x12, 0x00, 0xEF, 0x57, 0x00, 0x00, 0x06, 0x06,
233         0x02, 0xC0, 0xC1, 0x07, 0x23, 0x00, 0x9F, 0xAF,
234         0x28, 0x05, 0xC0, 0x07, 0x14, 0x00, 0xC1, 0x0B,
235         0xEA, 0x05, 0x9F, 0xAF, 0x28, 0x05, 0xC0, 0x07,
236         0x3E, 0x00, 0x9F, 0xAF, 0x0A, 0x05, 0xE7, 0x09,
237         0xE4, 0x05, 0xFA, 0x05, 0x27, 0xD8, 0xFA, 0x05,
238         0xE7, 0x07, 0x0E, 0x06, 0xFC, 0x05, 0xE7, 0x07,
239         0x4E, 0x06, 0x00, 0x06, 0xE7, 0x07, 0x40, 0x00,
240         0x02, 0x06, 0x9F, 0xAF, 0x66, 0x05, 0x9F, 0xAF,
241         0xC6, 0x00, 0x97, 0xCF, 0xC1, 0x0B, 0xE2, 0x05,
242         0x41, 0xD0, 0x01, 0xD2, 0xC1, 0x17, 0x23, 0x00,
243         0x9F, 0xAF, 0xDC, 0x04, 0xC0, 0x07, 0x04, 0x00,
244         0xC1, 0x0B, 0xE3, 0x05, 0x9F, 0xAF, 0x28, 0x05,
245         0xC0, 0x07, 0x06, 0x00, 0xC1, 0x09, 0xE6, 0x05,
246         0x9F, 0xAF, 0x28, 0x05, 0xC0, 0x07, 0x07, 0x00,
247         0xC1, 0x09, 0xE6, 0x05, 0xC1, 0xD1, 0x9F, 0xAF,
248         0x28, 0x05, 0xC0, 0x07, 0x0B, 0x00, 0xC1, 0x09,
249         0xE8, 0x05, 0x9F, 0xAF, 0x28, 0x05, 0xC0, 0x07,
250         0x0C, 0x00, 0xC1, 0x09, 0xE8, 0x05, 0xC1, 0xD1,
251         0x9F, 0xAF, 0x28, 0x05, 0xC0, 0x07, 0x0D, 0x00,
252         0xC1, 0x07, 0x09, 0x00, 0x9F, 0xAF, 0x28, 0x05,
253         0xC0, 0x07, 0x03, 0x00, 0xC1, 0x07, 0x32, 0x00,
254         0x9F, 0xAF, 0x28, 0x05, 0xC0, 0x07, 0x0F, 0x00,
255         0xC1, 0x07, 0x00, 0x00, 0x9F, 0xAF, 0x28, 0x05,
256         0x97, 0xCF, 0xE7, 0x67, 0xFF, 0xD9, 0x24, 0xC0,
257         0xC8, 0x07, 0x0A, 0x00, 0x40, 0x00, 0xC0, 0x67,
258         0x00, 0x02, 0x27, 0x80, 0x24, 0xC0, 0xE7, 0x87,
259         0x00, 0x04, 0x24, 0xC0, 0xE7, 0x67, 0xFF, 0xF9,
260         0x24, 0xC0, 0x01, 0xD2, 0x08, 0xDA, 0x72, 0xC1,
261         0xE7, 0x87, 0x00, 0x20, 0x24, 0xC0, 0x97, 0xCF,
262         0x27, 0x00, 0x1E, 0xC0, 0xE7, 0x87, 0xFF, 0x00,
263         0x22, 0xC0, 0xE7, 0x67, 0x7F, 0xFF, 0x24, 0xC0,
264         0xE7, 0x87, 0x80, 0x00, 0x24, 0xC0, 0xE7, 0x87,
265         0x80, 0x00, 0x24, 0xC0, 0x97, 0xCF, 0x9F, 0xAF,
266         0x0A, 0x05, 0x67, 0x00, 0x1E, 0xC0, 0xE7, 0x67,
267         0xBF, 0xFF, 0x24, 0xC0, 0xE7, 0x87, 0x40, 0x00,
268         0x24, 0xC0, 0xE7, 0x87, 0x40, 0x00, 0x24, 0xC0,
269         0x97, 0xCF, 0x9F, 0xAF, 0x0A, 0x05, 0xE7, 0x67,
270         0x00, 0xFF, 0x22, 0xC0, 0xE7, 0x67, 0xFF, 0xFE,
271         0x24, 0xC0, 0xE7, 0x67, 0xFF, 0xFE, 0x24, 0xC0,
272         0xC1, 0x09, 0x20, 0xC0, 0xE7, 0x87, 0x00, 0x01,
273         0x24, 0xC0, 0x97, 0xCF, 0xC0, 0x07, 0x40, 0x00,
274         0xC8, 0x09, 0xFC, 0x05, 0xE7, 0x67, 0x00, 0xFF,
275         0x22, 0xC0, 0xE7, 0x67, 0xFF, 0xFE, 0x24, 0xC0,
276         0xE7, 0x67, 0xBF, 0xFF, 0x24, 0xC0, 0xE7, 0x67,
277         0xBF, 0xFF, 0x24, 0xC0, 0x00, 0xDA, 0xE8, 0x09,
278         0x20, 0xC0, 0xE7, 0x87, 0x40, 0x00, 0x24, 0xC0,
279         0xE7, 0x87, 0x40, 0x00, 0x24, 0xC0, 0x00, 0xDA,
280         0xE8, 0x09, 0x20, 0xC0, 0x6D, 0xC1, 0xE7, 0x87,
281         0x00, 0x01, 0x24, 0xC0, 0x97, 0xCF, 0xE7, 0x07,
282         0x32, 0x00, 0x12, 0xC0, 0xE7, 0x77, 0x00, 0x80,
283         0x12, 0xC0, 0x7C, 0xC0, 0x97, 0xCF, 0xE7, 0x07,
284         0x20, 0x4E, 0x12, 0xC0, 0xE7, 0x77, 0x00, 0x80,
285         0x12, 0xC0, 0x7C, 0xC0, 0x97, 0xCF, 0x09, 0x02,
286         0x19, 0x00, 0x01, 0x01, 0x00, 0x80, 0x96, 0x09,
287         0x04, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
288         0x07, 0x05, 0x81, 0x02, 0x40, 0x00, 0x00, 0x00,
289         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
290         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
291         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
292         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
293         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
294         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
295         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
296         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
297         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
298         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
299         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
300         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
301         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
302         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
303         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
304         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
305         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
306         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
307         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
308         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
309         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
310         0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
311 };
312
313 static unsigned char setup5[] = {
314         0xB6, 0xC3, 0x2F, 0x01, 0x03, 0x64, 0x0E, 0x00,
315         0x14, 0x00, 0x1A, 0x00, 0x20, 0x00, 0x26, 0x00,
316         0x4A, 0x00, 0x64, 0x00, 0x6A, 0x00, 0x92, 0x00,
317         0x9A, 0x00, 0xA0, 0x00, 0xB2, 0x00, 0xB8, 0x00,
318         0xBE, 0x00, 0xC2, 0x00, 0xC8, 0x00, 0xCE, 0x00,
319         0xDC, 0x00, 0xDA, 0x00, 0xE2, 0x00, 0xE0, 0x00,
320         0xE8, 0x00, 0xE6, 0x00, 0xEE, 0x00, 0xEC, 0x00,
321         0xF2, 0x00, 0xF8, 0x00, 0x02, 0x01, 0x0A, 0x01,
322         0x0E, 0x01, 0x12, 0x01, 0x1E, 0x01, 0x22, 0x01,
323         0x28, 0x01, 0x2C, 0x01, 0x32, 0x01, 0x36, 0x01,
324         0x44, 0x01, 0x50, 0x01, 0x5E, 0x01, 0x72, 0x01,
325         0x76, 0x01, 0x7A, 0x01, 0x80, 0x01, 0x88, 0x01,
326         0x8C, 0x01, 0x94, 0x01, 0x9C, 0x01, 0xA0, 0x01,
327         0xA4, 0x01, 0xAA, 0x01, 0xB0, 0x01, 0xB4, 0x01,
328         0xBA, 0x01, 0xD0, 0x01, 0xDA, 0x01, 0xF6, 0x01,
329         0xFA, 0x01, 0x02, 0x02, 0x34, 0x02, 0x3C, 0x02,
330         0x44, 0x02, 0x4A, 0x02, 0x50, 0x02, 0x56, 0x02,
331         0x74, 0x02, 0x78, 0x02, 0x7E, 0x02, 0x84, 0x02,
332         0x8A, 0x02, 0x88, 0x02, 0x90, 0x02, 0x8E, 0x02,
333         0x94, 0x02, 0xA2, 0x02, 0xA8, 0x02, 0xAE, 0x02,
334         0xB4, 0x02, 0xBA, 0x02, 0xB8, 0x02, 0xC0, 0x02,
335         0xBE, 0x02, 0xC4, 0x02, 0xD0, 0x02, 0xD4, 0x02,
336         0xE0, 0x02, 0xE6, 0x02, 0xEE, 0x02, 0xF8, 0x02,
337         0xFC, 0x02, 0x06, 0x03, 0x1E, 0x03, 0x24, 0x03,
338         0x28, 0x03, 0x30, 0x03, 0x2E, 0x03, 0x3C, 0x03,
339         0x4A, 0x03, 0x4E, 0x03, 0x54, 0x03, 0x58, 0x03,
340         0x5E, 0x03, 0x66, 0x03, 0x6E, 0x03, 0x7A, 0x03,
341         0x86, 0x03, 0x8E, 0x03, 0x96, 0x03, 0xB2, 0x03,
342         0xB8, 0x03, 0xC6, 0x03, 0xCC, 0x03, 0xD4, 0x03,
343         0xDA, 0x03, 0xE8, 0x03, 0xF4, 0x03, 0xFC, 0x03,
344         0x04, 0x04, 0x20, 0x04, 0x2A, 0x04, 0x32, 0x04,
345         0x36, 0x04, 0x3E, 0x04, 0x44, 0x04, 0x42, 0x04,
346         0x48, 0x04, 0x4E, 0x04, 0x4C, 0x04, 0x54, 0x04,
347         0x52, 0x04, 0x5A, 0x04, 0x5E, 0x04, 0x62, 0x04,
348         0x68, 0x04, 0x74, 0x04, 0x7C, 0x04, 0x80, 0x04,
349         0x88, 0x04, 0x8C, 0x04, 0x94, 0x04, 0x9A, 0x04,
350         0xA2, 0x04, 0xA6, 0x04, 0xAE, 0x04, 0xB4, 0x04,
351         0xC0, 0x04, 0xCC, 0x04, 0xD8, 0x04, 0x2A, 0x05,
352         0x46, 0x05, 0x6C, 0x05, 0x00, 0x00
353 };
354
355 /* rvmalloc / rvfree copied from usbvideo.c
356  *
357  * Not sure why these are not yet non-statics which I can reference through
358  * usbvideo.h the same as it is in 2.4.20.  I bet this will get fixed sometime
359  * in the future.
360  * 
361 */
362 static void *rvmalloc(unsigned long size)
363 {
364         void *mem;
365         unsigned long adr;
366
367         size = PAGE_ALIGN(size);
368         mem = vmalloc_32(size);
369         if (!mem)
370                 return NULL;
371
372         memset(mem, 0, size); /* Clear the ram out, no junk to the user */
373         adr = (unsigned long) mem;
374         while (size > 0) {
375                 SetPageReserved(vmalloc_to_page((void *)adr));
376                 adr += PAGE_SIZE;
377                 size -= PAGE_SIZE;
378         }
379
380         return mem;
381 }
382
383 static void rvfree(void *mem, unsigned long size)
384 {
385         unsigned long adr;
386
387         if (!mem)
388                 return;
389
390         adr = (unsigned long) mem;
391         while ((long) size > 0) {
392                 ClearPageReserved(vmalloc_to_page((void *)adr));
393                 adr += PAGE_SIZE;
394                 size -= PAGE_SIZE;
395         }
396         vfree(mem);
397 }
398
399 struct vicam_camera {
400         u16 shutter_speed;      // capture shutter speed
401         u16 gain;               // capture gain
402
403         u8 *raw_image;          // raw data captured from the camera
404         u8 *framebuf;           // processed data in RGB24 format
405         u8 *cntrlbuf;           // area used to send control msgs
406
407         struct video_device vdev;       // v4l video device
408         struct usb_device *udev;        // usb device
409
410         /* guard against simultaneous accesses to the camera */
411         struct mutex cam_lock;
412
413         int is_initialized;
414         u8 open_count;
415         u8 bulkEndpoint;
416         int needsDummyRead;
417
418 #if defined(CONFIG_VIDEO_PROC_FS)
419         struct proc_dir_entry *proc_dir;
420 #endif
421
422 };
423
424 static int vicam_probe( struct usb_interface *intf, const struct usb_device_id *id);
425 static void vicam_disconnect(struct usb_interface *intf);
426 static void read_frame(struct vicam_camera *cam, int framenum);
427 static void vicam_decode_color(const u8 *, u8 *);
428
429 static int __send_control_msg(struct vicam_camera *cam,
430                               u8 request,
431                               u16 value,
432                               u16 index,
433                               unsigned char *cp,
434                               u16 size)
435 {
436         int status;
437
438         /* cp must be memory that has been allocated by kmalloc */
439
440         status = usb_control_msg(cam->udev,
441                                  usb_sndctrlpipe(cam->udev, 0),
442                                  request,
443                                  USB_DIR_OUT | USB_TYPE_VENDOR |
444                                  USB_RECIP_DEVICE, value, index,
445                                  cp, size, 1000);
446
447         status = min(status, 0);
448
449         if (status < 0) {
450                 printk(KERN_INFO "Failed sending control message, error %d.\n",
451                        status);
452         }
453
454         return status;
455 }
456
457 static int send_control_msg(struct vicam_camera *cam,
458                             u8 request,
459                             u16 value,
460                             u16 index,
461                             unsigned char *cp,
462                             u16 size)
463 {
464         int status = -ENODEV;
465         mutex_lock(&cam->cam_lock);
466         if (cam->udev) {
467                 status = __send_control_msg(cam, request, value,
468                                             index, cp, size);
469         }
470         mutex_unlock(&cam->cam_lock);
471         return status;
472 }
473 static int
474 initialize_camera(struct vicam_camera *cam)
475 {
476         const struct {
477                 u8 *data;
478                 u32 size;
479         } firmware[] = {
480                 { .data = setup1, .size = sizeof(setup1) },
481                 { .data = setup2, .size = sizeof(setup2) },
482                 { .data = setup3, .size = sizeof(setup3) },
483                 { .data = setup4, .size = sizeof(setup4) },
484                 { .data = setup5, .size = sizeof(setup5) },
485                 { .data = setup3, .size = sizeof(setup3) },
486                 { .data = NULL, .size = 0 }
487         };
488
489         int err, i;
490
491         for (i = 0, err = 0; firmware[i].data && !err; i++) {
492                 memcpy(cam->cntrlbuf, firmware[i].data, firmware[i].size);
493
494                 err = send_control_msg(cam, 0xff, 0, 0,
495                                        cam->cntrlbuf, firmware[i].size);
496         }
497
498         return err;
499 }
500
501 static int
502 set_camera_power(struct vicam_camera *cam, int state)
503 {
504         int status;
505
506         if ((status = send_control_msg(cam, 0x50, state, 0, NULL, 0)) < 0)
507                 return status;
508
509         if (state) {
510                 send_control_msg(cam, 0x55, 1, 0, NULL, 0);
511         }
512
513         return 0;
514 }
515
516 static int
517 vicam_ioctl(struct inode *inode, struct file *file, unsigned int ioctlnr, unsigned long arg)
518 {
519         void __user *user_arg = (void __user *)arg;
520         struct vicam_camera *cam = file->private_data;
521         int retval = 0;
522
523         if (!cam)
524                 return -ENODEV;
525
526         switch (ioctlnr) {
527                 /* query capabilities */
528         case VIDIOCGCAP:
529                 {
530                         struct video_capability b;
531
532                         DBG("VIDIOCGCAP\n");
533                         memset(&b, 0, sizeof(b));
534                         strcpy(b.name, "ViCam-based Camera");
535                         b.type = VID_TYPE_CAPTURE;
536                         b.channels = 1;
537                         b.audios = 0;
538                         b.maxwidth = 320;       /* VIDEOSIZE_CIF */
539                         b.maxheight = 240;
540                         b.minwidth = 320;       /* VIDEOSIZE_48_48 */
541                         b.minheight = 240;
542
543                         if (copy_to_user(user_arg, &b, sizeof(b)))
544                                 retval = -EFAULT;
545
546                         break;
547                 }
548                 /* get/set video source - we are a camera and nothing else */
549         case VIDIOCGCHAN:
550                 {
551                         struct video_channel v;
552
553                         DBG("VIDIOCGCHAN\n");
554                         if (copy_from_user(&v, user_arg, sizeof(v))) {
555                                 retval = -EFAULT;
556                                 break;
557                         }
558                         if (v.channel != 0) {
559                                 retval = -EINVAL;
560                                 break;
561                         }
562
563                         v.channel = 0;
564                         strcpy(v.name, "Camera");
565                         v.tuners = 0;
566                         v.flags = 0;
567                         v.type = VIDEO_TYPE_CAMERA;
568                         v.norm = 0;
569
570                         if (copy_to_user(user_arg, &v, sizeof(v)))
571                                 retval = -EFAULT;
572                         break;
573                 }
574
575         case VIDIOCSCHAN:
576                 {
577                         int v;
578
579                         if (copy_from_user(&v, user_arg, sizeof(v)))
580                                 retval = -EFAULT;
581                         DBG("VIDIOCSCHAN %d\n", v);
582
583                         if (retval == 0 && v != 0)
584                                 retval = -EINVAL;
585
586                         break;
587                 }
588
589                 /* image properties */
590         case VIDIOCGPICT:
591                 {
592                         struct video_picture vp;
593                         DBG("VIDIOCGPICT\n");
594                         memset(&vp, 0, sizeof (struct video_picture));
595                         vp.brightness = cam->gain << 8;
596                         vp.depth = 24;
597                         vp.palette = VIDEO_PALETTE_RGB24;
598                         if (copy_to_user(user_arg, &vp, sizeof (struct video_picture)))
599                                 retval = -EFAULT;
600                         break;
601                 }
602
603         case VIDIOCSPICT:
604                 {
605                         struct video_picture vp;
606                         
607                         if (copy_from_user(&vp, user_arg, sizeof(vp))) {
608                                 retval = -EFAULT;
609                                 break;
610                         }
611                         
612                         DBG("VIDIOCSPICT depth = %d, pal = %d\n", vp.depth,
613                             vp.palette);
614
615                         cam->gain = vp.brightness >> 8;
616
617                         if (vp.depth != 24
618                             || vp.palette != VIDEO_PALETTE_RGB24)
619                                 retval = -EINVAL;
620
621                         break;
622                 }
623
624                 /* get/set capture window */
625         case VIDIOCGWIN:
626                 {
627                         struct video_window vw;
628                         vw.x = 0;
629                         vw.y = 0;
630                         vw.width = 320;
631                         vw.height = 240;
632                         vw.chromakey = 0;
633                         vw.flags = 0;
634                         vw.clips = NULL;
635                         vw.clipcount = 0;
636
637                         DBG("VIDIOCGWIN\n");
638
639                         if (copy_to_user(user_arg, (void *)&vw, sizeof(vw)))
640                                 retval = -EFAULT;
641
642                         // I'm not sure what the deal with a capture window is, it is very poorly described
643                         // in the doc.  So I won't support it now.
644                         break;
645                 }
646
647         case VIDIOCSWIN:
648                 {
649
650                         struct video_window vw;
651
652                         if (copy_from_user(&vw, user_arg, sizeof(vw))) {
653                                 retval = -EFAULT;
654                                 break;
655                         }
656
657                         DBG("VIDIOCSWIN %d x %d\n", vw.width, vw.height);
658                         
659                         if ( vw.width != 320 || vw.height != 240 )
660                                 retval = -EFAULT;
661
662                         break;
663                 }
664
665                 /* mmap interface */
666         case VIDIOCGMBUF:
667                 {
668                         struct video_mbuf vm;
669                         int i;
670
671                         DBG("VIDIOCGMBUF\n");
672                         memset(&vm, 0, sizeof (vm));
673                         vm.size =
674                             VICAM_MAX_FRAME_SIZE * VICAM_FRAMES;
675                         vm.frames = VICAM_FRAMES;
676                         for (i = 0; i < VICAM_FRAMES; i++)
677                                 vm.offsets[i] = VICAM_MAX_FRAME_SIZE * i;
678
679                         if (copy_to_user(user_arg, (void *)&vm, sizeof(vm)))
680                                 retval = -EFAULT;
681
682                         break;
683                 }
684
685         case VIDIOCMCAPTURE:
686                 {
687                         struct video_mmap vm;
688                         // int video_size;
689
690                         if (copy_from_user((void *)&vm, user_arg, sizeof(vm))) {
691                                 retval = -EFAULT;
692                                 break;
693                         }
694
695                         DBG("VIDIOCMCAPTURE frame=%d, height=%d, width=%d, format=%d.\n",vm.frame,vm.width,vm.height,vm.format);
696
697                         if ( vm.frame >= VICAM_FRAMES || vm.format != VIDEO_PALETTE_RGB24 )
698                                 retval = -EINVAL;
699
700                         // in theory right here we'd start the image capturing
701                         // (fill in a bulk urb and submit it asynchronously)
702                         //
703                         // Instead we're going to do a total hack job for now and
704                         // retrieve the frame in VIDIOCSYNC
705
706                         break;
707                 }
708
709         case VIDIOCSYNC:
710                 {
711                         int frame;
712
713                         if (copy_from_user((void *)&frame, user_arg, sizeof(int))) {
714                                 retval = -EFAULT;
715                                 break;
716                         }
717                         DBG("VIDIOCSYNC: %d\n", frame);
718
719                         read_frame(cam, frame);
720                         vicam_decode_color(cam->raw_image,
721                                            cam->framebuf +
722                                            frame * VICAM_MAX_FRAME_SIZE );
723
724                         break;
725                 }
726
727                 /* pointless to implement overlay with this camera */
728         case VIDIOCCAPTURE:
729         case VIDIOCGFBUF:
730         case VIDIOCSFBUF:
731         case VIDIOCKEY:
732                 retval = -EINVAL;
733                 break;
734
735                 /* tuner interface - we have none */
736         case VIDIOCGTUNER:
737         case VIDIOCSTUNER:
738         case VIDIOCGFREQ:
739         case VIDIOCSFREQ:
740                 retval = -EINVAL;
741                 break;
742
743                 /* audio interface - we have none */
744         case VIDIOCGAUDIO:
745         case VIDIOCSAUDIO:
746                 retval = -EINVAL;
747                 break;
748         default:
749                 retval = -ENOIOCTLCMD;
750                 break;
751         }
752
753         return retval;
754 }
755
756 static int
757 vicam_open(struct inode *inode, struct file *file)
758 {
759         struct video_device *dev = video_devdata(file);
760         struct vicam_camera *cam =
761             (struct vicam_camera *) dev->priv;
762         DBG("open\n");
763
764         if (!cam) {
765                 printk(KERN_ERR
766                        "vicam video_device improperly initialized");
767         }
768
769         /* the videodev_lock held above us protects us from
770          * simultaneous opens...for now. we probably shouldn't
771          * rely on this fact forever.
772          */
773
774         if (cam->open_count > 0) {
775                 printk(KERN_INFO
776                        "vicam_open called on already opened camera");
777                 return -EBUSY;
778         }
779
780         cam->raw_image = kmalloc(VICAM_MAX_READ_SIZE, GFP_KERNEL);
781         if (!cam->raw_image) {
782                 return -ENOMEM;
783         }
784
785         cam->framebuf = rvmalloc(VICAM_MAX_FRAME_SIZE * VICAM_FRAMES);
786         if (!cam->framebuf) {
787                 kfree(cam->raw_image);
788                 return -ENOMEM;
789         }
790
791         cam->cntrlbuf = kmalloc(PAGE_SIZE, GFP_KERNEL);
792         if (!cam->cntrlbuf) {
793                 kfree(cam->raw_image);
794                 rvfree(cam->framebuf, VICAM_MAX_FRAME_SIZE * VICAM_FRAMES);
795                 return -ENOMEM;
796         }
797
798         // First upload firmware, then turn the camera on
799
800         if (!cam->is_initialized) {
801                 initialize_camera(cam);
802
803                 cam->is_initialized = 1;
804         }
805
806         set_camera_power(cam, 1);
807
808         cam->needsDummyRead = 1;
809         cam->open_count++;
810
811         file->private_data = cam;       
812         
813         return 0;
814 }
815
816 static int 
817 vicam_close(struct inode *inode, struct file *file)
818 {
819         struct vicam_camera *cam = file->private_data;
820         int open_count;
821         struct usb_device *udev;
822
823         DBG("close\n");
824
825         /* it's not the end of the world if
826          * we fail to turn the camera off.
827          */
828
829         set_camera_power(cam, 0);
830
831         kfree(cam->raw_image);
832         rvfree(cam->framebuf, VICAM_MAX_FRAME_SIZE * VICAM_FRAMES);
833         kfree(cam->cntrlbuf);
834
835         mutex_lock(&cam->cam_lock);
836
837         cam->open_count--;
838         open_count = cam->open_count;
839         udev = cam->udev;
840
841         mutex_unlock(&cam->cam_lock);
842
843         if (!open_count && !udev) {
844                 kfree(cam);
845         }
846
847         return 0;
848 }
849
850 static void vicam_decode_color(const u8 *data, u8 *rgb)
851 {
852         /* vicam_decode_color - Convert from Vicam Y-Cr-Cb to RGB
853          * Copyright (C) 2002 Monroe Williams (monroe@pobox.com)
854          */
855
856         int i, prevY, nextY;
857
858         prevY = 512;
859         nextY = 512;
860
861         data += VICAM_HEADER_SIZE;
862
863         for( i = 0; i < 240; i++, data += 512 ) {
864                 const int y = ( i * 242 ) / 240;
865
866                 int j, prevX, nextX;
867                 int Y, Cr, Cb;
868
869                 if ( y == 242 - 1 ) {
870                         nextY = -512;
871                 }
872
873                 prevX = 1;
874                 nextX = 1;
875
876                 for ( j = 0; j < 320; j++, rgb += 3 ) {
877                         const int x = ( j * 512 ) / 320;
878                         const u8 * const src = &data[x];
879
880                         if ( x == 512 - 1 ) {
881                                 nextX = -1;
882                         }
883
884                         Cr = ( src[prevX] - src[0] ) +
885                                 ( src[nextX] - src[0] );
886                         Cr /= 2;
887
888                         Cb = ( src[prevY] - src[prevX + prevY] ) +
889                                 ( src[prevY] - src[nextX + prevY] ) +
890                                 ( src[nextY] - src[prevX + nextY] ) +
891                                 ( src[nextY] - src[nextX + nextY] );
892                         Cb /= 4;
893
894                         Y = 1160 * ( src[0] + ( Cr / 2 ) - 16 );
895
896                         if ( i & 1 ) {
897                                 int Ct = Cr;
898                                 Cr = Cb;
899                                 Cb = Ct;
900                         }
901
902                         if ( ( x ^ i ) & 1 ) {
903                                 Cr = -Cr;
904                                 Cb = -Cb;
905                         }
906
907                         rgb[0] = clamp( ( ( Y + ( 2017 * Cb ) ) +
908                                         500 ) / 900, 0, 255 );
909                         rgb[1] = clamp( ( ( Y - ( 392 * Cb ) -
910                                           ( 813 * Cr ) ) +
911                                           500 ) / 1000, 0, 255 );
912                         rgb[2] = clamp( ( ( Y + ( 1594 * Cr ) ) +
913                                         500 ) / 1300, 0, 255 );
914
915                         prevX = -1;
916                 }
917
918                 prevY = -512;
919         }
920 }
921
922 static void
923 read_frame(struct vicam_camera *cam, int framenum)
924 {
925         unsigned char *request = cam->cntrlbuf;
926         int realShutter;
927         int n;
928         int actual_length;
929
930         if (cam->needsDummyRead) {
931                 cam->needsDummyRead = 0;
932                 read_frame(cam, framenum);
933         }
934
935         memset(request, 0, 16);
936         request[0] = cam->gain; // 0 = 0% gain, FF = 100% gain
937
938         request[1] = 0; // 512x242 capture
939
940         request[2] = 0x90;      // the function of these two bytes
941         request[3] = 0x07;      // is not yet understood
942
943         if (cam->shutter_speed > 60) {
944                 // Short exposure
945                 realShutter =
946                     ((-15631900 / cam->shutter_speed) + 260533) / 1000;
947                 request[4] = realShutter & 0xFF;
948                 request[5] = (realShutter >> 8) & 0xFF;
949                 request[6] = 0x03;
950                 request[7] = 0x01;
951         } else {
952                 // Long exposure
953                 realShutter = 15600 / cam->shutter_speed - 1;
954                 request[4] = 0;
955                 request[5] = 0;
956                 request[6] = realShutter & 0xFF;
957                 request[7] = realShutter >> 8;
958         }
959
960         // Per John Markus Bjørndalen, byte at index 8 causes problems if it isn't 0
961         request[8] = 0;
962         // bytes 9-15 do not seem to affect exposure or image quality
963
964         mutex_lock(&cam->cam_lock);
965
966         if (!cam->udev) {
967                 goto done;
968         }
969
970         n = __send_control_msg(cam, 0x51, 0x80, 0, request, 16);
971
972         if (n < 0) {
973                 printk(KERN_ERR
974                        " Problem sending frame capture control message");
975                 goto done;
976         }
977
978         n = usb_bulk_msg(cam->udev,
979                          usb_rcvbulkpipe(cam->udev, cam->bulkEndpoint),
980                          cam->raw_image,
981                          512 * 242 + 128, &actual_length, 10000);
982
983         if (n < 0) {
984                 printk(KERN_ERR "Problem during bulk read of frame data: %d\n",
985                        n);
986         }
987
988  done:
989         mutex_unlock(&cam->cam_lock);
990 }
991
992 static ssize_t
993 vicam_read( struct file *file, char __user *buf, size_t count, loff_t *ppos )
994 {
995         struct vicam_camera *cam = file->private_data;
996
997         DBG("read %d bytes.\n", (int) count);
998
999         if (*ppos >= VICAM_MAX_FRAME_SIZE) {
1000                 *ppos = 0;
1001                 return 0;
1002         }
1003
1004         if (*ppos == 0) {
1005                 read_frame(cam, 0);
1006                 vicam_decode_color(cam->raw_image,
1007                                    cam->framebuf +
1008                                    0 * VICAM_MAX_FRAME_SIZE);
1009         }
1010
1011         count = min_t(size_t, count, VICAM_MAX_FRAME_SIZE - *ppos);
1012
1013         if (copy_to_user(buf, &cam->framebuf[*ppos], count)) {
1014                 count = -EFAULT;
1015         } else {
1016                 *ppos += count;
1017         }
1018
1019         if (count == VICAM_MAX_FRAME_SIZE) {
1020                 *ppos = 0;
1021         }
1022
1023         return count;
1024 }
1025
1026
1027 static int
1028 vicam_mmap(struct file *file, struct vm_area_struct *vma)
1029 {
1030         // TODO: allocate the raw frame buffer if necessary
1031         unsigned long page, pos;
1032         unsigned long start = vma->vm_start;
1033         unsigned long size  = vma->vm_end-vma->vm_start;
1034         struct vicam_camera *cam = file->private_data;
1035
1036         if (!cam)
1037                 return -ENODEV;
1038
1039         DBG("vicam_mmap: %ld\n", size);
1040
1041         /* We let mmap allocate as much as it wants because Linux was adding 2048 bytes
1042          * to the size the application requested for mmap and it was screwing apps up.
1043          if (size > VICAM_FRAMES*VICAM_MAX_FRAME_SIZE)
1044          return -EINVAL;
1045          */
1046
1047         pos = (unsigned long)cam->framebuf;
1048         while (size > 0) {
1049                 page = vmalloc_to_pfn((void *)pos);
1050                 if (remap_pfn_range(vma, start, page, PAGE_SIZE, PAGE_SHARED))
1051                         return -EAGAIN;
1052
1053                 start += PAGE_SIZE;
1054                 pos += PAGE_SIZE;
1055                 if (size > PAGE_SIZE)
1056                         size -= PAGE_SIZE;
1057                 else
1058                         size = 0;
1059         }
1060
1061         return 0;
1062 }
1063
1064 #if defined(CONFIG_VIDEO_PROC_FS)
1065
1066 static struct proc_dir_entry *vicam_proc_root = NULL;
1067
1068 static int vicam_read_helper(char *page, char **start, off_t off,
1069                                 int count, int *eof, int value)
1070 {
1071         char *out = page;
1072         int len;
1073
1074         out += sprintf(out, "%d",value);
1075
1076         len = out - page;
1077         len -= off;
1078         if (len < count) {
1079                 *eof = 1;
1080                 if (len <= 0)
1081                         return 0;
1082         } else
1083                 len = count;
1084
1085         *start = page + off;
1086         return len;
1087 }
1088
1089 static int vicam_read_proc_shutter(char *page, char **start, off_t off,
1090                                 int count, int *eof, void *data)
1091 {
1092         return vicam_read_helper(page,start,off,count,eof,
1093                                 ((struct vicam_camera *)data)->shutter_speed);
1094 }
1095
1096 static int vicam_read_proc_gain(char *page, char **start, off_t off,
1097                                 int count, int *eof, void *data)
1098 {
1099         return vicam_read_helper(page,start,off,count,eof,
1100                                 ((struct vicam_camera *)data)->gain);
1101 }
1102
1103 static int
1104 vicam_write_proc_shutter(struct file *file, const char *buffer,
1105                          unsigned long count, void *data)
1106 {
1107         u16 stmp;
1108         char kbuf[8];
1109         struct vicam_camera *cam = (struct vicam_camera *) data;
1110
1111         if (count > 6)
1112                 return -EINVAL;
1113
1114         if (copy_from_user(kbuf, buffer, count))
1115                 return -EFAULT;
1116
1117         stmp = (u16) simple_strtoul(kbuf, NULL, 10);
1118         if (stmp < 4 || stmp > 32000)
1119                 return -EINVAL;
1120
1121         cam->shutter_speed = stmp;
1122
1123         return count;
1124 }
1125
1126 static int
1127 vicam_write_proc_gain(struct file *file, const char *buffer,
1128                       unsigned long count, void *data)
1129 {
1130         u16 gtmp;
1131         char kbuf[8];
1132
1133         struct vicam_camera *cam = (struct vicam_camera *) data;
1134
1135         if (count > 4)
1136                 return -EINVAL;
1137
1138         if (copy_from_user(kbuf, buffer, count))
1139                 return -EFAULT;
1140
1141         gtmp = (u16) simple_strtoul(kbuf, NULL, 10);
1142         if (gtmp > 255)
1143                 return -EINVAL;
1144         cam->gain = gtmp;
1145
1146         return count;
1147 }
1148
1149 static void
1150 vicam_create_proc_root(void)
1151 {
1152         vicam_proc_root = proc_mkdir("video/vicam", NULL);
1153
1154         if (vicam_proc_root)
1155                 vicam_proc_root->owner = THIS_MODULE;
1156         else
1157                 printk(KERN_ERR
1158                        "could not create /proc entry for vicam!");
1159 }
1160
1161 static void
1162 vicam_destroy_proc_root(void)
1163 {
1164         if (vicam_proc_root)
1165                 remove_proc_entry("video/vicam", 0);
1166 }
1167
1168 static void
1169 vicam_create_proc_entry(struct vicam_camera *cam)
1170 {
1171         char name[64];
1172         struct proc_dir_entry *ent;
1173
1174         DBG(KERN_INFO "vicam: creating proc entry\n");
1175
1176         if (!vicam_proc_root || !cam) {
1177                 printk(KERN_INFO
1178                        "vicam: could not create proc entry, %s pointer is null.\n",
1179                        (!cam ? "camera" : "root"));
1180                 return;
1181         }
1182
1183         sprintf(name, "video%d", cam->vdev.minor);
1184
1185         cam->proc_dir = proc_mkdir(name, vicam_proc_root);
1186
1187         if ( !cam->proc_dir )
1188                 return; // FIXME: We should probably return an error here
1189         
1190         ent = create_proc_entry("shutter", S_IFREG | S_IRUGO | S_IWUSR,
1191                                 cam->proc_dir);
1192         if (ent) {
1193                 ent->data = cam;
1194                 ent->read_proc = vicam_read_proc_shutter;
1195                 ent->write_proc = vicam_write_proc_shutter;
1196                 ent->size = 64;
1197         }
1198
1199         ent = create_proc_entry("gain", S_IFREG | S_IRUGO | S_IWUSR,
1200                                 cam->proc_dir);
1201         if (ent) {
1202                 ent->data = cam;
1203                 ent->read_proc = vicam_read_proc_gain;
1204                 ent->write_proc = vicam_write_proc_gain;
1205                 ent->size = 64;
1206         }
1207 }
1208
1209 static void
1210 vicam_destroy_proc_entry(void *ptr)
1211 {
1212         struct vicam_camera *cam = (struct vicam_camera *) ptr;
1213         char name[16];
1214
1215         if ( !cam->proc_dir )
1216                 return;
1217
1218         sprintf(name, "video%d", cam->vdev.minor);
1219         remove_proc_entry("shutter", cam->proc_dir);
1220         remove_proc_entry("gain", cam->proc_dir);
1221         remove_proc_entry(name,vicam_proc_root);
1222         cam->proc_dir = NULL;
1223
1224 }
1225
1226 #else
1227 static inline void vicam_create_proc_root(void) { }
1228 static inline void vicam_destroy_proc_root(void) { }
1229 static inline void vicam_create_proc_entry(struct vicam_camera *cam) { }
1230 static inline void vicam_destroy_proc_entry(void *ptr) { }
1231 #endif
1232
1233 static struct file_operations vicam_fops = {
1234         .owner          = THIS_MODULE,
1235         .open           = vicam_open,
1236         .release        = vicam_close,
1237         .read           = vicam_read,
1238         .mmap           = vicam_mmap,
1239         .ioctl          = vicam_ioctl,
1240         .compat_ioctl   = v4l_compat_ioctl32,
1241         .llseek         = no_llseek,
1242 };
1243
1244 static struct video_device vicam_template = {
1245         .owner          = THIS_MODULE,
1246         .name           = "ViCam-based USB Camera",
1247         .type           = VID_TYPE_CAPTURE,
1248         .hardware       = VID_HARDWARE_VICAM,
1249         .fops           = &vicam_fops,
1250         .minor          = -1,
1251 };
1252
1253 /* table of devices that work with this driver */
1254 static struct usb_device_id vicam_table[] = {
1255         {USB_DEVICE(USB_VICAM_VENDOR_ID, USB_VICAM_PRODUCT_ID)},
1256         {}                      /* Terminating entry */
1257 };
1258
1259 MODULE_DEVICE_TABLE(usb, vicam_table);
1260
1261 static struct usb_driver vicam_driver = {
1262         .name           = "vicam",
1263         .probe          = vicam_probe,
1264         .disconnect     = vicam_disconnect,
1265         .id_table       = vicam_table
1266 };
1267
1268 /**
1269  *      vicam_probe
1270  *      @intf: the interface
1271  *      @id: the device id
1272  *
1273  *      Called by the usb core when a new device is connected that it thinks
1274  *      this driver might be interested in.
1275  */
1276 static int
1277 vicam_probe( struct usb_interface *intf, const struct usb_device_id *id)
1278 {
1279         struct usb_device *dev = interface_to_usbdev(intf);
1280         int bulkEndpoint = 0;
1281         const struct usb_host_interface *interface;
1282         const struct usb_endpoint_descriptor *endpoint;
1283         struct vicam_camera *cam;
1284         
1285         printk(KERN_INFO "ViCam based webcam connected\n");
1286
1287         interface = intf->cur_altsetting;
1288
1289         DBG(KERN_DEBUG "Interface %d. has %u. endpoints!\n",
1290                interface->desc.bInterfaceNumber, (unsigned) (interface->desc.bNumEndpoints));
1291         endpoint = &interface->endpoint[0].desc;
1292
1293         if ((endpoint->bEndpointAddress & 0x80) &&
1294             ((endpoint->bmAttributes & 3) == 0x02)) {
1295                 /* we found a bulk in endpoint */
1296                 bulkEndpoint = endpoint->bEndpointAddress;
1297         } else {
1298                 printk(KERN_ERR
1299                        "No bulk in endpoint was found ?! (this is bad)\n");
1300         }
1301
1302         if ((cam =
1303              kmalloc(sizeof (struct vicam_camera), GFP_KERNEL)) == NULL) {
1304                 printk(KERN_WARNING
1305                        "could not allocate kernel memory for vicam_camera struct\n");
1306                 return -ENOMEM;
1307         }
1308
1309         memset(cam, 0, sizeof (struct vicam_camera));
1310
1311         cam->shutter_speed = 15;
1312
1313         mutex_init(&cam->cam_lock);
1314
1315         memcpy(&cam->vdev, &vicam_template,
1316                sizeof (vicam_template));
1317         cam->vdev.priv = cam;   // sort of a reverse mapping for those functions that get vdev only
1318
1319         cam->udev = dev;
1320         cam->bulkEndpoint = bulkEndpoint;
1321
1322         if (video_register_device(&cam->vdev, VFL_TYPE_GRABBER, -1) == -1) {
1323                 kfree(cam);
1324                 printk(KERN_WARNING "video_register_device failed\n");
1325                 return -EIO;
1326         }
1327
1328         vicam_create_proc_entry(cam);
1329
1330         printk(KERN_INFO "ViCam webcam driver now controlling video device %d\n",cam->vdev.minor);
1331
1332         usb_set_intfdata (intf, cam);
1333         
1334         return 0;
1335 }
1336
1337 static void
1338 vicam_disconnect(struct usb_interface *intf)
1339 {
1340         int open_count;
1341         struct vicam_camera *cam = usb_get_intfdata (intf);
1342         usb_set_intfdata (intf, NULL);
1343
1344         /* we must unregister the device before taking its
1345          * cam_lock. This is because the video open call
1346          * holds the same lock as video unregister. if we
1347          * unregister inside of the cam_lock and open also
1348          * uses the cam_lock, we get deadlock.
1349          */
1350
1351         video_unregister_device(&cam->vdev);
1352
1353         /* stop the camera from being used */
1354
1355         mutex_lock(&cam->cam_lock);
1356
1357         /* mark the camera as gone */
1358
1359         cam->udev = NULL;
1360
1361         vicam_destroy_proc_entry(cam);
1362
1363         /* the only thing left to do is synchronize with
1364          * our close/release function on who should release
1365          * the camera memory. if there are any users using the
1366          * camera, it's their job. if there are no users,
1367          * it's ours.
1368          */
1369
1370         open_count = cam->open_count;
1371
1372         mutex_unlock(&cam->cam_lock);
1373
1374         if (!open_count) {
1375                 kfree(cam);
1376         }
1377
1378         printk(KERN_DEBUG "ViCam-based WebCam disconnected\n");
1379 }
1380
1381 /*
1382  */
1383 static int __init
1384 usb_vicam_init(void)
1385 {
1386         int retval;
1387         DBG(KERN_INFO "ViCam-based WebCam driver startup\n");
1388         vicam_create_proc_root();
1389         retval = usb_register(&vicam_driver);
1390         if (retval)
1391                 printk(KERN_WARNING "usb_register failed!\n");
1392         return retval;
1393 }
1394
1395 static void __exit
1396 usb_vicam_exit(void)
1397 {
1398         DBG(KERN_INFO
1399                "ViCam-based WebCam driver shutdown\n");
1400
1401         usb_deregister(&vicam_driver);
1402         vicam_destroy_proc_root();
1403 }
1404
1405 module_init(usb_vicam_init);
1406 module_exit(usb_vicam_exit);
1407
1408 MODULE_AUTHOR(DRIVER_AUTHOR);
1409 MODULE_DESCRIPTION(DRIVER_DESC);
1410 MODULE_LICENSE("GPL");