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)
9 * Supports 3COM HomeConnect PC Digital WebCam
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.
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
28 * Portions of this code were also copied from usbvideo.c
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.
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>
47 // #define VICAM_DEBUG
50 #define ADBG(lineno,fmt,args...) printk(fmt, jiffies, __FUNCTION__, lineno, ##args)
51 #define DBG(fmt,args...) ADBG((__LINE__),KERN_DEBUG __FILE__"(%ld):%s (%d):"fmt,##args)
53 #define DBG(fmn,args...) do {} while(0)
56 #define DRIVER_AUTHOR "Joe Burks, jburks@wavicle.org"
57 #define DRIVER_DESC "ViCam WebCam Driver"
59 /* Define these values to match your device */
60 #define USB_VICAM_VENDOR_ID 0x04c1
61 #define USB_VICAM_PRODUCT_ID 0x009d
63 #define VICAM_BYTES_PER_PIXEL 3
64 #define VICAM_MAX_READ_SIZE (512*242+128)
65 #define VICAM_MAX_FRAME_SIZE (VICAM_BYTES_PER_PIXEL*320*240)
66 #define VICAM_FRAMES 2
68 #define VICAM_HEADER_SIZE 64
70 #define clamp( x, l, h ) max_t( __typeof__( x ), \
72 min_t( __typeof__( x ), \
76 /* Not sure what all the bytes in these char
77 * arrays do, but they're necessary to make
81 static unsigned char setup1[] = {
82 0xB6, 0xC3, 0x1F, 0x00, 0x02, 0x64, 0xE7, 0x67,
83 0xFD, 0xFF, 0x0E, 0xC0, 0xE7, 0x09, 0xDE, 0x00,
84 0x8E, 0x00, 0xC0, 0x09, 0x40, 0x03, 0xC0, 0x17,
85 0x44, 0x03, 0x4B, 0xAF, 0xC0, 0x07, 0x00, 0x00,
86 0x4B, 0xAF, 0x97, 0xCF, 0x00, 0x00
89 static unsigned char setup2[] = {
90 0xB6, 0xC3, 0x03, 0x00, 0x03, 0x64, 0x18, 0x00,
94 static unsigned char setup3[] = {
95 0xB6, 0xC3, 0x01, 0x00, 0x06, 0x64, 0x00, 0x00
98 static unsigned char setup4[] = {
99 0xB6, 0xC3, 0x8F, 0x06, 0x02, 0x64, 0xE7, 0x07,
100 0x00, 0x00, 0x08, 0xC0, 0xE7, 0x07, 0x00, 0x00,
101 0x3E, 0xC0, 0xE7, 0x07, 0x54, 0x01, 0xAA, 0x00,
102 0xE7, 0x07, 0xC8, 0x05, 0xB6, 0x00, 0xE7, 0x07,
103 0x42, 0x01, 0xD2, 0x00, 0xE7, 0x07, 0x7C, 0x00,
104 0x16, 0x00, 0xE7, 0x07, 0x56, 0x00, 0x18, 0x00,
105 0xE7, 0x07, 0x06, 0x00, 0x92, 0xC0, 0xE7, 0x07,
106 0x00, 0x00, 0x1E, 0xC0, 0xE7, 0x07, 0xFF, 0xFF,
107 0x22, 0xC0, 0xE7, 0x07, 0x04, 0x00, 0x24, 0xC0,
108 0xE7, 0x07, 0xEC, 0x27, 0x28, 0xC0, 0xE7, 0x07,
109 0x16, 0x01, 0x8E, 0x00, 0xE7, 0x87, 0x01, 0x00,
110 0x0E, 0xC0, 0x97, 0xCF, 0xD7, 0x09, 0x00, 0xC0,
111 0xE7, 0x77, 0x01, 0x00, 0x92, 0xC0, 0x09, 0xC1,
112 0xE7, 0x09, 0xFE, 0x05, 0x24, 0x01, 0xE7, 0x09,
113 0x04, 0x06, 0x26, 0x01, 0xE7, 0x07, 0x07, 0x00,
114 0x92, 0xC0, 0xE7, 0x05, 0x00, 0xC0, 0xC0, 0xDF,
115 0x97, 0xCF, 0x17, 0x00, 0x57, 0x00, 0x17, 0x02,
116 0xD7, 0x09, 0x00, 0xC0, 0xE7, 0x77, 0x01, 0x00,
117 0x92, 0xC0, 0x0A, 0xC1, 0xE7, 0x57, 0xFF, 0xFF,
118 0xFA, 0x05, 0x0D, 0xC0, 0xE7, 0x57, 0x00, 0x00,
119 0xFA, 0x05, 0x0F, 0xC0, 0x9F, 0xAF, 0xC6, 0x00,
120 0xE7, 0x05, 0x00, 0xC0, 0xC8, 0x05, 0xC1, 0x05,
121 0xC0, 0x05, 0xC0, 0xDF, 0x97, 0xCF, 0x27, 0xDA,
122 0xFA, 0x05, 0xEF, 0x07, 0x01, 0x00, 0x0B, 0x06,
123 0x73, 0xCF, 0x9F, 0xAF, 0x78, 0x01, 0x9F, 0xAF,
124 0x1A, 0x03, 0x6E, 0xCF, 0xE7, 0x09, 0xFC, 0x05,
125 0x24, 0x01, 0xE7, 0x09, 0x02, 0x06, 0x26, 0x01,
126 0xE7, 0x07, 0x07, 0x00, 0x92, 0xC0, 0xE7, 0x09,
127 0xFC, 0x05, 0xFE, 0x05, 0xE7, 0x09, 0x02, 0x06,
128 0x04, 0x06, 0xE7, 0x09, 0x00, 0x06, 0xFC, 0x05,
129 0xE7, 0x09, 0xFE, 0x05, 0x00, 0x06, 0x27, 0xDA,
130 0xFA, 0x05, 0xE7, 0x57, 0x01, 0x00, 0xFA, 0x05,
131 0x02, 0xCA, 0x04, 0xC0, 0x97, 0xCF, 0x9F, 0xAF,
132 0x66, 0x05, 0x97, 0xCF, 0xE7, 0x07, 0x40, 0x00,
133 0x02, 0x06, 0xC8, 0x09, 0xFC, 0x05, 0x9F, 0xAF,
134 0xDA, 0x02, 0x97, 0xCF, 0xCF, 0x17, 0x02, 0x00,
135 0xEF, 0x57, 0x81, 0x00, 0x09, 0x06, 0x9F, 0xA0,
136 0xB6, 0x01, 0xEF, 0x57, 0x80, 0x00, 0x09, 0x06,
137 0x9F, 0xA0, 0x40, 0x02, 0xEF, 0x57, 0x01, 0x00,
138 0x0B, 0x06, 0x9F, 0xA0, 0x46, 0x03, 0xE7, 0x07,
139 0x01, 0x00, 0x0A, 0xC0, 0x46, 0xAF, 0x47, 0xAF,
140 0x9F, 0xAF, 0x40, 0x02, 0xE7, 0x07, 0x2E, 0x00,
141 0x0A, 0xC0, 0xEF, 0x87, 0x80, 0x00, 0x09, 0x06,
142 0x97, 0xCF, 0x00, 0x0E, 0x01, 0x00, 0xC0, 0x57,
143 0x51, 0x00, 0x9F, 0xC0, 0x9E, 0x02, 0xC0, 0x57,
144 0x50, 0x00, 0x20, 0xC0, 0xC0, 0x57, 0x55, 0x00,
145 0x12, 0xC0, 0xC0, 0x57, 0x56, 0x00, 0x9F, 0xC0,
146 0x72, 0x02, 0x9F, 0xCF, 0xD6, 0x02, 0xC1, 0x0B,
147 0x08, 0x06, 0x01, 0xD0, 0x6F, 0x90, 0x08, 0x06,
148 0xC0, 0x07, 0x08, 0x00, 0xC1, 0x0B, 0x08, 0x06,
149 0x9F, 0xAF, 0x28, 0x05, 0x97, 0xCF, 0x2F, 0x0E,
150 0x02, 0x00, 0x08, 0x06, 0xC0, 0x07, 0x08, 0x00,
151 0xC1, 0x0B, 0x08, 0x06, 0x9F, 0xAF, 0x28, 0x05,
152 0x9F, 0xCF, 0xD6, 0x02, 0x2F, 0x0E, 0x02, 0x00,
153 0x09, 0x06, 0xEF, 0x87, 0x80, 0x00, 0x09, 0x06,
154 0x9F, 0xCF, 0xD6, 0x02, 0xEF, 0x67, 0x7F, 0xFF,
155 0x09, 0x06, 0xE7, 0x67, 0xFF, 0xFD, 0x22, 0xC0,
156 0xE7, 0x67, 0xEF, 0xFF, 0x24, 0xC0, 0xE7, 0x87,
157 0x10, 0x00, 0x28, 0xC0, 0x9F, 0xAF, 0xB8, 0x05,
158 0xE7, 0x87, 0xE0, 0x21, 0x24, 0xC0, 0x9F, 0xAF,
159 0xA8, 0x05, 0xE7, 0x87, 0x08, 0x00, 0x24, 0xC0,
160 0xE7, 0x67, 0xDF, 0xFF, 0x24, 0xC0, 0xC8, 0x07,
161 0x0A, 0x00, 0xC0, 0x07, 0x00, 0x00, 0xC1, 0x07,
162 0x01, 0x00, 0x9F, 0xAF, 0x28, 0x05, 0x9F, 0xAF,
163 0xB8, 0x05, 0xC0, 0x07, 0x9E, 0x00, 0x9F, 0xAF,
164 0x44, 0x05, 0xE7, 0x67, 0xFF, 0xFE, 0x24, 0xC0,
165 0xC0, 0x09, 0x20, 0xC0, 0xE7, 0x87, 0x00, 0x01,
166 0x24, 0xC0, 0xC0, 0x77, 0x00, 0x02, 0x0F, 0xC1,
167 0xE7, 0x67, 0xF7, 0xFF, 0x24, 0xC0, 0xE7, 0x67,
168 0xF7, 0xFF, 0x24, 0xC0, 0xE7, 0x87, 0x08, 0x00,
169 0x24, 0xC0, 0x08, 0xDA, 0x5E, 0xC1, 0xEF, 0x07,
170 0x80, 0x00, 0x09, 0x06, 0x97, 0xCF, 0xEF, 0x07,
171 0x01, 0x00, 0x0A, 0x06, 0x97, 0xCF, 0xEF, 0x07,
172 0x00, 0x00, 0x0B, 0x06, 0xEF, 0x07, 0x00, 0x00,
173 0x0A, 0x06, 0xEF, 0x67, 0x7F, 0xFF, 0x09, 0x06,
174 0xEF, 0x07, 0x00, 0x00, 0x0D, 0x06, 0xE7, 0x67,
175 0xEF, 0xFF, 0x28, 0xC0, 0xE7, 0x67, 0x17, 0xD8,
176 0x24, 0xC0, 0xE7, 0x07, 0x00, 0x00, 0x1E, 0xC0,
177 0xE7, 0x07, 0xFF, 0xFF, 0x22, 0xC0, 0x97, 0xCF,
178 0xC8, 0x07, 0x0E, 0x06, 0x9F, 0xAF, 0xDA, 0x02,
179 0xE7, 0x07, 0x00, 0x00, 0xF2, 0x05, 0xE7, 0x07,
180 0x10, 0x00, 0xF6, 0x05, 0xE7, 0x07, 0x0E, 0x06,
181 0xF4, 0x05, 0xE7, 0x07, 0xD6, 0x02, 0xF8, 0x05,
182 0xC8, 0x07, 0xF2, 0x05, 0xC1, 0x07, 0x00, 0x80,
183 0x50, 0xAF, 0x97, 0xCF, 0x2F, 0x0C, 0x02, 0x00,
184 0x07, 0x06, 0x2F, 0x0C, 0x04, 0x00, 0x06, 0x06,
185 0xE7, 0x07, 0x00, 0x00, 0xF2, 0x05, 0xE7, 0x07,
186 0x10, 0x00, 0xF6, 0x05, 0xE7, 0x07, 0xE2, 0x05,
187 0xF4, 0x05, 0xE7, 0x07, 0xCE, 0x02, 0xF8, 0x05,
188 0xC8, 0x07, 0xF2, 0x05, 0xC1, 0x07, 0x00, 0x80,
189 0x51, 0xAF, 0x97, 0xCF, 0x9F, 0xAF, 0x66, 0x04,
190 0x9F, 0xAF, 0x1A, 0x03, 0x59, 0xAF, 0x97, 0xCF,
191 0xC0, 0x07, 0x0E, 0x00, 0xC1, 0x0B, 0x0C, 0x06,
192 0x41, 0xD1, 0x9F, 0xAF, 0x28, 0x05, 0xC0, 0x07,
193 0x3C, 0x00, 0x9F, 0xAF, 0x44, 0x05, 0x68, 0x00,
194 0xC0, 0x07, 0x3B, 0x00, 0x9F, 0xAF, 0x44, 0x05,
195 0x6F, 0x00, 0x0C, 0x06, 0x68, 0x00, 0xE0, 0x07,
196 0x04, 0x01, 0xE8, 0x0B, 0x0A, 0x06, 0xE8, 0x07,
197 0x00, 0x00, 0xE0, 0x07, 0x00, 0x02, 0xE0, 0x07,
198 0xEC, 0x01, 0xE0, 0x07, 0xFC, 0xFF, 0x97, 0xCF,
199 0xE7, 0x07, 0xFF, 0xFF, 0xFA, 0x05, 0xEF, 0x07,
200 0x00, 0x00, 0x0B, 0x06, 0xE7, 0x07, 0x0E, 0x06,
201 0x24, 0x01, 0xE7, 0x07, 0x0E, 0x06, 0xFE, 0x05,
202 0xE7, 0x07, 0x40, 0x00, 0x26, 0x01, 0xE7, 0x07,
203 0x40, 0x00, 0x04, 0x06, 0xE7, 0x07, 0x07, 0x00,
204 0x92, 0xC0, 0x97, 0xCF, 0xEF, 0x07, 0x02, 0x00,
205 0x0B, 0x06, 0x9F, 0xAF, 0x78, 0x01, 0xEF, 0x77,
206 0x80, 0x00, 0x07, 0x06, 0x9F, 0xC0, 0x14, 0x04,
207 0xEF, 0x77, 0x01, 0x00, 0x07, 0x06, 0x37, 0xC0,
208 0xEF, 0x77, 0x01, 0x00, 0x0D, 0x06, 0x0F, 0xC1,
209 0xEF, 0x07, 0x01, 0x00, 0x0D, 0x06, 0xC0, 0x07,
210 0x02, 0x00, 0xC1, 0x07, 0x30, 0x00, 0x9F, 0xAF,
211 0x28, 0x05, 0xC0, 0x07, 0x01, 0x00, 0xC1, 0x07,
212 0x02, 0x00, 0x9F, 0xAF, 0x28, 0x05, 0xC8, 0x07,
213 0xFF, 0x4F, 0x9F, 0xAF, 0xA8, 0x05, 0xC0, 0x07,
214 0x38, 0x00, 0x9F, 0xAF, 0x44, 0x05, 0xC1, 0x77,
215 0x03, 0x00, 0x02, 0xC1, 0x08, 0xDA, 0x75, 0xC1,
216 0xC1, 0x77, 0x01, 0x00, 0x0A, 0xC1, 0xC0, 0x07,
217 0x01, 0x00, 0xC1, 0x07, 0x02, 0x00, 0x9F, 0xAF,
218 0x28, 0x05, 0xEF, 0x07, 0x01, 0x00, 0x06, 0x06,
219 0x2C, 0xCF, 0xC0, 0x07, 0x01, 0x00, 0xC1, 0x07,
220 0x04, 0x00, 0x9F, 0xAF, 0x28, 0x05, 0xEF, 0x07,
221 0x00, 0x00, 0x06, 0x06, 0x22, 0xCF, 0xEF, 0x07,
222 0x00, 0x00, 0x0D, 0x06, 0xEF, 0x57, 0x01, 0x00,
223 0x06, 0x06, 0x1B, 0xC0, 0xC0, 0x07, 0x01, 0x00,
224 0xC1, 0x07, 0x01, 0x00, 0x9F, 0xAF, 0x28, 0x05,
225 0xC0, 0x07, 0x02, 0x00, 0xC1, 0x07, 0x30, 0x00,
226 0x9F, 0xAF, 0x28, 0x05, 0xC8, 0x07, 0xFF, 0x4F,
227 0x9F, 0xAF, 0xA8, 0x05, 0xC0, 0x07, 0x38, 0x00,
228 0x9F, 0xAF, 0x44, 0x05, 0xC1, 0x67, 0x03, 0x00,
229 0xC1, 0x57, 0x03, 0x00, 0x02, 0xC0, 0x08, 0xDA,
230 0x73, 0xC1, 0xC0, 0x07, 0x02, 0x00, 0xC1, 0x07,
231 0x12, 0x00, 0xEF, 0x57, 0x00, 0x00, 0x06, 0x06,
232 0x02, 0xC0, 0xC1, 0x07, 0x23, 0x00, 0x9F, 0xAF,
233 0x28, 0x05, 0xC0, 0x07, 0x14, 0x00, 0xC1, 0x0B,
234 0xEA, 0x05, 0x9F, 0xAF, 0x28, 0x05, 0xC0, 0x07,
235 0x3E, 0x00, 0x9F, 0xAF, 0x0A, 0x05, 0xE7, 0x09,
236 0xE4, 0x05, 0xFA, 0x05, 0x27, 0xD8, 0xFA, 0x05,
237 0xE7, 0x07, 0x0E, 0x06, 0xFC, 0x05, 0xE7, 0x07,
238 0x4E, 0x06, 0x00, 0x06, 0xE7, 0x07, 0x40, 0x00,
239 0x02, 0x06, 0x9F, 0xAF, 0x66, 0x05, 0x9F, 0xAF,
240 0xC6, 0x00, 0x97, 0xCF, 0xC1, 0x0B, 0xE2, 0x05,
241 0x41, 0xD0, 0x01, 0xD2, 0xC1, 0x17, 0x23, 0x00,
242 0x9F, 0xAF, 0xDC, 0x04, 0xC0, 0x07, 0x04, 0x00,
243 0xC1, 0x0B, 0xE3, 0x05, 0x9F, 0xAF, 0x28, 0x05,
244 0xC0, 0x07, 0x06, 0x00, 0xC1, 0x09, 0xE6, 0x05,
245 0x9F, 0xAF, 0x28, 0x05, 0xC0, 0x07, 0x07, 0x00,
246 0xC1, 0x09, 0xE6, 0x05, 0xC1, 0xD1, 0x9F, 0xAF,
247 0x28, 0x05, 0xC0, 0x07, 0x0B, 0x00, 0xC1, 0x09,
248 0xE8, 0x05, 0x9F, 0xAF, 0x28, 0x05, 0xC0, 0x07,
249 0x0C, 0x00, 0xC1, 0x09, 0xE8, 0x05, 0xC1, 0xD1,
250 0x9F, 0xAF, 0x28, 0x05, 0xC0, 0x07, 0x0D, 0x00,
251 0xC1, 0x07, 0x09, 0x00, 0x9F, 0xAF, 0x28, 0x05,
252 0xC0, 0x07, 0x03, 0x00, 0xC1, 0x07, 0x32, 0x00,
253 0x9F, 0xAF, 0x28, 0x05, 0xC0, 0x07, 0x0F, 0x00,
254 0xC1, 0x07, 0x00, 0x00, 0x9F, 0xAF, 0x28, 0x05,
255 0x97, 0xCF, 0xE7, 0x67, 0xFF, 0xD9, 0x24, 0xC0,
256 0xC8, 0x07, 0x0A, 0x00, 0x40, 0x00, 0xC0, 0x67,
257 0x00, 0x02, 0x27, 0x80, 0x24, 0xC0, 0xE7, 0x87,
258 0x00, 0x04, 0x24, 0xC0, 0xE7, 0x67, 0xFF, 0xF9,
259 0x24, 0xC0, 0x01, 0xD2, 0x08, 0xDA, 0x72, 0xC1,
260 0xE7, 0x87, 0x00, 0x20, 0x24, 0xC0, 0x97, 0xCF,
261 0x27, 0x00, 0x1E, 0xC0, 0xE7, 0x87, 0xFF, 0x00,
262 0x22, 0xC0, 0xE7, 0x67, 0x7F, 0xFF, 0x24, 0xC0,
263 0xE7, 0x87, 0x80, 0x00, 0x24, 0xC0, 0xE7, 0x87,
264 0x80, 0x00, 0x24, 0xC0, 0x97, 0xCF, 0x9F, 0xAF,
265 0x0A, 0x05, 0x67, 0x00, 0x1E, 0xC0, 0xE7, 0x67,
266 0xBF, 0xFF, 0x24, 0xC0, 0xE7, 0x87, 0x40, 0x00,
267 0x24, 0xC0, 0xE7, 0x87, 0x40, 0x00, 0x24, 0xC0,
268 0x97, 0xCF, 0x9F, 0xAF, 0x0A, 0x05, 0xE7, 0x67,
269 0x00, 0xFF, 0x22, 0xC0, 0xE7, 0x67, 0xFF, 0xFE,
270 0x24, 0xC0, 0xE7, 0x67, 0xFF, 0xFE, 0x24, 0xC0,
271 0xC1, 0x09, 0x20, 0xC0, 0xE7, 0x87, 0x00, 0x01,
272 0x24, 0xC0, 0x97, 0xCF, 0xC0, 0x07, 0x40, 0x00,
273 0xC8, 0x09, 0xFC, 0x05, 0xE7, 0x67, 0x00, 0xFF,
274 0x22, 0xC0, 0xE7, 0x67, 0xFF, 0xFE, 0x24, 0xC0,
275 0xE7, 0x67, 0xBF, 0xFF, 0x24, 0xC0, 0xE7, 0x67,
276 0xBF, 0xFF, 0x24, 0xC0, 0x00, 0xDA, 0xE8, 0x09,
277 0x20, 0xC0, 0xE7, 0x87, 0x40, 0x00, 0x24, 0xC0,
278 0xE7, 0x87, 0x40, 0x00, 0x24, 0xC0, 0x00, 0xDA,
279 0xE8, 0x09, 0x20, 0xC0, 0x6D, 0xC1, 0xE7, 0x87,
280 0x00, 0x01, 0x24, 0xC0, 0x97, 0xCF, 0xE7, 0x07,
281 0x32, 0x00, 0x12, 0xC0, 0xE7, 0x77, 0x00, 0x80,
282 0x12, 0xC0, 0x7C, 0xC0, 0x97, 0xCF, 0xE7, 0x07,
283 0x20, 0x4E, 0x12, 0xC0, 0xE7, 0x77, 0x00, 0x80,
284 0x12, 0xC0, 0x7C, 0xC0, 0x97, 0xCF, 0x09, 0x02,
285 0x19, 0x00, 0x01, 0x01, 0x00, 0x80, 0x96, 0x09,
286 0x04, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
287 0x07, 0x05, 0x81, 0x02, 0x40, 0x00, 0x00, 0x00,
288 0x00, 0x00, 0x00, 0x00, 0x00, 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,
312 static unsigned char setup5[] = {
313 0xB6, 0xC3, 0x2F, 0x01, 0x03, 0x64, 0x0E, 0x00,
314 0x14, 0x00, 0x1A, 0x00, 0x20, 0x00, 0x26, 0x00,
315 0x4A, 0x00, 0x64, 0x00, 0x6A, 0x00, 0x92, 0x00,
316 0x9A, 0x00, 0xA0, 0x00, 0xB2, 0x00, 0xB8, 0x00,
317 0xBE, 0x00, 0xC2, 0x00, 0xC8, 0x00, 0xCE, 0x00,
318 0xDC, 0x00, 0xDA, 0x00, 0xE2, 0x00, 0xE0, 0x00,
319 0xE8, 0x00, 0xE6, 0x00, 0xEE, 0x00, 0xEC, 0x00,
320 0xF2, 0x00, 0xF8, 0x00, 0x02, 0x01, 0x0A, 0x01,
321 0x0E, 0x01, 0x12, 0x01, 0x1E, 0x01, 0x22, 0x01,
322 0x28, 0x01, 0x2C, 0x01, 0x32, 0x01, 0x36, 0x01,
323 0x44, 0x01, 0x50, 0x01, 0x5E, 0x01, 0x72, 0x01,
324 0x76, 0x01, 0x7A, 0x01, 0x80, 0x01, 0x88, 0x01,
325 0x8C, 0x01, 0x94, 0x01, 0x9C, 0x01, 0xA0, 0x01,
326 0xA4, 0x01, 0xAA, 0x01, 0xB0, 0x01, 0xB4, 0x01,
327 0xBA, 0x01, 0xD0, 0x01, 0xDA, 0x01, 0xF6, 0x01,
328 0xFA, 0x01, 0x02, 0x02, 0x34, 0x02, 0x3C, 0x02,
329 0x44, 0x02, 0x4A, 0x02, 0x50, 0x02, 0x56, 0x02,
330 0x74, 0x02, 0x78, 0x02, 0x7E, 0x02, 0x84, 0x02,
331 0x8A, 0x02, 0x88, 0x02, 0x90, 0x02, 0x8E, 0x02,
332 0x94, 0x02, 0xA2, 0x02, 0xA8, 0x02, 0xAE, 0x02,
333 0xB4, 0x02, 0xBA, 0x02, 0xB8, 0x02, 0xC0, 0x02,
334 0xBE, 0x02, 0xC4, 0x02, 0xD0, 0x02, 0xD4, 0x02,
335 0xE0, 0x02, 0xE6, 0x02, 0xEE, 0x02, 0xF8, 0x02,
336 0xFC, 0x02, 0x06, 0x03, 0x1E, 0x03, 0x24, 0x03,
337 0x28, 0x03, 0x30, 0x03, 0x2E, 0x03, 0x3C, 0x03,
338 0x4A, 0x03, 0x4E, 0x03, 0x54, 0x03, 0x58, 0x03,
339 0x5E, 0x03, 0x66, 0x03, 0x6E, 0x03, 0x7A, 0x03,
340 0x86, 0x03, 0x8E, 0x03, 0x96, 0x03, 0xB2, 0x03,
341 0xB8, 0x03, 0xC6, 0x03, 0xCC, 0x03, 0xD4, 0x03,
342 0xDA, 0x03, 0xE8, 0x03, 0xF4, 0x03, 0xFC, 0x03,
343 0x04, 0x04, 0x20, 0x04, 0x2A, 0x04, 0x32, 0x04,
344 0x36, 0x04, 0x3E, 0x04, 0x44, 0x04, 0x42, 0x04,
345 0x48, 0x04, 0x4E, 0x04, 0x4C, 0x04, 0x54, 0x04,
346 0x52, 0x04, 0x5A, 0x04, 0x5E, 0x04, 0x62, 0x04,
347 0x68, 0x04, 0x74, 0x04, 0x7C, 0x04, 0x80, 0x04,
348 0x88, 0x04, 0x8C, 0x04, 0x94, 0x04, 0x9A, 0x04,
349 0xA2, 0x04, 0xA6, 0x04, 0xAE, 0x04, 0xB4, 0x04,
350 0xC0, 0x04, 0xCC, 0x04, 0xD8, 0x04, 0x2A, 0x05,
351 0x46, 0x05, 0x6C, 0x05, 0x00, 0x00
354 static unsigned long kvirt_to_pa(unsigned long adr)
356 unsigned long kva, ret;
358 kva = (unsigned long) page_address(vmalloc_to_page((void *)adr));
359 kva |= adr & (PAGE_SIZE-1); /* restore the offset */
364 /* rvmalloc / rvfree copied from usbvideo.c
366 * Not sure why these are not yet non-statics which I can reference through
367 * usbvideo.h the same as it is in 2.4.20. I bet this will get fixed sometime
371 static void *rvmalloc(unsigned long size)
376 size = PAGE_ALIGN(size);
377 mem = vmalloc_32(size);
381 memset(mem, 0, size); /* Clear the ram out, no junk to the user */
382 adr = (unsigned long) mem;
384 SetPageReserved(vmalloc_to_page((void *)adr));
392 static void rvfree(void *mem, unsigned long size)
399 adr = (unsigned long) mem;
400 while ((long) size > 0) {
401 ClearPageReserved(vmalloc_to_page((void *)adr));
408 struct vicam_camera {
409 u16 shutter_speed; // capture shutter speed
410 u16 gain; // capture gain
412 u8 *raw_image; // raw data captured from the camera
413 u8 *framebuf; // processed data in RGB24 format
414 u8 *cntrlbuf; // area used to send control msgs
416 struct video_device vdev; // v4l video device
417 struct usb_device *udev; // usb device
419 /* guard against simultaneous accesses to the camera */
420 struct semaphore cam_lock;
427 #if defined(CONFIG_VIDEO_PROC_FS)
428 struct proc_dir_entry *proc_dir;
433 static int vicam_probe( struct usb_interface *intf, const struct usb_device_id *id);
434 static void vicam_disconnect(struct usb_interface *intf);
435 static void read_frame(struct vicam_camera *cam, int framenum);
436 static void vicam_decode_color(const u8 *, u8 *);
438 static int __send_control_msg(struct vicam_camera *cam,
447 /* cp must be memory that has been allocated by kmalloc */
449 status = usb_control_msg(cam->udev,
450 usb_sndctrlpipe(cam->udev, 0),
452 USB_DIR_OUT | USB_TYPE_VENDOR |
453 USB_RECIP_DEVICE, value, index,
456 status = min(status, 0);
459 printk(KERN_INFO "Failed sending control message, error %d.\n",
466 static int send_control_msg(struct vicam_camera *cam,
473 int status = -ENODEV;
474 down(&cam->cam_lock);
476 status = __send_control_msg(cam, request, value,
483 initialize_camera(struct vicam_camera *cam)
489 { .data = setup1, .size = sizeof(setup1) },
490 { .data = setup2, .size = sizeof(setup2) },
491 { .data = setup3, .size = sizeof(setup3) },
492 { .data = setup4, .size = sizeof(setup4) },
493 { .data = setup5, .size = sizeof(setup5) },
494 { .data = setup3, .size = sizeof(setup3) },
495 { .data = NULL, .size = 0 }
500 for (i = 0, err = 0; firmware[i].data && !err; i++) {
501 memcpy(cam->cntrlbuf, firmware[i].data, firmware[i].size);
503 err = send_control_msg(cam, 0xff, 0, 0,
504 cam->cntrlbuf, firmware[i].size);
511 set_camera_power(struct vicam_camera *cam, int state)
515 if ((status = send_control_msg(cam, 0x50, state, 0, NULL, 0)) < 0)
519 send_control_msg(cam, 0x55, 1, 0, NULL, 0);
526 vicam_ioctl(struct inode *inode, struct file *file, unsigned int ioctlnr, unsigned long ul_arg)
528 void *arg = (void *)ul_arg;
529 struct vicam_camera *cam = file->private_data;
536 /* query capabilities */
539 struct video_capability b;
542 memset(&b, 0, sizeof(b));
543 strcpy(b.name, "ViCam-based Camera");
544 b.type = VID_TYPE_CAPTURE;
547 b.maxwidth = 320; /* VIDEOSIZE_CIF */
549 b.minwidth = 320; /* VIDEOSIZE_48_48 */
552 if (copy_to_user(arg, &b, sizeof (b)))
557 /* get/set video source - we are a camera and nothing else */
560 struct video_channel v;
562 DBG("VIDIOCGCHAN\n");
563 if (copy_from_user(&v, arg, sizeof (v))) {
567 if (v.channel != 0) {
573 strcpy(v.name, "Camera");
576 v.type = VIDEO_TYPE_CAMERA;
579 if (copy_to_user(arg, &v, sizeof (v)))
588 if (copy_from_user(&v, arg, sizeof (v)))
590 DBG("VIDIOCSCHAN %d\n", v);
592 if (retval == 0 && v != 0)
598 /* image properties */
601 struct video_picture vp;
602 DBG("VIDIOCGPICT\n");
603 memset(&vp, 0, sizeof (struct video_picture));
604 vp.brightness = cam->gain << 8;
606 vp.palette = VIDEO_PALETTE_RGB24;
608 (arg, &vp, sizeof (struct video_picture)))
615 struct video_picture vp;
617 if (copy_from_user(&vp, arg, sizeof(vp))) {
622 DBG("VIDIOCSPICT depth = %d, pal = %d\n", vp.depth,
625 cam->gain = vp.brightness >> 8;
628 || vp.palette != VIDEO_PALETTE_RGB24)
634 /* get/set capture window */
637 struct video_window vw;
650 ((void *) arg, (void *) &vw, sizeof (vw)))
653 // I'm not sure what the deal with a capture window is, it is very poorly described
654 // in the doc. So I won't support it now.
661 struct video_window vw;
663 if (copy_from_user(&vw, arg, sizeof(vw))) {
668 DBG("VIDIOCSWIN %d x %d\n", vw.width, vw.height);
670 if ( vw.width != 320 || vw.height != 240 )
679 struct video_mbuf vm;
682 DBG("VIDIOCGMBUF\n");
683 memset(&vm, 0, sizeof (vm));
685 VICAM_MAX_FRAME_SIZE * VICAM_FRAMES;
686 vm.frames = VICAM_FRAMES;
687 for (i = 0; i < VICAM_FRAMES; i++)
688 vm.offsets[i] = VICAM_MAX_FRAME_SIZE * i;
691 ((void *) arg, (void *) &vm, sizeof (vm)))
699 struct video_mmap vm;
703 ((void *) &vm, (void *) arg, sizeof (vm))) {
708 DBG("VIDIOCMCAPTURE frame=%d, height=%d, width=%d, format=%d.\n",vm.frame,vm.width,vm.height,vm.format);
710 if ( vm.frame >= VICAM_FRAMES || vm.format != VIDEO_PALETTE_RGB24 )
713 // in theory right here we'd start the image capturing
714 // (fill in a bulk urb and submit it asynchronously)
716 // Instead we're going to do a total hack job for now and
717 // retrieve the frame in VIDIOCSYNC
726 if (copy_from_user((void *) &frame, arg, sizeof (int))) {
730 DBG("VIDIOCSYNC: %d\n", frame);
732 read_frame(cam, frame);
733 vicam_decode_color(cam->raw_image,
735 frame * VICAM_MAX_FRAME_SIZE );
740 /* pointless to implement overlay with this camera */
748 /* tuner interface - we have none */
756 /* audio interface - we have none */
762 retval = -ENOIOCTLCMD;
770 vicam_open(struct inode *inode, struct file *file)
772 struct video_device *dev = video_devdata(file);
773 struct vicam_camera *cam =
774 (struct vicam_camera *) dev->priv;
779 "vicam video_device improperly initialized");
782 /* the videodev_lock held above us protects us from
783 * simultaneous opens...for now. we probably shouldn't
784 * rely on this fact forever.
787 if (cam->open_count > 0) {
789 "vicam_open called on already opened camera");
793 cam->raw_image = kmalloc(VICAM_MAX_READ_SIZE, GFP_KERNEL);
794 if (!cam->raw_image) {
798 cam->framebuf = rvmalloc(VICAM_MAX_FRAME_SIZE * VICAM_FRAMES);
799 if (!cam->framebuf) {
800 kfree(cam->raw_image);
804 cam->cntrlbuf = kmalloc(PAGE_SIZE, GFP_KERNEL);
805 if (!cam->cntrlbuf) {
806 kfree(cam->raw_image);
807 rvfree(cam->framebuf, VICAM_MAX_FRAME_SIZE * VICAM_FRAMES);
811 // First upload firmware, then turn the camera on
813 if (!cam->is_initialized) {
814 initialize_camera(cam);
816 cam->is_initialized = 1;
819 set_camera_power(cam, 1);
821 cam->needsDummyRead = 1;
824 file->private_data = cam;
830 vicam_close(struct inode *inode, struct file *file)
832 struct vicam_camera *cam = file->private_data;
834 struct usb_device *udev;
838 /* it's not the end of the world if
839 * we fail to turn the camera off.
842 set_camera_power(cam, 0);
844 kfree(cam->raw_image);
845 rvfree(cam->framebuf, VICAM_MAX_FRAME_SIZE * VICAM_FRAMES);
846 kfree(cam->cntrlbuf);
848 down(&cam->cam_lock);
851 open_count = cam->open_count;
856 if (!open_count && !udev) {
863 static void vicam_decode_color(const u8 *data, u8 *rgb)
865 /* vicam_decode_color - Convert from Vicam Y-Cr-Cb to RGB
866 * Copyright (C) 2002 Monroe Williams (monroe@pobox.com)
874 data += VICAM_HEADER_SIZE;
876 for( i = 0; i < 240; i++, data += 512 ) {
877 const int y = ( i * 242 ) / 240;
882 if ( y == 242 - 1 ) {
889 for ( j = 0; j < 320; j++, rgb += 3 ) {
890 const int x = ( j * 512 ) / 320;
891 const u8 * const src = &data[x];
893 if ( x == 512 - 1 ) {
897 Cr = ( src[prevX] - src[0] ) +
898 ( src[nextX] - src[0] );
901 Cb = ( src[prevY] - src[prevX + prevY] ) +
902 ( src[prevY] - src[nextX + prevY] ) +
903 ( src[nextY] - src[prevX + nextY] ) +
904 ( src[nextY] - src[nextX + nextY] );
907 Y = 1160 * ( src[0] + ( Cr / 2 ) - 16 );
915 if ( ( x ^ i ) & 1 ) {
920 rgb[0] = clamp( ( ( Y + ( 2017 * Cb ) ) +
921 500 ) / 900, 0, 255 );
922 rgb[1] = clamp( ( ( Y - ( 392 * Cb ) -
924 500 ) / 1000, 0, 255 );
925 rgb[2] = clamp( ( ( Y + ( 1594 * Cr ) ) +
926 500 ) / 1300, 0, 255 );
936 read_frame(struct vicam_camera *cam, int framenum)
938 unsigned char *request = cam->cntrlbuf;
943 if (cam->needsDummyRead) {
944 cam->needsDummyRead = 0;
945 read_frame(cam, framenum);
948 memset(request, 0, 16);
949 request[0] = cam->gain; // 0 = 0% gain, FF = 100% gain
951 request[1] = 0; // 512x242 capture
953 request[2] = 0x90; // the function of these two bytes
954 request[3] = 0x07; // is not yet understood
956 if (cam->shutter_speed > 60) {
959 ((-15631900 / cam->shutter_speed) + 260533) / 1000;
960 request[4] = realShutter & 0xFF;
961 request[5] = (realShutter >> 8) & 0xFF;
966 realShutter = 15600 / cam->shutter_speed - 1;
969 request[6] = realShutter & 0xFF;
970 request[7] = realShutter >> 8;
973 // Per John Markus Bjørndalen, byte at index 8 causes problems if it isn't 0
975 // bytes 9-15 do not seem to affect exposure or image quality
977 down(&cam->cam_lock);
983 n = __send_control_msg(cam, 0x51, 0x80, 0, request, 16);
987 " Problem sending frame capture control message");
991 n = usb_bulk_msg(cam->udev,
992 usb_rcvbulkpipe(cam->udev, cam->bulkEndpoint),
994 512 * 242 + 128, &actual_length, HZ*10);
997 printk(KERN_ERR "Problem during bulk read of frame data: %d\n",
1006 vicam_read( struct file *file, char *buf, size_t count, loff_t *ppos )
1008 struct vicam_camera *cam = file->private_data;
1010 DBG("read %d bytes.\n", (int) count);
1012 if (*ppos >= VICAM_MAX_FRAME_SIZE) {
1019 vicam_decode_color(cam->raw_image,
1021 0 * VICAM_MAX_FRAME_SIZE);
1024 count = min_t(size_t, count, VICAM_MAX_FRAME_SIZE - *ppos);
1026 if (copy_to_user(buf, &cam->framebuf[*ppos], count)) {
1032 if (count == VICAM_MAX_FRAME_SIZE) {
1041 vicam_mmap(struct file *file, struct vm_area_struct *vma)
1043 // TODO: allocate the raw frame buffer if necessary
1044 unsigned long page, pos;
1045 unsigned long start = vma->vm_start;
1046 unsigned long size = vma->vm_end-vma->vm_start;
1047 struct vicam_camera *cam = file->private_data;
1052 DBG("vicam_mmap: %ld\n", size);
1054 /* We let mmap allocate as much as it wants because Linux was adding 2048 bytes
1055 * to the size the application requested for mmap and it was screwing apps up.
1056 if (size > VICAM_FRAMES*VICAM_MAX_FRAME_SIZE)
1060 pos = (unsigned long)cam->framebuf;
1062 page = kvirt_to_pa(pos);
1063 if (remap_page_range(vma, start, page, PAGE_SIZE, PAGE_SHARED))
1068 if (size > PAGE_SIZE)
1077 #if defined(CONFIG_VIDEO_PROC_FS)
1079 static struct proc_dir_entry *vicam_proc_root = NULL;
1081 static int vicam_read_helper(char *page, char **start, off_t off,
1082 int count, int *eof, int value)
1087 out += sprintf(out, "%d",value);
1098 *start = page + off;
1102 static int vicam_read_proc_shutter(char *page, char **start, off_t off,
1103 int count, int *eof, void *data)
1105 return vicam_read_helper(page,start,off,count,eof,
1106 ((struct vicam_camera *)data)->shutter_speed);
1109 static int vicam_read_proc_gain(char *page, char **start, off_t off,
1110 int count, int *eof, void *data)
1112 return vicam_read_helper(page,start,off,count,eof,
1113 ((struct vicam_camera *)data)->gain);
1117 vicam_write_proc_shutter(struct file *file, const char *buffer,
1118 unsigned long count, void *data)
1122 struct vicam_camera *cam = (struct vicam_camera *) data;
1127 if (copy_from_user(kbuf, buffer, count))
1130 stmp = (u16) simple_strtoul(kbuf, NULL, 10);
1131 if (stmp < 4 || stmp > 32000)
1134 cam->shutter_speed = stmp;
1140 vicam_write_proc_gain(struct file *file, const char *buffer,
1141 unsigned long count, void *data)
1146 struct vicam_camera *cam = (struct vicam_camera *) data;
1151 if (copy_from_user(kbuf, buffer, count))
1154 gtmp = (u16) simple_strtoul(kbuf, NULL, 10);
1163 vicam_create_proc_root(void)
1165 vicam_proc_root = create_proc_entry("video/vicam", S_IFDIR, 0);
1167 if (vicam_proc_root)
1168 vicam_proc_root->owner = THIS_MODULE;
1171 "could not create /proc entry for vicam!");
1175 vicam_destroy_proc_root(void)
1177 if (vicam_proc_root)
1178 remove_proc_entry("video/vicam", 0);
1182 vicam_create_proc_entry(struct vicam_camera *cam)
1185 struct proc_dir_entry *ent;
1187 DBG(KERN_INFO "vicam: creating proc entry\n");
1189 if (!vicam_proc_root || !cam) {
1191 "vicam: could not create proc entry, %s pointer is null.\n",
1192 (!cam ? "camera" : "root"));
1196 sprintf(name, "video%d", cam->vdev.minor);
1198 cam->proc_dir = create_proc_entry(name, S_IFDIR, vicam_proc_root);
1200 if ( !cam->proc_dir )
1201 return; // FIXME: We should probably return an error here
1203 ent = create_proc_entry("shutter", S_IFREG | S_IRUGO | S_IWUSR,
1207 ent->read_proc = vicam_read_proc_shutter;
1208 ent->write_proc = vicam_write_proc_shutter;
1212 ent = create_proc_entry("gain", S_IFREG | S_IRUGO | S_IWUSR,
1216 ent->read_proc = vicam_read_proc_gain;
1217 ent->write_proc = vicam_write_proc_gain;
1223 vicam_destroy_proc_entry(void *ptr)
1225 struct vicam_camera *cam = (struct vicam_camera *) ptr;
1228 if ( !cam->proc_dir )
1231 sprintf(name, "video%d", cam->vdev.minor);
1232 remove_proc_entry("shutter", cam->proc_dir);
1233 remove_proc_entry("gain", cam->proc_dir);
1234 remove_proc_entry(name,vicam_proc_root);
1235 cam->proc_dir = NULL;
1240 static inline void vicam_create_proc_root(void) { }
1241 static inline void vicam_destroy_proc_root(void) { }
1242 static inline void vicam_create_proc_entry(struct vicam_camera *cam) { }
1243 static inline void vicam_destroy_proc_entry(void *ptr) { }
1246 static struct file_operations vicam_fops = {
1247 .owner = THIS_MODULE,
1249 .release = vicam_close,
1252 .ioctl = vicam_ioctl,
1253 .llseek = no_llseek,
1256 static struct video_device vicam_template = {
1257 .owner = THIS_MODULE,
1258 .name = "ViCam-based USB Camera",
1259 .type = VID_TYPE_CAPTURE,
1260 .hardware = VID_HARDWARE_VICAM,
1261 .fops = &vicam_fops,
1265 /* table of devices that work with this driver */
1266 static struct usb_device_id vicam_table[] = {
1267 {USB_DEVICE(USB_VICAM_VENDOR_ID, USB_VICAM_PRODUCT_ID)},
1268 {} /* Terminating entry */
1271 MODULE_DEVICE_TABLE(usb, vicam_table);
1273 static struct usb_driver vicam_driver = {
1274 .owner = THIS_MODULE,
1276 .probe = vicam_probe,
1277 .disconnect = vicam_disconnect,
1278 .id_table = vicam_table
1283 * @intf: the interface
1284 * @id: the device id
1286 * Called by the usb core when a new device is connected that it thinks
1287 * this driver might be interested in.
1290 vicam_probe( struct usb_interface *intf, const struct usb_device_id *id)
1292 struct usb_device *dev = interface_to_usbdev(intf);
1293 int bulkEndpoint = 0;
1294 const struct usb_host_interface *interface;
1295 const struct usb_endpoint_descriptor *endpoint;
1296 struct vicam_camera *cam;
1298 /* See if the device offered us matches what we can accept */
1299 if ((dev->descriptor.idVendor != USB_VICAM_VENDOR_ID) ||
1300 (dev->descriptor.idProduct != USB_VICAM_PRODUCT_ID)) {
1304 printk(KERN_INFO "ViCam based webcam connected\n");
1306 interface = &intf->altsetting[0];
1308 DBG(KERN_DEBUG "Interface %d. has %u. endpoints!\n",
1309 interface->desc.bInterfaceNumber, (unsigned) (interface->desc.bNumEndpoints));
1310 endpoint = &interface->endpoint[0].desc;
1312 if ((endpoint->bEndpointAddress & 0x80) &&
1313 ((endpoint->bmAttributes & 3) == 0x02)) {
1314 /* we found a bulk in endpoint */
1315 bulkEndpoint = endpoint->bEndpointAddress;
1318 "No bulk in endpoint was found ?! (this is bad)\n");
1322 kmalloc(sizeof (struct vicam_camera), GFP_KERNEL)) == NULL) {
1324 "could not allocate kernel memory for vicam_camera struct\n");
1328 memset(cam, 0, sizeof (struct vicam_camera));
1330 cam->shutter_speed = 15;
1332 init_MUTEX(&cam->cam_lock);
1334 memcpy(&cam->vdev, &vicam_template,
1335 sizeof (vicam_template));
1336 cam->vdev.priv = cam; // sort of a reverse mapping for those functions that get vdev only
1339 cam->bulkEndpoint = bulkEndpoint;
1341 if (video_register_device(&cam->vdev, VFL_TYPE_GRABBER, -1) == -1) {
1343 printk(KERN_WARNING "video_register_device failed\n");
1347 vicam_create_proc_entry(cam);
1349 printk(KERN_INFO "ViCam webcam driver now controlling video device %d\n",cam->vdev.minor);
1351 usb_set_intfdata (intf, cam);
1357 vicam_disconnect(struct usb_interface *intf)
1360 struct vicam_camera *cam = usb_get_intfdata (intf);
1361 usb_set_intfdata (intf, NULL);
1363 /* we must unregister the device before taking its
1364 * cam_lock. This is because the video open call
1365 * holds the same lock as video unregister. if we
1366 * unregister inside of the cam_lock and open also
1367 * uses the cam_lock, we get deadlock.
1370 video_unregister_device(&cam->vdev);
1372 /* stop the camera from being used */
1374 down(&cam->cam_lock);
1376 /* mark the camera as gone */
1380 vicam_destroy_proc_entry(cam);
1382 /* the only thing left to do is synchronize with
1383 * our close/release function on who should release
1384 * the camera memory. if there are any users using the
1385 * camera, it's their job. if there are no users,
1389 open_count = cam->open_count;
1397 printk(KERN_DEBUG "ViCam-based WebCam disconnected\n");
1403 usb_vicam_init(void)
1406 DBG(KERN_INFO "ViCam-based WebCam driver startup\n");
1407 vicam_create_proc_root();
1408 retval = usb_register(&vicam_driver);
1410 printk(KERN_WARNING "usb_register failed!\n");
1415 usb_vicam_exit(void)
1418 "ViCam-based WebCam driver shutdown\n");
1420 usb_deregister(&vicam_driver);
1421 vicam_destroy_proc_root();
1424 module_init(usb_vicam_init);
1425 module_exit(usb_vicam_exit);
1427 MODULE_AUTHOR(DRIVER_AUTHOR);
1428 MODULE_DESCRIPTION(DRIVER_DESC);
1429 MODULE_LICENSE("GPL");